scoring

• EnergiesCacheableDataType
• aa_composition_energy
• annealing
• atomic_depth
• bin_transitions
• carbohydrates
• carbon_hbonds
• constraints
• cryst
• custom_pair_distance
• disulfides
• dna
• dssp
• elec
• electron_density
• electron_density_atomwise
• epr_deer
• etable
• facts
• fiber_diffraction
• func
• geometric_solvation
• hbonds
• interface
• lkball
• loop_graph
• magnesium
• membrane
• methods
• mhc_epitope_energy
• mm
• motif
• netcharge_energy
• nmr
• 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_object

APBSConfig

class I_PARAM

Bases: pybind11_object

I_PARAM

property apol_calcenergy

property apol_calcforce

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

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

property bcfl

property calcenergy

property calcforce

property chgm

property coarse_centering_mode

property fine_centering_mode

property grid_centering_mode

property iparam19

property nions

property nlev

property pbe_mode

raw_array(self: pyrosetta.rosetta.core.scoring.APBSConfig.I_PARAM) → int

C++: core::scoring::APBSConfig::I_PARAM::raw_array() –> int *

property sim_type

property srfm

property use_charge

property use_diel

property use_kappa

property use_pot

property write_atompot

property write_charge

property write_diel

property write_kappa

property write_pot

property write_smol

class R_PARAM

Bases: pybind11_object

R_PARAM

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

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

property gamma

property nsdie

property pdie

raw_array(self: pyrosetta.rosetta.core.scoring.APBSConfig.R_PARAM) → float

C++: core::scoring::APBSConfig::R_PARAM::raw_array() –> double *

property sdens

property smpbe_size

property smpbe_vol

property srad

property swin

property temp

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 &

property calcenergy

property cfac

property dbg

property fadd

property i_param

property natoms

property nsims

property ofrac

property r_param

property space

class pyrosetta.rosetta.core.scoring.APBSResult

Bases: pybind11_object

APBSResult

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

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

property dbx

property dby

property dbz

property dx

property dy

property dz

property esEnergy

property grid_data

property ibx

property iby

property ibz

property npEnergy

property npx

property npy

property npz

property nwrites

property qfx

property qfy

property qfz

class pyrosetta.rosetta.core.scoring.APBSWrapper

Bases: pybind11_object

APBS wrapper

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

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

exec(self: pyrosetta.rosetta.core.scoring.APBSWrapper) → core::scoring::APBSResult

C++: core::scoring::APBSWrapper::exec() –> class std::shared_ptr<const class core::scoring::APBSResult>

class pyrosetta.rosetta.core.scoring.AtomNeighbor

Bases: pybind11_object

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

The logic for using the nblist is tricky.

Tentative scheme: turn on nblist scoring at start of minimization

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

pose.energies().setup_use_nblist( true );

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

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

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

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

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

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

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

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

atomno(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → int

C++: core::scoring::AtomNeighbor::atomno() const –> int

path_dist(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → int

C++: core::scoring::AtomNeighbor::path_dist() const –> unsigned long

rsd(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → int

C++: core::scoring::AtomNeighbor::rsd() const –> int

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

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

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

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

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

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

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

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

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

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

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

fpd

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

class pyrosetta.rosetta.core.scoring.AtomVDW

Bases: pybind11_object

approximate_vdw_radius(self: pyrosetta.rosetta.core.scoring.AtomVDW, atom_type_index: int) → float

C++: core::scoring::AtomVDW::approximate_vdw_radius(const unsigned long) const –> double

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

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

atom_type_set_name(self: pyrosetta.rosetta.core.scoring.AtomVDW) → str

C++: core::scoring::AtomVDW::atom_type_set_name() const –> std::string

class pyrosetta.rosetta.core.scoring.BB_Pos

Bases: pybind11_object

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

resize(self: pyrosetta.rosetta.core.scoring.BB_Pos, nres: int) → None

C++: core::scoring::BB_Pos::resize(const int) –> void

take_coordinates_from_pose(self: pyrosetta.rosetta.core.scoring.BB_Pos, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::BB_Pos::take_coordinates_from_pose(const class core::pose::Pose &) –> void

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

Overloaded function.

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 &, const 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 &, const 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 &, const 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_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

property CSAval_computed_

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>

property f1ij_

f2ij(self: pyrosetta.rosetta.core.scoring.CSA) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::CSA::f2ij() const –> class numeric::xyzVector<double>

property f2ij_

f3ij(self: pyrosetta.rosetta.core.scoring.CSA) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::CSA::f3ij() const –> class numeric::xyzVector<double>

property f3ij_

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(std::ostream &) 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.CenHBPotential

Bases: pybind11_object

add_lr_gaussian(self: pyrosetta.rosetta.core.scoring.CenHBPotential, A_in: float, mu_in: pyrosetta.rosetta.numeric.xyzVector_double_t, sigma_in: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::CenHBPotential::add_lr_gaussian(double, class numeric::xyzVector<double>, class numeric::xyzVector<double>) –> void

add_sr_gaussian(self: pyrosetta.rosetta.core.scoring.CenHBPotential, A_in: float, mu_in: pyrosetta.rosetta.numeric.xyzVector_double_t, sigma_in: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::CenHBPotential::add_sr_gaussian(double, class numeric::xyzVector<double>, class numeric::xyzVector<double>) –> void

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

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

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

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

cutoff(self: pyrosetta.rosetta.core.scoring.CenHBPotential, seqsep: int) → float

C++: core::scoring::CenHBPotential::cutoff(unsigned long) const –> double

dfunc(self: pyrosetta.rosetta.core.scoring.CenHBPotential, seqsep: int, d: float, xd: float, xh: float) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::CenHBPotential::dfunc(unsigned long, double, double, double) const –> class numeric::xyzVector<double>

dfunc_soft(self: pyrosetta.rosetta.core.scoring.CenHBPotential, a1: pyrosetta.rosetta.numeric.xyzVector_double_t, a2: pyrosetta.rosetta.numeric.xyzVector_double_t, b1: pyrosetta.rosetta.numeric.xyzVector_double_t, b2: pyrosetta.rosetta.numeric.xyzVector_double_t, dv: pyrosetta.rosetta.numeric.xyzVector_double_t, df_dABNC_1: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t, df_dABNC_2: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t) → None

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

func(self: pyrosetta.rosetta.core.scoring.CenHBPotential, seqsep: int, d: float, xd: float, xh: float) → float

C++: core::scoring::CenHBPotential::func(unsigned long, double, double, double) const –> double

func_soft(self: pyrosetta.rosetta.core.scoring.CenHBPotential, a1: pyrosetta.rosetta.numeric.xyzVector_double_t, a2: pyrosetta.rosetta.numeric.xyzVector_double_t, b1: pyrosetta.rosetta.numeric.xyzVector_double_t, b2: pyrosetta.rosetta.numeric.xyzVector_double_t, dv: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

C++: core::scoring::CenHBPotential::func_soft(class numeric::xyzVector<double>, class numeric::xyzVector<double>, class numeric::xyzVector<double>, class numeric::xyzVector<double>, class numeric::xyzVector<double>) const –> double

nlr_gaussians(self: pyrosetta.rosetta.core.scoring.CenHBPotential) → int

C++: core::scoring::CenHBPotential::nlr_gaussians() const –> unsigned long

nsr_gaussians(self: pyrosetta.rosetta.core.scoring.CenHBPotential) → int

C++: core::scoring::CenHBPotential::nsr_gaussians() const –> unsigned long

set_cutoff_lr(self: pyrosetta.rosetta.core.scoring.CenHBPotential, cut_in: float) → None

C++: core::scoring::CenHBPotential::set_cutoff_lr(double) –> void

set_cutoff_sr(self: pyrosetta.rosetta.core.scoring.CenHBPotential, cut_in: float) → None

C++: core::scoring::CenHBPotential::set_cutoff_sr(double) –> void

class pyrosetta.rosetta.core.scoring.CenListInfo

Bases: CacheableData

Keep track of the cenlist information

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

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

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

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

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

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

fcen10(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int) → float

C++: core::scoring::CenListInfo::fcen10(const unsigned long) –> double &

fcen12(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int) → float

C++: core::scoring::CenListInfo::fcen12(const unsigned long) –> double &

fcen6(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int) → float

C++: core::scoring::CenListInfo::fcen6(const unsigned long) –> double &

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

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

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

set_fcen10(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int, value: float) → None

C++: core::scoring::CenListInfo::set_fcen10(const unsigned long, double) –> void

set_fcen12(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int, value: float) → None

C++: core::scoring::CenListInfo::set_fcen12(const unsigned long, double) –> void

set_fcen6(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int, value: float) → None

C++: core::scoring::CenListInfo::set_fcen6(const unsigned long, double) –> void

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

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

class pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential

Bases: pybind11_object

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

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

compute_centroid_environment(self: pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::CenRotEnvPairPotential::compute_centroid_environment(class core::pose::Pose &) const –> void

compute_dcentroid_environment(self: pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::CenRotEnvPairPotential::compute_dcentroid_environment(class core::pose::Pose &) const –> void

evaluate_cen_rot_env_and_cbeta_deriv(self: pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, f2_cen_env: pyrosetta.rosetta.numeric.xyzVector_double_t, f2_cen_cb6: pyrosetta.rosetta.numeric.xyzVector_double_t, f2_cen_cb12: pyrosetta.rosetta.numeric.xyzVector_double_t, f2_cb_env: pyrosetta.rosetta.numeric.xyzVector_double_t, f2_cb_cb6: pyrosetta.rosetta.numeric.xyzVector_double_t, f2_cb_cb12: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::CenRotEnvPairPotential::evaluate_cen_rot_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> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

evaluate_cen_rot_env_and_cbeta_score(self: pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, env_contribution: float, cbeta6_contribution: float, cbeta12_contribution: float) → None

env

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

evaluate_cen_rot_pair_deriv(self: pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, d_pair: float) → None

C++: core::scoring::CenRotEnvPairPotential::evaluate_cen_rot_pair_deriv(const class core::conformation::Residue &, const class core::conformation::Residue &, const double, double &) const –> void

evaluate_cen_rot_pair_orientation_deriv(self: pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, ang: float, dE_dr: float, dE_d_ang: float, dE_d_dih: float) → None

C++: core::scoring::CenRotEnvPairPotential::evaluate_cen_rot_pair_orientation_deriv(const class core::conformation::Residue &, const class core::conformation::Residue &, const double, const double, double &, double &, double &) const –> void

evaluate_cen_rot_pair_orientation_score(self: pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, ang1_contribution: float, ang2_contribution: float, dih_contribution: float) → None

C++: core::scoring::CenRotEnvPairPotential::evaluate_cen_rot_pair_orientation_score(const class core::conformation::Residue &, const class core::conformation::Residue &, const double, double &, double &, double &) const –> void

evaluate_cen_rot_pair_score(self: pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, pair_contribution: float) → None

pair

C++: core::scoring::CenRotEnvPairPotential::evaluate_cen_rot_pair_score(const class core::conformation::Residue &, const class core::conformation::Residue &, const double, double &) const –> void

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

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

class pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy

Bases: CacheableData

ChemicalShiftAnisotropys are mainly handled by this class

related classed: CSA — a single line in an CSA file - representing a single csa coupling

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

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

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

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

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

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

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

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

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

get the raw CSA data

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

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

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

C++: core::scoring::ChemicalShiftAnisotropy::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.scoring.ContextGraph

Bases: Graph

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 *

all_pairs_shortest_paths(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.ObjexxFCL.FArray2D_int_t

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.ContextGraph, : pyrosetta.rosetta.core.scoring.ContextGraph) → pyrosetta.rosetta.core.scoring.ContextGraph

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

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

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

conditionally_add_edge(self: pyrosetta.rosetta.core.scoring.ContextGraph, lower_node_id: int, upper_node_id: int, dsq: float) → None

C++: core::scoring::ContextGraph::conditionally_add_edge(unsigned long, unsigned long, double) –> void

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.utility.graph.Graph, edge: pyrosetta.rosetta.utility.graph.Edge) → None

remove an edge from the graph. (NEW AS OF 12/9/07) Never call C++’s

“delete” function on an edge pointer directly. Derived classes must implement this function. If they wish to use unordered_object_pools to manage their memory

C++: utility::graph::Graph::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 *

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

neighbor_cutoff(self: pyrosetta.rosetta.core.scoring.ContextGraph) → float

C++: core::scoring::ContextGraph::neighbor_cutoff() const –> double

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(std::ostream &) 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(std::ostream &) 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_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

update_from_pose(self: pyrosetta.rosetta.core.scoring.ContextGraph, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::ContextGraph::update_from_pose(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.core.scoring.ContextGraphFactory

Bases: pybind11_object

static create_context_graph(type: pyrosetta.rosetta.core.scoring.ContextGraphType) → pyrosetta.rosetta.core.scoring.ContextGraph

C++: core::scoring::ContextGraphFactory::create_context_graph(enum core::scoring::ContextGraphType) –> class std::shared_ptr<class core::scoring::ContextGraph>

class pyrosetta.rosetta.core.scoring.ContextGraphType

Bases: pybind11_object

Members:

ten_A_neighbor_graph

twelve_A_neighbor_graph

centroid_neighbor_graph

num_context_graph_types

centroid_neighbor_graph = <ContextGraphType.centroid_neighbor_graph: 3>

property name

num_context_graph_types = <ContextGraphType.centroid_neighbor_graph: 3>

ten_A_neighbor_graph = <ContextGraphType.ten_A_neighbor_graph: 1>

twelve_A_neighbor_graph = <ContextGraphType.twelve_A_neighbor_graph: 2>

property value

class pyrosetta.rosetta.core.scoring.DC

Bases: pybind11_object

class DC_TYPE

Bases: pybind11_object

Members:

DC_TYPE_NH

DC_TYPE_NC

DC_TYPE_CH

DC_TYPE_CC

DC_TYPE_CC = <DC_TYPE.DC_TYPE_CC: 4>

DC_TYPE_CH = <DC_TYPE.DC_TYPE_CH: 3>

DC_TYPE_NC = <DC_TYPE.DC_TYPE_NC: 2>

DC_TYPE_NH = <DC_TYPE.DC_TYPE_NH: 1>

property name

property value

DC_TYPE_CC = <DC_TYPE.DC_TYPE_CC: 4>

DC_TYPE_CH = <DC_TYPE.DC_TYPE_CH: 3>

DC_TYPE_NC = <DC_TYPE.DC_TYPE_NC: 2>

DC_TYPE_NH = <DC_TYPE.DC_TYPE_NH: 1>

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

property DCval_computed_

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

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

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

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

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

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

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

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

f1ij(self: pyrosetta.rosetta.core.scoring.DC) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::DC::f1ij() const –> class numeric::xyzVector<double>

property f1ij_

f2ij(self: pyrosetta.rosetta.core.scoring.DC) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::DC::f2ij() const –> class numeric::xyzVector<double>

property f2ij_

get_DC_data_type(self: pyrosetta.rosetta.core.scoring.DC, atom1: str, atom2: str) → pyrosetta.rosetta.core.scoring.DC.DC_TYPE

C++: core::scoring::DC::get_DC_data_type(const std::string &, const std::string &) –> 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(std::ostream &) const –> void

type(self: pyrosetta.rosetta.core.scoring.DC) → pyrosetta.rosetta.core.scoring.DC.DC_TYPE

C++: core::scoring::DC::type() const –> enum core::scoring::DC::DC_TYPE

weight(self: pyrosetta.rosetta.core.scoring.DC) → float

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

class pyrosetta.rosetta.core.scoring.DenseEnergyContainer

Bases: LREnergyContainer

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator

Bases: ResidueNeighborConstIterator

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

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

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

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

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

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

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

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

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

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

pre_increment(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: ResidueNeighborIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pre_increment(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.DensityZscoresStatsSetup

Bases: pybind11_object

eval_zscore_by_resn_bfactor(self: pyrosetta.rosetta.core.scoring.DensityZscoresStatsSetup, input_val: float, resn: str, bfactor: float, window_size: int) → float

C++: core::scoring::DensityZscoresStatsSetup::eval_zscore_by_resn_bfactor(const double, const std::string &, const double, const unsigned long) const –> double

class pyrosetta.rosetta.core.scoring.DerivVectorPair

Bases: pybind11_object

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

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

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

f1(self: pyrosetta.rosetta.core.scoring.DerivVectorPair) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::DerivVectorPair::f1() –> class numeric::xyzVector<double> &

f2(self: pyrosetta.rosetta.core.scoring.DerivVectorPair) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::DerivVectorPair::f2() –> class numeric::xyzVector<double> &

class pyrosetta.rosetta.core.scoring.DipolarCoupling

Bases: CacheableData

DipolarCouplings are mainly handled by this class

related classed: DC — a single line in an DC file - representing a single dc coupling

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

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

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

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

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

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

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

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

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

get the raw DC data

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

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

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

C++: core::scoring::DipolarCoupling::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.scoring.DockingScoreFunction

Bases: ScoreFunction

_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 std::string &, 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(std::istream &, bool, const std::string &) –> 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: pyrosetta.rosetta.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: pyrosetta.rosetta.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 std::string &) –> void

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 std::string &) –> 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(*args, **kwargs)

Overloaded function.

1. assign(self: pyrosetta.rosetta.core.scoring.DockingScoreFunction, src: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

INTERNAL USE ONLY

C++: core::scoring::DockingScoreFunction::assign(const class core::scoring::ScoreFunction &) –> void

2. assign(self: pyrosetta.rosetta.core.scoring.DockingScoreFunction, src: pyrosetta.rosetta.core.scoring.DockingScoreFunction) -> None

INTERNAL USE ONLY

C++: core::scoring::DockingScoreFunction::assign(const class core::scoring::DockingScoreFunction &) –> 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_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_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_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_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.DockingScoreFunction) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::scoring::DockingScoreFunction::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) → pyrosetta.rosetta.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: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, 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: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) → 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

static extract_weights_from_file(*args, **kwargs)

Overloaded function.

1. extract_weights_from_file(filename: str) -> pyrosetta.rosetta.core.scoring.EMapVector

2. extract_weights_from_file(filename: str, patch: bool) -> pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunction::extract_weights_from_file(const std::string &, bool) –> class core::scoring::EMapVector

static extract_weights_from_stream(*args, **kwargs)

Overloaded function.

1. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream) -> pyrosetta.rosetta.core.scoring.EMapVector

2. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream, patch: bool) -> pyrosetta.rosetta.core.scoring.EMapVector

3. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream, patch: bool, filename: str) -> pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunction::extract_weights_from_stream(std::istream &, bool, const std::string &) –> class core::scoring::EMapVector

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

finalize_after_minimizing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

Called after minimization.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoreFunction::finalize_after_minimizing(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 –> 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 std::string &) –> void

static list_options_read(options_read: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: core::scoring::DockingScoreFunction::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

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

provide_citation_info(self: pyrosetta.rosetta.core.scoring.ScoreFunction, citations: pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

This allows the scorefunciton to provide citaitons for itself itself and for any modules that it invokes (particularl energy methods).

The default implementation of this provides a vector of citations from all energy methods that

C++: core::scoring::ScoreFunction::provide_citation_info(class basic::citation_manager::CitationCollectionList &) 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: pyrosetta.rosetta.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 std::string &) –> 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: pyrosetta.rosetta.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: pyrosetta.rosetta.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: pyrosetta.rosetta.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_packing_with_rotsets(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, rotsets: core::pack_basic::RotamerSetsBase) → None

Lets the scoring functions cache anything they need to calculate

energies in a packing step (pack_rotamers) in the context of all available rotamers

The exact order of events when setting up for packing are as follows:

1. setup_for_packing() is called for all energy methods

2. rotamers are built

3. setup_for_packing_with_rotsets() is called for all energy methods

4. prepare_rotamers_for_packing() is called for all energy methods

5. The energy methods are asked to score all rotamers and rotamer pairs

6. Annealing begins

The pose is specifically non-const here so that energy methods can store data in it

: Used in ApproximateBuriedUnsatPenalty to pre-compute compatible rotamers

C++: core::scoring::ScoreFunction::setup_for_packing_with_rotsets(class core::pose::Pose &, const class std::shared_ptr<class core::pack_basic::RotamerSetsBase> &) 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(std::ostream &) 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(std::ostream &, 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(std::ostream &, 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(std::ostream &, 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(std::ostream &) 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(std::ostream &) 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

weighted_sum(self: pyrosetta.rosetta.core.scoring.ScoreFunction, unweighted: pyrosetta.rosetta.core.scoring.EMapVector) → float

Returns the weighted sum of the given energy map, given the current set of weights

example(s):

scorefxn.weighted_sum(scores_emap)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreFunction.weights

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

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

class pyrosetta.rosetta.core.scoring.EMapVector

Bases: pybind11_object

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

: several methods using EMapVector objects add in values,

be sure to use the zero method between uses

Common Methods:

EMapVector.zero

accumulate(*args, **kwargs)

Overloaded function.

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, : 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) const –> double

is_finite(self: pyrosetta.rosetta.core.scoring.EMapVector) → bool

Check that there aren’t any non-finite (inf, NaN) entries.

C++: core::scoring::EMapVector::is_finite() const –> bool

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> > &) const –> 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(std::ostream &, 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(std::ostream &) 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(std::ostream &, 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() const –> 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_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.

active_total_energies()

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

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

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

kill everything (that nobody forgot about)

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

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

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

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

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

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

context_graph(self: pyrosetta.rosetta.core.scoring.Energies, type: pyrosetta.rosetta.core.scoring.ContextGraphType) → pyrosetta.rosetta.core.scoring.ContextGraph

C++: core::scoring::Energies::context_graph(enum core::scoring::ContextGraphType) –> class std::shared_ptr<class core::scoring::ContextGraph>

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

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

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

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

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

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

domain_map(*args, **kwargs)

Overloaded function.

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) -> pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t

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>

nonzero_weights(out=None)

Gets energy terms weights in the given energies object. returns:

{ score_term : score_weight }

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_onebody_energies_array(residue_selection=None, out=None)

Gets table of energy terms with non-zero weight on a per-residue basis. returns:

structure_array of shape n_residue, with per-score-term entries

residue_pair_energies_array(from_residue_selection=None, to_residue_selection=None)

Generate pair energy table from the given energies object. returns: energy_table - 2d energy type structured array.

shape - (energies.size, energies.size) dtype - [(<type>, float)] for every nonzero weight energy type.

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_energies_array(residue_selection=None, out=None)

Gets table of energy terms with non-zero weight on a per-residue basis. returns:

structure_array of shape n_residue, with per-score-term entries

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: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, 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(std::ostream &) const –> void

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

C++: core::scoring::Energies::show(std::ostream &, 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(std::ostream &) const –> void

show_totals(self: pyrosetta.rosetta.core.scoring.Energies, out: pyrosetta.rosetta.std.ostream) → None

C++: core::scoring::Energies::show_totals(std::ostream &) const –> void

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

Returns the number of held residue energies

example(s):

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

See also:

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

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

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

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

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

const b/c called inside const access methods

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

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

Write access to the graph encoding # neighbors within 10 Angstroms

If the graph has not been requested up until this point, then it will be instantiated and filled. If the pose has changed size since the last score function evaluation (or if the pose has never been scored) this function will exit.

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

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

Returns a non-const reference to the total_energies EnergyMap

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

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

total_energies_array(out=None)

Get total structured dtype with non-zero energies.

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

Returns the weighted total energies.

C++: core::scoring::Energies::total_energies_weighted() const –> 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: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, 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: Edge

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

add_to_energy_map(*args, **kwargs)

Overloaded function.

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

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

active_2b_score_types(self: pyrosetta.rosetta.core.scoring.EnergyGraph) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

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

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

Set the active score types, and return true if the new score types

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

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

add_edge(*args, **kwargs)

Overloaded function.

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) → pyrosetta.rosetta.ObjexxFCL.FArray2D_int_t

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(std::ostream &) 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(std::ostream &) 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: Node

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

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

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

list element

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

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

returns a const iterator to the beginning of its edge list

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

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

returns a const iterator to the end of its edge list

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

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

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

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

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

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

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

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

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

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

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

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

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

copy_from(self: pyrosetta.rosetta.core.scoring.EnergyNode, source: pyrosetta.rosetta.utility.graph.Node) → None

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

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.EnergyNode) → int

C++: core::scoring::EnergyNode::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.EnergyNode) → int

C++: core::scoring::EnergyNode::count_static_memory() const –> unsigned long

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

deletes all edges incident upon this node

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

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

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

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

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

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

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

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

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

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

find_edge(self: pyrosetta.rosetta.utility.graph.Node, other_node_index: int) → utility::graph::Edge

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

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

the index for this node

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

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

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

is present

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

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

the number of lower neighbors

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

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

NOTE TO SELF: remove loop support

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

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

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

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

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

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

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

moved(*args, **kwargs)

Overloaded function.

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

Bases: pybind11_object

static 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

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.EnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

static 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.ExcludedResPredicate

Bases: Predicate

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

Bases: CacheableData

add_residue_exclude_torsions(self: pyrosetta.rosetta.core.scoring.GenBondedExclInfo, rsd_type: pyrosetta.rosetta.core.chemical.ResidueType) → None

C++: core::scoring::GenBondedExclInfo::add_residue_exclude_torsions(const class core::chemical::ResidueType &) –> void

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

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

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

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

get_residue_data(self: pyrosetta.rosetta.core.scoring.GenBondedExclInfo, rsd_type: pyrosetta.rosetta.core.chemical.ResidueType) → pyrosetta.rosetta.core.scoring.ResidueExclParams

C++: core::scoring::GenBondedExclInfo::get_residue_data(const class core::chemical::ResidueType &) const –> class std::shared_ptr<const class core::scoring::ResidueExclParams>

get_residue_pair_data(self: pyrosetta.rosetta.core.scoring.GenBondedExclInfo, seqpos1: int, seqpos2: int) → pyrosetta.rosetta.core.scoring.ResidueExclParams

C++: core::scoring::GenBondedExclInfo::get_residue_pair_data(unsigned long, unsigned long) const –> class std::shared_ptr<const class core::scoring::ResidueExclParams>

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>

class pyrosetta.rosetta.core.scoring.GenBornPoseInfo

Bases: CacheableData

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

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

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

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

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

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

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

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

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

placeholder_info(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, seqpos: int) → pyrosetta.rosetta.core.scoring.GenBornResidueInfo

C++: core::scoring::GenBornPoseInfo::placeholder_info(const unsigned long) const –> const class core::scoring::GenBornResidueInfo &

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

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

residue_info(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, i: int) → pyrosetta.rosetta.core.scoring.GenBornResidueInfo

C++: core::scoring::GenBornPoseInfo::residue_info(const unsigned long) –> class core::scoring::GenBornResidueInfo &

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

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

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

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

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

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

class pyrosetta.rosetta.core.scoring.GenBornPotential

Bases: pybind11_object

eval_atom_derivative(self: pyrosetta.rosetta.core.scoring.GenBornPotential, id: pyrosetta.rosetta.core.id.AtomID, weight: float, pose: pyrosetta.rosetta.core.pose.Pose, domain_map: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, 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_object

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

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

atomic_radius(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, atm: int) → float

C++: core::scoring::GenBornResidueInfo::atomic_radius(const unsigned long) –> double &

born_radius(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, atm: int) → float

C++: core::scoring::GenBornResidueInfo::born_radius(const unsigned long) –> double &

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

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

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

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

scale_factor(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, atm: int) → float

C++: core::scoring::GenBornResidueInfo::scale_factor(const unsigned long) –> double &

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

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

class pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo

Bases: CacheableData

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

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

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

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

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

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

dont forget to 0 the born_radii

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

residue_info(self: pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo, i: int) → pyrosetta.rosetta.core.scoring.GenBornResidueInfo

C++: core::scoring::GenBornRotamerSetInfo::residue_info(const unsigned long) –> class core::scoring::GenBornResidueInfo &

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

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

class pyrosetta.rosetta.core.scoring.GenTorsionParams

Bases: pybind11_object

Parameter set for one torsion angle

Stores a set of constants required for enumerating a Karplus

cosine function given torsion angle as variable. This set of parameters are required for regular torsion term (gen_bonded_torsion) scoring. More descriptions below:

E = sum_over_n { k_n * cos(n*x - f_n) } + offset

E: Energy value n: order of Karplus equation, from 1 to 4 x: variable of the function (torsion angle in this case) k1_ ~ k4_: coefficients k_n for each order of n f1_ ~ f4_: phases f_n for each order of n k6_: sixth order k; used only in special case (not included in default params) mult_: the specificity/generality of a constraint; when there is ambiguity

in multiple parameter set, one with lower mult_ is selected

offset: constant offset to E torsion_type: string tag (just for labeling)

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

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

deriv(self: pyrosetta.rosetta.core.scoring.GenTorsionParams, value: float) → float

C++: core::scoring::GenTorsionParams::deriv(double) const –> double

energy(self: pyrosetta.rosetta.core.scoring.GenTorsionParams, value: float) → float

getters

C++: core::scoring::GenTorsionParams::energy(double) const –> double

get_params(self: pyrosetta.rosetta.core.scoring.GenTorsionParams, keyword: str) → float

C++: core::scoring::GenTorsionParams::get_params(std::string) const –> double

is_null(self: pyrosetta.rosetta.core.scoring.GenTorsionParams) → bool

C++: core::scoring::GenTorsionParams::is_null() const –> bool

k(self: pyrosetta.rosetta.core.scoring.GenTorsionParams, idx: int) → float

C++: core::scoring::GenTorsionParams::k(unsigned long) const –> double

k6(self: pyrosetta.rosetta.core.scoring.GenTorsionParams, value: float) → None

C++: core::scoring::GenTorsionParams::k6(double) –> void

multiplicity(self: pyrosetta.rosetta.core.scoring.GenTorsionParams) → int

C++: core::scoring::GenTorsionParams::multiplicity() const –> unsigned long

offset(self: pyrosetta.rosetta.core.scoring.GenTorsionParams) → float

C++: core::scoring::GenTorsionParams::offset() const –> double

set_offset(self: pyrosetta.rosetta.core.scoring.GenTorsionParams, value: float) → None

C++: core::scoring::GenTorsionParams::set_offset(double) –> void

torsion_type(self: pyrosetta.rosetta.core.scoring.GenTorsionParams) → str

C++: core::scoring::GenTorsionParams::torsion_type() const –> std::string

class pyrosetta.rosetta.core.scoring.GenericBondedPotential

Bases: pybind11_object

Potential for core/scoring/methods/GenericBondedEnergy method.

Main class calculating gen_bonded energy term. Consists of energy terms

of bond-length, -angle, torsion, and improper torsions. Reads in database/scoring/score_function/generic_bonded/generic_bonded.XX.txt and stores it as SpringParams or GenTorsionParams as local variables for score enumeration.

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

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

residue_derivatives(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector, atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, score_full: bool, score_hybrid: bool) → None

interface with same named function in GenericBondedEnergy

C++: core::scoring::GenericBondedPotential::residue_derivatives(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> > &, const bool &, const bool &) const –> void

residue_energy(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector, score_full: bool, score_hybrid: bool) → None

interface with same named function in GenericBondedEnergy

C++: core::scoring::GenericBondedPotential::residue_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &, const bool &, const bool &) const –> void

residue_pair_derivatives(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector, atom_derivs_r1: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, atom_derivs_r2: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, score_full: bool, score_hybrid: bool) → None

interface with same named function in GenericBondedEnergy

C++: core::scoring::GenericBondedPotential::residue_pair_derivatives(const class core::conformation::Residue &, 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> > &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &, const bool &, const bool &) const –> void

residue_pair_energy(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector, score_full: bool, score_hybrid: bool) → None

interface with same named function in GenericBondedEnergy

C++: core::scoring::GenericBondedPotential::residue_pair_energy(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &, const bool &, const bool &) const –> void

setup_for_scoring(*args, **kwargs)

Overloaded function.

1. setup_for_scoring(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

2. setup_for_scoring(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, score_full: bool) -> None

3. setup_for_scoring(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, score_full: bool, score_hybrid: bool) -> None

interface with same named function in GenericBondedEnergy

C++: core::scoring::GenericBondedPotential::setup_for_scoring(class core::pose::Pose &, const class core::scoring::ScoreFunction &, const bool &, const bool &) const –> void

class pyrosetta.rosetta.core.scoring.Hairpin

Bases: pybind11_object

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

copy assignment

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

property range_pair_

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

Bases: pybind11_object

append_hairpin(self: pyrosetta.rosetta.core.scoring.Hairpins, s1_1: int, s1_2: int, s2_1: int, s2_2: int) → None

C++: core::scoring::Hairpins::append_hairpin(unsigned long, unsigned long, unsigned long, unsigned long) –> void

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

copy assignment

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

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

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

property hairpin_list_

list(self: pyrosetta.rosetta.core.scoring.Hairpins) → pyrosetta.rosetta.utility.vector1_core_scoring_Hairpin

C++: core::scoring::Hairpins::list() const –> class utility::vector1<struct core::scoring::Hairpin, class std::allocator<struct core::scoring::Hairpin> >

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

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

class pyrosetta.rosetta.core.scoring.Helices

Bases: pybind11_object

property HH_helix_end

property HH_resnum

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

property total_HH_dimer

property total_helices

class pyrosetta.rosetta.core.scoring.HydroxylTorsionPotential

Bases: pybind11_object

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

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

eval_residue_derivative(self: pyrosetta.rosetta.core.scoring.HydroxylTorsionPotential, rsd: pyrosetta.rosetta.core.conformation.Residue, atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None

C++: core::scoring::HydroxylTorsionPotential::eval_residue_derivative(const class core::conformation::Residue &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &) const –> void

eval_residue_energy(self: pyrosetta.rosetta.core.scoring.HydroxylTorsionPotential, rsd: pyrosetta.rosetta.core.conformation.Residue) → float

C++: core::scoring::HydroxylTorsionPotential::eval_residue_energy(const class core::conformation::Residue &) const –> double

class pyrosetta.rosetta.core.scoring.IsHeavyAtomPredicate

Bases: Predicate

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

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

class pyrosetta.rosetta.core.scoring.IsMainAtomPredicate

Bases: Predicate

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

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

class pyrosetta.rosetta.core.scoring.IsProteinBackboneIncludingOPredicate

Bases: Predicate

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

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

class pyrosetta.rosetta.core.scoring.IsProteinBackbonePredicate

Bases: Predicate

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

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

class pyrosetta.rosetta.core.scoring.IsProteinCAPredicate

Bases: Predicate

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

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

class pyrosetta.rosetta.core.scoring.IsSpecificAtomsPredicate

Bases: Predicate

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

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

class pyrosetta.rosetta.core.scoring.LREnergyContainer

Bases: pybind11_object

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class pyrosetta.rosetta.core.scoring.MembraneEmbed

Bases: CacheableData

Whole Pose Membrane Embedding

Define the embedding of the membrane pose based on computed

normal and center parameters. These are initialzed in the membrane protein framework and then recomputed based upon the structured and stored in MP residues (see MP Framework code)

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

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

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

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

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

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

Get Center Parameter

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

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

Clone Cacheable Data

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

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

Compute depth of residue in the membrane

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

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

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

Initialize Membrane Embedding From Pose??

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

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

Get Normal Parameter

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

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

Get MP Penalty

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

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

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

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

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

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

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

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

Set Penalty

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

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

Compute Size of MP (]

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

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

Return Ref Spanning Parameter

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

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

Add Const Membrane Embedding to the pose cache

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

class pyrosetta.rosetta.core.scoring.MembranePotential

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

static 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

static 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

class pyrosetta.rosetta.core.scoring.MembraneTopology

Bases: CacheableData

LipidBurial(self: pyrosetta.rosetta.core.scoring.MembraneTopology, n: int) → float

C++: core::scoring::MembraneTopology::LipidBurial(const unsigned long) const –> double

LipidExposure(self: pyrosetta.rosetta.core.scoring.MembraneTopology, n: int) → float

C++: core::scoring::MembraneTopology::LipidExposure(const unsigned long) const –> double

LipoDefined(self: pyrosetta.rosetta.core.scoring.MembraneTopology) → bool

C++: core::scoring::MembraneTopology::LipoDefined() const –> bool

allow_scoring(self: pyrosetta.rosetta.core.scoring.MembraneTopology, seqpos: int) → bool

C++: core::scoring::MembraneTopology::allow_scoring(const unsigned long) const –> bool

allow_tmh_scoring(self: pyrosetta.rosetta.core.scoring.MembraneTopology, tmh: int) → bool

C++: core::scoring::MembraneTopology::allow_tmh_scoring(const unsigned long) const –> bool

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

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

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

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

depth(*args, **kwargs)

Overloaded function.

1. depth(self: pyrosetta.rosetta.core.scoring.MembraneTopology, seqpos: int) -> float

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

2. depth(self: pyrosetta.rosetta.core.scoring.MembraneTopology) -> pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::MembraneTopology::depth() –> class utility::vector1<double, class std::allocator<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>

get_subset(self: pyrosetta.rosetta.core.scoring.MembraneTopology, TMH_list: pyrosetta.rosetta.utility.vector1_unsigned_long, src: pyrosetta.rosetta.core.scoring.MembraneTopology) → None

C++: core::scoring::MembraneTopology::get_subset(class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class core::scoring::MembraneTopology &) –> void

helix_id(self: pyrosetta.rosetta.core.scoring.MembraneTopology, n: int) → int

C++: core::scoring::MembraneTopology::helix_id(unsigned long) const –> unsigned long

initialize(self: pyrosetta.rosetta.core.scoring.MembraneTopology, spanfile: str) → None

C++: core::scoring::MembraneTopology::initialize(const std::string &) –> void

initialized(self: pyrosetta.rosetta.core.scoring.MembraneTopology) → bool

C++: core::scoring::MembraneTopology::initialized() –> bool &

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

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

read_in_spanfile(self: pyrosetta.rosetta.core.scoring.MembraneTopology) → str

C++: core::scoring::MembraneTopology::read_in_spanfile() –> std::string

reset_allowed_scoring(self: pyrosetta.rosetta.core.scoring.MembraneTopology) → None

C++: core::scoring::MembraneTopology::reset_allowed_scoring() –> void

reset_tmh_insert(self: pyrosetta.rosetta.core.scoring.MembraneTopology) → None

C++: core::scoring::MembraneTopology::reset_tmh_insert() –> void

set_allow_scoring(self: pyrosetta.rosetta.core.scoring.MembraneTopology, pos: int, setting: bool) → None

C++: core::scoring::MembraneTopology::set_allow_scoring(const unsigned long, bool) –> void

set_allow_tmh_scoring(self: pyrosetta.rosetta.core.scoring.MembraneTopology, tmh: int, setting: bool) → None

C++: core::scoring::MembraneTopology::set_allow_tmh_scoring(const unsigned long, bool) –> void

set_tmh_inserted(self: pyrosetta.rosetta.core.scoring.MembraneTopology, tmh_inserted: int) → None

C++: core::scoring::MembraneTopology::set_tmh_inserted(unsigned long) –> void

shift_span(self: pyrosetta.rosetta.core.scoring.MembraneTopology, shift: int) → None

C++: core::scoring::MembraneTopology::shift_span(unsigned long) –> void

span_begin(self: pyrosetta.rosetta.core.scoring.MembraneTopology, n: int) → int

C++: core::scoring::MembraneTopology::span_begin(unsigned long) const –> unsigned long

span_end(self: pyrosetta.rosetta.core.scoring.MembraneTopology, n: int) → int

C++: core::scoring::MembraneTopology::span_end(unsigned long) const –> unsigned long

tmh_inserted(self: pyrosetta.rosetta.core.scoring.MembraneTopology) → int

C++: core::scoring::MembraneTopology::tmh_inserted() const –> unsigned long

tmhelix(self: pyrosetta.rosetta.core.scoring.MembraneTopology) → int

C++: core::scoring::MembraneTopology::tmhelix() const –> unsigned long

tmregion(self: pyrosetta.rosetta.core.scoring.MembraneTopology, pos: int) → bool

C++: core::scoring::MembraneTopology::tmregion(const unsigned long) const –> bool

pyrosetta.rosetta.core.scoring.MembraneTopology_from_pose(pose: 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: CacheableData

Membrane Fullatom embedding info

Cacheable Data - Stores Full atom embedding information including

projection from z axis, fa depth, center, penalty, membrane thicnkess steepness and normal

Fa_Membed_update(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → bool

C++: core::scoring::Membrane_FAEmbed::Fa_Membed_update() –> bool &

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

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

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

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

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

Cacheable Data base Mehtod - Clone Object

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

fa_center(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → float

C++: core::scoring::Membrane_FAEmbed::fa_center() –> double &

fa_depth(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, seqpos: int, atom: int) → float

Compute Depth of Position in Membrane

C++: core::scoring::Membrane_FAEmbed::fa_depth(const unsigned long, const unsigned long) –> double &

fa_penalty(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → float

C++: core::scoring::Membrane_FAEmbed::fa_penalty() –> double &

fa_proj(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, seqpos: int, atom: int) → float

Compute FA Proj to Z Axis

C++: core::scoring::Membrane_FAEmbed::fa_proj(const unsigned long, const unsigned long) –> double &

fa_proj_coord(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, seqpos: int, atom: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

Get Coordinates (I think it is storing these)

C++: core::scoring::Membrane_FAEmbed::fa_proj_coord(const unsigned long, const unsigned long) –> class numeric::xyzVector<double> &

fa_proj_deriv(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, seqpos: int, atom: int) → float

Compute Derivative of Fa Proj.

C++: core::scoring::Membrane_FAEmbed::fa_proj_deriv(const unsigned long, const unsigned long) –> double &

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

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

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

steepness(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → float

C++: core::scoring::Membrane_FAEmbed::steepness() –> double &

thickness(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → float

C++: core::scoring::Membrane_FAEmbed::thickness() –> double &

pyrosetta.rosetta.core.scoring.Membrane_FAEmbed_from_pose(: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.Membrane_FAEmbed

Grab Const MP Fa Embedding data from the pose cache

C++: core::scoring::Membrane_FAEmbed_from_pose(const class core::pose::Pose &) –> const class core::scoring::Membrane_FAEmbed &

class pyrosetta.rosetta.core.scoring.Membrane_FAPotential

Bases: EnvPairPotential

Mmebrane Fullatom Potential - Scoring Class

Helper methods for computing fullatom energy terms

in the membrane scoring function

static 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

static 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.MinScoreScoreFunction

Bases: ScoreFunction

_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 std::string &, 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(std::istream &, bool, const std::string &) –> 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: pyrosetta.rosetta.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: pyrosetta.rosetta.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 std::string &) –> void

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 std::string &) –> 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(*args, **kwargs)

Overloaded function.

1. assign(self: pyrosetta.rosetta.core.scoring.MinScoreScoreFunction, src: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

INTERNAL USE ONLY

C++: core::scoring::MinScoreScoreFunction::assign(const class core::scoring::ScoreFunction &) –> void

2. assign(self: pyrosetta.rosetta.core.scoring.MinScoreScoreFunction, src: pyrosetta.rosetta.core.scoring.MinScoreScoreFunction) -> None

INTERNAL USE ONLY

C++: core::scoring::MinScoreScoreFunction::assign(const class core::scoring::MinScoreScoreFunction &) –> 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_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_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_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_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.MinScoreScoreFunction) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::scoring::MinScoreScoreFunction::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) → pyrosetta.rosetta.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: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, 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: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) → 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

static extract_weights_from_file(*args, **kwargs)

Overloaded function.

1. extract_weights_from_file(filename: str) -> pyrosetta.rosetta.core.scoring.EMapVector

2. extract_weights_from_file(filename: str, patch: bool) -> pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunction::extract_weights_from_file(const std::string &, bool) –> class core::scoring::EMapVector

static extract_weights_from_stream(*args, **kwargs)

Overloaded function.

1. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream) -> pyrosetta.rosetta.core.scoring.EMapVector

2. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream, patch: bool) -> pyrosetta.rosetta.core.scoring.EMapVector

3. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream, patch: bool, filename: str) -> pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunction::extract_weights_from_stream(std::istream &, bool, const std::string &) –> class core::scoring::EMapVector

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

finalize_after_minimizing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

Called after minimization.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoreFunction::finalize_after_minimizing(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 –> 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 std::string &) –> void

static list_options_read(options_read: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: core::scoring::MinScoreScoreFunction::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

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

provide_citation_info(self: pyrosetta.rosetta.core.scoring.ScoreFunction, citations: pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

This allows the scorefunciton to provide citaitons for itself itself and for any modules that it invokes (particularl energy methods).

The default implementation of this provides a vector of citations from all energy methods that

C++: core::scoring::ScoreFunction::provide_citation_info(class basic::citation_manager::CitationCollectionList &) 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: pyrosetta.rosetta.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 std::string &) –> 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: pyrosetta.rosetta.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: pyrosetta.rosetta.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: pyrosetta.rosetta.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_packing_with_rotsets(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, rotsets: core::pack_basic::RotamerSetsBase) → None

Lets the scoring functions cache anything they need to calculate

energies in a packing step (pack_rotamers) in the context of all available rotamers

The exact order of events when setting up for packing are as follows:

1. setup_for_packing() is called for all energy methods

2. rotamers are built

3. setup_for_packing_with_rotsets() is called for all energy methods

4. prepare_rotamers_for_packing() is called for all energy methods

5. The energy methods are asked to score all rotamers and rotamer pairs

6. Annealing begins

The pose is specifically non-const here so that energy methods can store data in it

: Used in ApproximateBuriedUnsatPenalty to pre-compute compatible rotamers

C++: core::scoring::ScoreFunction::setup_for_packing_with_rotsets(class core::pose::Pose &, const class std::shared_ptr<class core::pack_basic::RotamerSetsBase> &) 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(std::ostream &) 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(std::ostream &, 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(std::ostream &, 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(std::ostream &, 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(std::ostream &) 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(std::ostream &) 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

weighted_sum(self: pyrosetta.rosetta.core.scoring.ScoreFunction, unweighted: pyrosetta.rosetta.core.scoring.EMapVector) → float

Returns the weighted sum of the given energy map, given the current set of weights

example(s):

scorefxn.weighted_sum(scores_emap)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreFunction.weights

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

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

class pyrosetta.rosetta.core.scoring.MinimizationEdge

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

activate_dof_deriv_two_body_method(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, enmeth: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, pose: pyrosetta.rosetta.core.pose.Pose) → None

Activate a particular two body energy method as part of this edge.

Sometimes energy methods defining DOF derivatives have to be evaluated even when the residues defining the interaction are not moving with respect to each other (causing the energy method to be activated when given to the edge in the add_twobody_enmeth function above) because the DOFs that define the interaction spill into a third residue and that third residue’s coordinates are changing, causing the DOF to change.

C++: core::scoring::MinimizationEdge::activate_dof_deriv_two_body_method(class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, const class core::pose::Pose &) –> void

add_twobody_enmeth(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, enmeth: pyrosetta.rosetta.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

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

Class to hold all the minimization-specific data that’s required to efficiently evaluate the score function and its derivatives on a structure of fixed sequence and chemical identity.

add_edge(*args, **kwargs)

Overloaded function.

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) → pyrosetta.rosetta.ObjexxFCL.FArray2D_int_t

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

class pyrosetta.rosetta.core.scoring.MinimizationNode

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

activate_dof_deriv_one_body_method(self: pyrosetta.rosetta.core.scoring.MinimizationNode, enmeth: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, pose: pyrosetta.rosetta.core.pose.Pose) → None

Energy methods that define DOF derivatives sometimes have to

be activated for residues that are not having internal-DOF changes because the DOFs they rely on extend into residues whose coordinates are changing. The code constructing the MinimizationGraph has to have already decided that the input energy method should be active.

C++: core::scoring::MinimizationNode::activate_dof_deriv_one_body_method(class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, const class core::pose::Pose &) –> void

activate_dof_deriv_two_body_method(self: pyrosetta.rosetta.core.scoring.MinimizationNode, enmeth: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, pose: pyrosetta.rosetta.core.pose.Pose) → None

Energy methods that define DOF derivatives sometimes have to

be activated for residues that are not having internal-DOF changes because the DOFs they rely on extend into residues whose coordinates are changing. The code constructing the MinimizationGraph has to have already decided that the input energy method should be active.

C++: core::scoring::MinimizationNode::activate_dof_deriv_two_body_method(class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, const class core::pose::Pose &) –> void

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: pyrosetta.rosetta.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

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

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_object

Members:

none

z_axis_only

three_fold

bisector

z_then_bisector

z_then_x

bisector = <MultipoleAxisType.bisector: 4>

property name

none = <MultipoleAxisType.none: 1>

three_fold = <MultipoleAxisType.three_fold: 3>

property value

z_axis_only = <MultipoleAxisType.z_axis_only: 2>

z_then_bisector = <MultipoleAxisType.z_then_bisector: 5>

z_then_x = <MultipoleAxisType.z_then_x: 6>

class pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo

Bases: CacheableData

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

Bases: pybind11_object

align_multipole_axes(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

called prior to scoring, eg

C++: core::scoring::MultipoleElecPotential::align_multipole_axes(class core::pose::Pose &) const –> void

align_residue_multipole_axes(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, mp: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → None

called prior to scoring, eg

C++: core::scoring::MultipoleElecPotential::align_residue_multipole_axes(const class core::pose::Pose &, const class core::conformation::Residue &, class core::scoring::MultipoleElecResidueInfo &) const –> void

amoeba_type_lookup(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, atomname: str, resname: str, variantname: str, variantname2: str) → int

Look up Amoeba type by resname/atomname/variant name

C++: core::scoring::MultipoleElecPotential::amoeba_type_lookup(const std::string &, const std::string &, const std::string &, const std::string &) const –> unsigned long

assign_all_amoeba_types(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

called prior to scoring, eg

C++: core::scoring::MultipoleElecPotential::assign_all_amoeba_types(class core::pose::Pose &) const –> void

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

called prior to scoring, eg

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

build_frame_and_rotate(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose, mp_param: pyrosetta.rosetta.core.scoring.MultipoleParameter, orig_atom: int, mp: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue) → None

Build the matrix to rotate from the local frame to the

global one.

C++: core::scoring::MultipoleElecPotential::build_frame_and_rotate(const class core::pose::Pose &, class std::shared_ptr<class core::scoring::MultipoleParameter> &, unsigned long, class core::scoring::MultipoleElecResidueInfo &, const class core::conformation::Residue &) const –> void

calculate_and_store_all_derivs(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::MultipoleElecPotential::calculate_and_store_all_derivs(const class core::pose::Pose &) const –> void

calculate_fixed_fields_for_polarization(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

Get the electric field due to permanent multipoles

C++: core::scoring::MultipoleElecPotential::calculate_fixed_fields_for_polarization(class core::pose::Pose &) const –> void

calculate_induced_fields_for_polarization(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

Get the electric field due to permanent multipoles

C++: core::scoring::MultipoleElecPotential::calculate_induced_fields_for_polarization(class core::pose::Pose &) const –> void

calculate_res_res_fixed_fields_for_polarization(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, mp1: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, rsd2: pyrosetta.rosetta.core.conformation.Residue, mp2: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → None

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

calculate_res_res_induced_fields_for_polarization(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, mp1: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, rsd2: pyrosetta.rosetta.core.conformation.Residue, mp2: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → None

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

clear_induced_fields(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

Zero out the fields due to induced dipoles

C++: core::scoring::MultipoleElecPotential::clear_induced_fields(class core::pose::Pose &) const –> void

determine_polarization_groups(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

called prior to scoring, eg

C++: core::scoring::MultipoleElecPotential::determine_polarization_groups(class core::pose::Pose &) const –> void

eval_residue_pair_derivatives(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, mp1: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, mp2: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, 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::MultipoleElecPotential::eval_residue_pair_derivatives(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::MultipoleElecResidueInfo &, const class core::scoring::MultipoleElecResidueInfo &, 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

find_params_and_neighbors(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose, mp_param: pyrosetta.rosetta.core.scoring.MultipoleParameter, mp: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue, j: int, this_type: int) → None

Find the appropriate multipole params and axis atoms

C++: core::scoring::MultipoleElecPotential::find_params_and_neighbors(const class core::pose::Pose &, class std::shared_ptr<class core::scoring::MultipoleParameter> &, class core::scoring::MultipoleElecResidueInfo &, const class core::conformation::Residue &, const unsigned long, const unsigned long) const –> void

get_effective_radii(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

Get the effective radii for Generalized Kirkwood

C++: core::scoring::MultipoleElecPotential::get_effective_radii(class core::pose::Pose &) const –> void

get_polarization_from_fields(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

Get the electric field due to permanent multipoles

C++: core::scoring::MultipoleElecPotential::get_polarization_from_fields(class core::pose::Pose &) const –> void

get_res_res_elecE(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, mp1: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, rsd2: pyrosetta.rosetta.core.conformation.Residue, mp2: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → float

C++: core::scoring::MultipoleElecPotential::get_res_res_elecE(const class core::conformation::Residue &, const class core::scoring::MultipoleElecResidueInfo &, const class core::conformation::Residue &, const class core::scoring::MultipoleElecResidueInfo &) const –> double

get_rotamers_effective_radii(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.conformation.RotamerSetBase) → None

Get the effective radii for Generalized Kirkwood

C++: core::scoring::MultipoleElecPotential::get_rotamers_effective_radii(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

get_rotamers_multipole_info(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.conformation.RotamerSetBase) → None

Get the amoeba info for rotamers

C++: core::scoring::MultipoleElecPotential::get_rotamers_multipole_info(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

get_single_rotamer_effective_radii(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, mp_info: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, mp1: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → None

Get the effective radii for Generalized Kirkwood

C++: core::scoring::MultipoleElecPotential::get_single_rotamer_effective_radii(const class core::conformation::Residue &, const class core::pose::Pose &, class std::shared_ptr<const class core::scoring::MultipoleElecPoseInfo>, class core::scoring::MultipoleElecResidueInfo &) const –> void

induce_polarizable_dipoles(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

called prior to scoring, eg

C++: core::scoring::MultipoleElecPotential::induce_polarizable_dipoles(class core::pose::Pose &) const –> void

read_in_amoeba_parameters(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential) → None

read in parameters for amoeba and mappings between

Rosetta residues/atoms and Amoeba types

C++: core::scoring::MultipoleElecPotential::read_in_amoeba_parameters() –> void

read_in_multipole_parameters(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential) → None

read in multipole parameters for amoeba types

C++: core::scoring::MultipoleElecPotential::read_in_multipole_parameters() –> void

relax_induced_dipoles(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose, relax: float) → float

Copies over induced dipoles to storage

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

setup_for_packing(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose, repacking_residues: pyrosetta.rosetta.utility.vector1_bool) → None

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

C++: core::scoring::MultipoleElecPotential::setup_for_scoring(class core::pose::Pose &) const –> void

store_induced_dipoles(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

Copies over induced dipoles to storage

C++: core::scoring::MultipoleElecPotential::store_induced_dipoles(class core::pose::Pose &) const –> void

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.MultipoleElecPotential, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None

C++: core::scoring::MultipoleElecPotential::update_residue_for_packing(class core::pose::Pose &, const unsigned long) const –> void

class pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo

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

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

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

Bases: pybind11_object

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

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

atom_type(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::scoring::MultipoleParameter::atom_type() –> class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

chirality_sign(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → float

C++: core::scoring::MultipoleParameter::chirality_sign() –> double &

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

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

coord_type(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → pyrosetta.rosetta.core.scoring.MultipoleAxisType

C++: core::scoring::MultipoleParameter::coord_type() –> enum core::scoring::MultipoleAxisType &

dipole(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleParameter::dipole() –> class numeric::xyzVector<double> &

monopole(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → float

C++: core::scoring::MultipoleParameter::monopole() –> double &

my_group_members(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::scoring::MultipoleParameter::my_group_members() –> class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

pdamp(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → float

C++: core::scoring::MultipoleParameter::pdamp() –> double &

polarity(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → float

C++: core::scoring::MultipoleParameter::polarity() –> double &

quadrupole(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: core::scoring::MultipoleParameter::quadrupole() –> class numeric::xyzMatrix<double> &

thole(self: pyrosetta.rosetta.core.scoring.MultipoleParameter) → float

C++: core::scoring::MultipoleParameter::thole() –> double &

class pyrosetta.rosetta.core.scoring.NeighborList

Bases: pybind11_object

check_domain_map(self: pyrosetta.rosetta.core.scoring.NeighborList, domain_map_in: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t) → 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) → pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t

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

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

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

class pyrosetta.rosetta.core.scoring.OmegaTether

Bases: pybind11_object

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

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

eval_omega_score_residue(*args, **kwargs)

Overloaded function.

1. eval_omega_score_residue(self: pyrosetta.rosetta.core.scoring.OmegaTether, res_aa: pyrosetta.rosetta.core.chemical.AA, omega: float, phi: float, psi: float) -> float

C++: core::scoring::OmegaTether::eval_omega_score_residue(const enum core::chemical::AA, const double, const double, const double) const –> double

2. eval_omega_score_residue(self: pyrosetta.rosetta.core.scoring.OmegaTether, res: pyrosetta.rosetta.core.conformation.Residue, energy: float, denergy_domega: float, denergy_dphi: float, denergy_dpsi: float) -> None

C++: core::scoring::OmegaTether::eval_omega_score_residue(const class core::conformation::Residue &, double &, double &, double &, double &) const –> void

3. eval_omega_score_residue(self: pyrosetta.rosetta.core.scoring.OmegaTether, res_aa: pyrosetta.rosetta.core.chemical.AA, omega: float, phi: float, psi: float, energy: float, denergy_domega: float, denergy_dphi: float, denergy_dpsi: float) -> None

4. eval_omega_score_residue(self: pyrosetta.rosetta.core.scoring.OmegaTether, res_aa: pyrosetta.rosetta.core.chemical.AA, omega: float, phi: float, psi: float, energy: float, denergy_domega: float, denergy_dphi: float, denergy_dpsi: float, force_simple_evaluation: bool) -> None

C++: core::scoring::OmegaTether::eval_omega_score_residue(const enum core::chemical::AA, const double, const double, const double, double &, double &, double &, double &, const bool) const –> void

omega_index(self: pyrosetta.rosetta.core.scoring.OmegaTether, rsd: pyrosetta.rosetta.core.conformation.Residue) → int

Returns the mainchain torsion index corresponding to “omega”.

Should be 3 for alpha amino acids, 4 for beta amino acids.

Vikram K. Mulligan (vmullig.edu)

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

phi_index(self: pyrosetta.rosetta.core.scoring.OmegaTether, rsd: pyrosetta.rosetta.core.conformation.Residue) → int

Returns the mainchain torsion index corresponding to “phi”.

Generally 1. Set to 2 for beta-amino acids so that derivatives are calculated for the dihedral two spaces before the peptide bond.

Vikram K. Mulligan (vmullig.edu)

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

psi_index(self: pyrosetta.rosetta.core.scoring.OmegaTether, rsd: pyrosetta.rosetta.core.conformation.Residue) → int

Returns the mainchain torsion index corresponding to “psi”.

Generally 2 (alpha-amino acids) or 3 (beta-amino acids).

Vikram K. Mulligan (vmullig.edu)

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

class pyrosetta.rosetta.core.scoring.OneDDistPotential

Bases: pybind11_object

evaluate(*args, **kwargs)

Overloaded function.

1. evaluate(self: pyrosetta.rosetta.core.scoring.OneDDistPotential, dist: float) -> float

C++: core::scoring::OneDDistPotential::evaluate(const double) const –> double

2. evaluate(self: pyrosetta.rosetta.core.scoring.OneDDistPotential, dist: float, compute_deriv: bool, deriv: float) -> float

C++: core::scoring::OneDDistPotential::evaluate(const double, const bool, double &) const –> double

get_derivative(self: pyrosetta.rosetta.core.scoring.OneDDistPotential, dist: float) → float

C++: core::scoring::OneDDistPotential::get_derivative(const double) const –> double

class pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer

Bases: LREnergyContainer

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

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

pre_increment(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: ResidueNeighborIterator

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

pre_increment(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_object

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

Bases: pybind11_object

add_atom(self: pyrosetta.rosetta.core.scoring.PDinter, pa: pyrosetta.rosetta.core.scoring.PDatom) → None

C++: core::scoring::PDinter::add_atom(class std::shared_ptr<const class core::scoring::PDatom>) –> void

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

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

atoms(self: pyrosetta.rosetta.core.scoring.PDinter) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_PDatom_t

C++: core::scoring::PDinter::atoms() const –> const class utility::vector1<class std::shared_ptr<const class core::scoring::PDatom>, class std::allocator<class std::shared_ptr<const class core::scoring::PDatom> > > &

circle(self: pyrosetta.rosetta.core.scoring.PDinter) → bool

C++: core::scoring::PDinter::circle() –> bool &

vrt1(self: pyrosetta.rosetta.core.scoring.PDinter) → pyrosetta.rosetta.core.scoring.PDvertex

C++: core::scoring::PDinter::vrt1() const –> const class std::shared_ptr<const class core::scoring::PDvertex> &

vrt2(self: pyrosetta.rosetta.core.scoring.PDinter) → pyrosetta.rosetta.core.scoring.PDvertex

C++: core::scoring::PDinter::vrt2() const –> const class std::shared_ptr<const class core::scoring::PDvertex> &

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

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

class pyrosetta.rosetta.core.scoring.PDvertex

Bases: pybind11_object

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

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

direction(self: pyrosetta.rosetta.core.scoring.PDvertex) → pyrosetta.rosetta.numeric.xyzVector_double_t

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

finite(self: pyrosetta.rosetta.core.scoring.PDvertex) → bool

C++: core::scoring::PDvertex::finite() const –> bool

generators(self: pyrosetta.rosetta.core.scoring.PDvertex) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_PDatom_t

C++: core::scoring::PDvertex::generators() const –> const class utility::vector1<class std::shared_ptr<class core::scoring::PDatom>, class std::allocator<class std::shared_ptr<class core::scoring::PDatom> > > &

id(self: pyrosetta.rosetta.core.scoring.PDvertex) → int

C++: core::scoring::PDvertex::id() const –> const unsigned long &

live(self: pyrosetta.rosetta.core.scoring.PDvertex) → bool

C++: core::scoring::PDvertex::live() const –> bool

nonconst_direction(self: pyrosetta.rosetta.core.scoring.PDvertex) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::PDvertex::nonconst_direction() –> class numeric::xyzVector<double> &

nonconst_generators(self: pyrosetta.rosetta.core.scoring.PDvertex) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_PDatom_t

C++: core::scoring::PDvertex::nonconst_generators() –> class utility::vector1<class std::shared_ptr<class core::scoring::PDatom>, class std::allocator<class std::shared_ptr<class core::scoring::PDatom> > > &

nonconst_id(self: pyrosetta.rosetta.core.scoring.PDvertex) → int

C++: core::scoring::PDvertex::nonconst_id() –> unsigned long &

nonconst_partners(self: pyrosetta.rosetta.core.scoring.PDvertex) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_PDvertex_t

C++: core::scoring::PDvertex::nonconst_partners() –> class utility::vector1<class std::shared_ptr<class core::scoring::PDvertex>, class std::allocator<class std::shared_ptr<class core::scoring::PDvertex> > > &

nonconst_power(self: pyrosetta.rosetta.core.scoring.PDvertex) → float

C++: core::scoring::PDvertex::nonconst_power() –> double &

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

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

partners(self: pyrosetta.rosetta.core.scoring.PDvertex) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_PDvertex_t

C++: core::scoring::PDvertex::partners() const –> const class utility::vector1<class std::shared_ptr<class core::scoring::PDvertex>, class std::allocator<class std::shared_ptr<class core::scoring::PDvertex> > > &

power(self: pyrosetta.rosetta.core.scoring.PDvertex) → float

C++: core::scoring::PDvertex::power() –> double

set_finite(self: pyrosetta.rosetta.core.scoring.PDvertex, in_val: bool) → None

C++: core::scoring::PDvertex::set_finite(bool) –> void

set_live(self: pyrosetta.rosetta.core.scoring.PDvertex, in_val: bool) → None

C++: core::scoring::PDvertex::set_live(bool) –> void

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

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

class pyrosetta.rosetta.core.scoring.PQR

Bases: pybind11_object

PQR

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 &

property charge

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

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

property natoms_

property radius

property x

property y

property z

class pyrosetta.rosetta.core.scoring.P_AA

Bases: pybind11_object

P_AA_energy(self: pyrosetta.rosetta.core.scoring.P_AA, : pyrosetta.rosetta.core.conformation.Residue) → float

Probability energies for P(aa)

C++: core::scoring::P_AA::P_AA_energy(const class core::conformation::Residue &) const –> double

P_AA_pp_energy(*args, **kwargs)

Overloaded function.

1. P_AA_pp_energy(self: pyrosetta.rosetta.core.scoring.P_AA, : pyrosetta.rosetta.core.conformation.Residue) -> float

C++: core::scoring::P_AA::P_AA_pp_energy(const class core::conformation::Residue &) const –> double

2. P_AA_pp_energy(self: pyrosetta.rosetta.core.scoring.P_AA, aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) -> float

C++: core::scoring::P_AA::P_AA_pp_energy(enum core::chemical::AA, const double, const double) const –> double

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

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

defines_p_aa_pp_energy_for_res(self: pyrosetta.rosetta.core.scoring.P_AA, res: pyrosetta.rosetta.core.conformation.Residue) → bool

Do the tables define a non-zero energy for a given residue?

C++: core::scoring::P_AA::defines_p_aa_pp_energy_for_res(const class core::conformation::Residue &) const –> bool

get_Paa_pp_deriv(self: pyrosetta.rosetta.core.scoring.P_AA, res: pyrosetta.rosetta.core.conformation.Residue, tor_id: pyrosetta.rosetta.core.id.TorsionID) → float

C++: core::scoring::P_AA::get_Paa_pp_deriv(const class core::conformation::Residue &, const class core::id::TorsionID &) const –> double

class pyrosetta.rosetta.core.scoring.P_AA_ABEGO3

Bases: pybind11_object

P_AA_ABEGO3_energy(self: pyrosetta.rosetta.core.scoring.P_AA_ABEGO3, abego_previous: str, abego_current: str, abego_next: str, aa: pyrosetta.rosetta.core.chemical.AA) → float

Probability energies from P(aa|abego triplet)

C++: core::scoring::P_AA_ABEGO3::P_AA_ABEGO3_energy(char, char, char, enum core::chemical::AA) const –> double

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

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

read_P_AA_ABEGO3(self: pyrosetta.rosetta.core.scoring.P_AA_ABEGO3) → None

Read the ss-dep amino acid probability file into P_AA_ABEGO3

C++: core::scoring::P_AA_ABEGO3::read_P_AA_ABEGO3() –> void

class pyrosetta.rosetta.core.scoring.P_AA_ss

Bases: pybind11_object

P_AA_ss_energy(self: pyrosetta.rosetta.core.scoring.P_AA_ss, aa: pyrosetta.rosetta.core.chemical.AA, ss: str) → float

Probability energies from P(aa|ss)

C++: core::scoring::P_AA_ss::P_AA_ss_energy(enum core::chemical::AA, char) const –> double

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

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

read_P_AA_ss(self: pyrosetta.rosetta.core.scoring.P_AA_ss) → None

Read the ss-dep amino acid probability file into P_AA_ss

C++: core::scoring::P_AA_ss::read_P_AA_ss() –> void

class pyrosetta.rosetta.core.scoring.PairEPotential

Bases: pybind11_object

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

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

pair_term_energy(self: pyrosetta.rosetta.core.scoring.PairEPotential, res1: pyrosetta.rosetta.core.conformation.Residue, res1_num_10A_neighbors: int, res2: pyrosetta.rosetta.core.conformation.Residue, res2_num_10A_neighbors: int) → float

C++: core::scoring::PairEPotential::pair_term_energy(const class core::conformation::Residue &, int, const class core::conformation::Residue &, int) const –> double

pair_term_energy_and_deriv(self: pyrosetta.rosetta.core.scoring.PairEPotential, res1: pyrosetta.rosetta.core.conformation.Residue, res1_num_10A_neighbors: int, res2: pyrosetta.rosetta.core.conformation.Residue, res2_num_10A_neighbors: int, dpairE_dr: float) → float

C++: core::scoring::PairEPotential::pair_term_energy_and_deriv(const class core::conformation::Residue &, int, const class core::conformation::Residue &, int, double &) const –> double

pair_term_energy_exists(self: pyrosetta.rosetta.core.scoring.PairEPotential, rsd: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: core::scoring::PairEPotential::pair_term_energy_exists(const class core::conformation::Residue &) const –> bool

range(self: pyrosetta.rosetta.core.scoring.PairEPotential) → float

C++: core::scoring::PairEPotential::range() const –> double

class pyrosetta.rosetta.core.scoring.PointWaterPotential

Bases: pybind11_object

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

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

eval_pointwater_derivs(self: pyrosetta.rosetta.core.scoring.PointWaterPotential, res_aa1: pyrosetta.rosetta.core.chemical.AA, res: pyrosetta.rosetta.core.conformation.Residue, O_pos: pyrosetta.rosetta.numeric.xyzVector_double_t, r_atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, O_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, wt: float) → float

C++: core::scoring::PointWaterPotential::eval_pointwater_derivs(const enum core::chemical::AA, const class core::conformation::Residue &, class numeric::xyzVector<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> > &, double) const –> double

eval_pointwater_score(self: pyrosetta.rosetta.core.scoring.PointWaterPotential, res_aa1: pyrosetta.rosetta.core.chemical.AA, res: pyrosetta.rosetta.core.conformation.Residue, O_pos: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

C++: core::scoring::PointWaterPotential::eval_pointwater_score(const enum core::chemical::AA, const class core::conformation::Residue &, class numeric::xyzVector<double>) const –> double

class pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential

Bases: pybind11_object

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

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

cart2idx(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential, cartX: pyrosetta.rosetta.numeric.xyzVector_double_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::PoissonBoltzmannPotential::cart2idx(const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

cleanup_files(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential) → None

C++: core::scoring::PoissonBoltzmannPotential::cleanup_files() const –> void

eval_PB_energy_residue(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential, rsd: pyrosetta.rosetta.core.conformation.Residue, PB_energy_residue: float, PB_energy_backbone: float, PB_energy_sidechain: float, PB_burial_weight: float) → float

C++: core::scoring::PoissonBoltzmannPotential::eval_PB_energy_residue(const class core::conformation::Residue &, double &, double &, double &, const double &) const –> double

get_potential(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential, cartX: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

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

lower_bound(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::PoissonBoltzmannPotential::lower_bound() const –> class numeric::xyzVector<double>

out_of_bounds(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential, cartX: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool

C++: core::scoring::PoissonBoltzmannPotential::out_of_bounds(const class numeric::xyzVector<double> &) const –> bool

solve_pb(*args, **kwargs)

Overloaded function.

1. solve_pb(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential, pose: pyrosetta.rosetta.core.pose.Pose, state_tag: str, is_residue_charged_by_name: pyrosetta.rosetta.std.map_std_string_bool) -> None

2. solve_pb(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential, pose: pyrosetta.rosetta.core.pose.Pose, state_tag: str, is_residue_charged_by_name: pyrosetta.rosetta.std.map_std_string_bool, cleanup_files: bool) -> None

Execute ABPS to freshly compute the electrotatic field.

The pose

Arbitrary string for generating APBS files. e.g. The current energy state.

Which residues are charged? The key is the residue name.

C++: core::scoring::PoissonBoltzmannPotential::solve_pb(const class core::pose::Pose &, const std::string &, const class std::map<std::string, bool, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, bool> > > &, bool) –> void

3. solve_pb(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential, pose: pyrosetta.rosetta.core.pose.Pose, state_tag: str, charged_atoms: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, present_atoms: pyrosetta.rosetta.core.id.AtomID_Map_bool_t) -> None

4. solve_pb(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential, pose: pyrosetta.rosetta.core.pose.Pose, state_tag: str, charged_atoms: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, present_atoms: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, cleanup_files: bool) -> None

C++: core::scoring::PoissonBoltzmannPotential::solve_pb(const class core::pose::Pose &, const std::string &, const class core::id::AtomID_Map<bool> &, const class core::id::AtomID_Map<bool> &, bool) –> void

upper_bound(self: pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::PoissonBoltzmannPotential::upper_bound() const –> class numeric::xyzVector<double>

class pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer

Bases: LREnergyContainer

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

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

pre_increment(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: ResidueNeighborIterator

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

pre_increment(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_object

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

Bases: pybind11_object

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

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

num_features_proq2(self: pyrosetta.rosetta.core.scoring.ProQPotential) → int

C++: core::scoring::ProQPotential::num_features_proq2() const –> unsigned long

num_features_proqm(self: pyrosetta.rosetta.core.scoring.ProQPotential) → int

C++: core::scoring::ProQPotential::num_features_proqm() const –> unsigned long

score(*args, **kwargs)

Overloaded function.

1. score(self: pyrosetta.rosetta.core.scoring.ProQPotential, pose: pyrosetta.rosetta.core.pose.Pose, feature_vector: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, score: pyrosetta.rosetta.ObjexxFCL.FArray1D_double_t) -> None

2. score(self: pyrosetta.rosetta.core.scoring.ProQPotential, pose: pyrosetta.rosetta.core.pose.Pose, feature_vector: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, score: pyrosetta.rosetta.ObjexxFCL.FArray1D_double_t, ProQ2: bool) -> None

C++: core::scoring::ProQPotential::score(class core::pose::Pose &, class ObjexxFCL::FArray2D<double> &, class ObjexxFCL::FArray1D<double> &, bool) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.ProQPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::ProQPotential::setup_for_scoring(class core::pose::Pose &) const –> void

class pyrosetta.rosetta.core.scoring.ProteinTorsion

Bases: pybind11_object

Members:

PHI

PSI

OMEGA

CHI1

CHI2

CHI3

CHI4

protein_torsion_end

CHI1 = <ProteinTorsion.CHI1: 4>

CHI2 = <ProteinTorsion.CHI2: 5>

CHI3 = <ProteinTorsion.CHI3: 6>

CHI4 = <ProteinTorsion.CHI4: 7>

OMEGA = <ProteinTorsion.OMEGA: 3>

PHI = <ProteinTorsion.PHI: 1>

PSI = <ProteinTorsion.PSI: 2>

property name

protein_torsion_end = <ProteinTorsion.protein_torsion_end: 8>

property value

class pyrosetta.rosetta.core.scoring.RDC

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

property Jdipolar_computed_

class RDC_TYPE

Bases: pybind11_object

Members:

RDC_TYPE_NH

RDC_TYPE_NC

RDC_TYPE_CH

RDC_TYPE_CC

RDC_TYPE_CHN

RDC_TYPE_NCA

RDC_TYPE_CC = <RDC_TYPE.RDC_TYPE_CC: 4>

RDC_TYPE_CH = <RDC_TYPE.RDC_TYPE_CH: 3>

RDC_TYPE_CHN = <RDC_TYPE.RDC_TYPE_CHN: 5>

RDC_TYPE_NC = <RDC_TYPE.RDC_TYPE_NC: 2>

RDC_TYPE_NCA = <RDC_TYPE.RDC_TYPE_NCA: 6>

RDC_TYPE_NH = <RDC_TYPE.RDC_TYPE_NH: 1>

property name

property value

RDC_TYPE_CC = <RDC_TYPE.RDC_TYPE_CC: 4>

RDC_TYPE_CH = <RDC_TYPE.RDC_TYPE_CH: 3>

RDC_TYPE_CHN = <RDC_TYPE.RDC_TYPE_CHN: 5>

RDC_TYPE_NC = <RDC_TYPE.RDC_TYPE_NC: 2>

RDC_TYPE_NCA = <RDC_TYPE.RDC_TYPE_NCA: 6>

RDC_TYPE_NH = <RDC_TYPE.RDC_TYPE_NH: 1>

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

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

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>

property fij_

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

which type of RDC pairing are we dealing with ?

C++: core::scoring::RDC::get_RDC_data_type(const std::string &, const std::string &) –> 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(std::ostream &) const –> void

type(self: pyrosetta.rosetta.core.scoring.RDC) → pyrosetta.rosetta.core.scoring.RDC.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_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

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

Bases: pybind11_object

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

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

eval_rpp_rama_derivatives(self: pyrosetta.rosetta.core.scoring.RamaPrePro, conf: pyrosetta.rosetta.core.conformation.Conformation, res1: pyrosetta.rosetta.core.chemical.ResidueType, res2: pyrosetta.rosetta.core.chemical.ResidueType, mainchain_torsions: pyrosetta.rosetta.utility.vector1_double, gradient: pyrosetta.rosetta.utility.vector1_double) → None

Evaluate the rama score for this residue (res1) given the identity of the next (res_aa2).

This version works for noncanonical or canonical residues with any number of mainchain torsions. If the next residue’s identity is pro or d-pro, a different score table is used.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::RamaPrePro::eval_rpp_rama_derivatives(const class core::conformation::Conformation &, class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>, const class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) const –> void

eval_rpp_rama_score(*args, **kwargs)

Overloaded function.

1. eval_rpp_rama_score(self: pyrosetta.rosetta.core.scoring.RamaPrePro, conf: pyrosetta.rosetta.core.conformation.Conformation, res1: pyrosetta.rosetta.core.chemical.ResidueType, res2: pyrosetta.rosetta.core.chemical.ResidueType, mainchain_torsions: pyrosetta.rosetta.utility.vector1_double) -> float

Evaluate the rama score for this residue (res1) given the identity of the next (res_aa2).

This version works for noncanonical or canonical residues with any number of mainchain torsions. If the next residue’s identity is pro or d-pro, a different score table is used.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::RamaPrePro::eval_rpp_rama_score(const class core::conformation::Conformation &, class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>, const class utility::vector1<double, class std::allocator<double> > &) const –> double

2. eval_rpp_rama_score(self: pyrosetta.rosetta.core.scoring.RamaPrePro, res_aa1: pyrosetta.rosetta.core.chemical.AA, res2: pyrosetta.rosetta.core.chemical.ResidueType, phi: float, psi: float, score_rama: float, denergy_dphi: float, denergy_dpsi: float, return_derivs: bool) -> None

Evaluate the rama score for this residue (res_aa1) given the identity of the next (res_aa2).

This version only works for canonical L-amino acids, canonical D-amino acids, or glycine. If the next residue’s identity is pro or d-pro, a different score table is used. Note: if return_derivs is true, the gradient vector is populated only. If it is false, then only the score_rama value is populated.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::RamaPrePro::eval_rpp_rama_score(const enum core::chemical::AA, class std::shared_ptr<const class core::chemical::ResidueType>, const double, const double, double &, double &, double &, const bool) const –> void

get_mainchain_torsions_covered(self: pyrosetta.rosetta.core.scoring.RamaPrePro, conf: pyrosetta.rosetta.core.conformation.Conformation, res1: pyrosetta.rosetta.core.chemical.ResidueType, res2: pyrosetta.rosetta.core.chemical.ResidueType) → pyrosetta.rosetta.utility.vector1_unsigned_long

Get a const reference to the vector of mainchain torsions indices that the mainchain potential for a given noncanonical ResidueType covers.

For example, for an oligourea, this would return {1, 2, 3}, since the Rama maps for oligoureas cover phi, theta, and psi (mainchain torsions 1, 2, and 3, respectively), but not mu or omega (mainchain torsions 4 and 5).

The current conformation, for reference.

The current residue, for which we’re drawing mainchain torsions.

The next residue, used to determine whether to use pre-proline tables or not.

C++: core::scoring::RamaPrePro::get_mainchain_torsions_covered(const class core::conformation::Conformation &, class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>) const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

random_mainchain_torsions(*args, **kwargs)

Overloaded function.

1. random_mainchain_torsions(self: pyrosetta.rosetta.core.scoring.RamaPrePro, conf: pyrosetta.rosetta.core.conformation.Conformation, res1: pyrosetta.rosetta.core.chemical.ResidueType, res2: pyrosetta.rosetta.core.chemical.ResidueType, torsions: pyrosetta.rosetta.utility.vector1_double) -> None

Given the current residue (res1) and the next one (res2), randomly draw mainchain torsion values for the current

residue, biased by the Ramachandran probabilities for its type.

This version is general, usable for canonicals or noncanonicals.

The current conformation, for reference.

The current residue, for which we’re drawing mainchain torsions.

The next residue, used to determine whether to use pre-proline tables or not.

A vector of mainchain torsions for the current residue.

If the mainchain potential is a function of fewer than all of the mainchain torsions, the vector returned will not have random values for the torsions that the mainchain potential is not a function of. Rather, these torsions will be set to 0. Use the RamaPrePro::get_mainchain_torsions_covered() function to get a vector of torsion indices that were randomized based on the mainchain potential CDF.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::RamaPrePro::random_mainchain_torsions(const class core::conformation::Conformation &, class std::shared_ptr<const class core::chemical::ResidueType>, class std::shared_ptr<const class core::chemical::ResidueType>, class utility::vector1<double, class std::allocator<double> > &) const –> void

2. random_mainchain_torsions(self: pyrosetta.rosetta.core.scoring.RamaPrePro, res_aa1: pyrosetta.rosetta.core.chemical.AA, res2: pyrosetta.rosetta.core.chemical.ResidueType, torsions: pyrosetta.rosetta.utility.vector1_double) -> None

Given the current residue (res1) and the next one (res2), randomly draw mainchain torsion values for the current

residue, biased by the Ramachandran probabilities for its type.

This version is for canonical residues only.

The AA enum for a canonical residue type.

The next residue, used to determine whether to use pre-proline tables or not.

A vector of mainchain torsions for the current residue.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::RamaPrePro::random_mainchain_torsions(const enum core::chemical::AA, class std::shared_ptr<const class core::chemical::ResidueType>, class utility::vector1<double, class std::allocator<double> > &) const –> void

class pyrosetta.rosetta.core.scoring.Rama_Table_Type

Bases: pybind11_object

Members:

flat_l_aa_ramatable

flat_d_aa_ramatable

flat_symm_dl_aa_ramatable

flat_symm_gly_ramatable

flat_symm_pro_ramatable

flat_l_aa_ramatable_stringent

flat_d_aa_ramatable_stringent

flat_symm_dl_aa_ramatable_stringent

flat_symm_gly_ramatable_stringent

flat_symm_pro_ramatable_stringent

unknown_ramatable_type

end_of_ramatable_type_list

end_of_ramatable_type_list = <Rama_Table_Type.unknown_ramatable_type: 11>

flat_d_aa_ramatable = <Rama_Table_Type.flat_d_aa_ramatable: 2>

flat_d_aa_ramatable_stringent = <Rama_Table_Type.flat_d_aa_ramatable_stringent: 7>

flat_l_aa_ramatable = <Rama_Table_Type.flat_l_aa_ramatable: 1>

flat_l_aa_ramatable_stringent = <Rama_Table_Type.flat_l_aa_ramatable_stringent: 6>

flat_symm_dl_aa_ramatable = <Rama_Table_Type.flat_symm_dl_aa_ramatable: 3>

flat_symm_dl_aa_ramatable_stringent = <Rama_Table_Type.flat_symm_dl_aa_ramatable_stringent: 8>

flat_symm_gly_ramatable = <Rama_Table_Type.flat_symm_gly_ramatable: 4>

flat_symm_gly_ramatable_stringent = <Rama_Table_Type.flat_symm_gly_ramatable_stringent: 9>

flat_symm_pro_ramatable = <Rama_Table_Type.flat_symm_pro_ramatable: 5>

flat_symm_pro_ramatable_stringent = <Rama_Table_Type.flat_symm_pro_ramatable_stringent: 10>

property name

unknown_ramatable_type = <Rama_Table_Type.unknown_ramatable_type: 11>

property value

class pyrosetta.rosetta.core.scoring.Ramachandran

Bases: pybind11_object

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

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

cdf_for_aa(self: pyrosetta.rosetta.core.scoring.Ramachandran, aa: pyrosetta.rosetta.core.chemical.AA) → pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::Ramachandran::cdf_for_aa(enum core::chemical::AA) const –> const class utility::vector1<double, class std::allocator<double> > &

cdf_for_aa_for_torsion_bin(self: pyrosetta.rosetta.core.scoring.Ramachandran, aa: pyrosetta.rosetta.core.chemical.AA, : pyrosetta.rosetta.core.conformation.ppo_torsion_bin) → pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::Ramachandran::cdf_for_aa_for_torsion_bin(enum core::chemical::AA, enum core::conformation::ppo_torsion_bin) const –> const class utility::vector1<double, class std::allocator<double> > &

defines_score_for_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, rsd: pyrosetta.rosetta.core.conformation.Residue) → bool

Function to report whether the Ramachandran class will assign a non-zero

score for this residue

C++: core::scoring::Ramachandran::defines_score_for_residue(const class core::conformation::Residue &) const –> bool

draw_random_phi_psi_from_extra_cdf(self: pyrosetta.rosetta.core.scoring.Ramachandran, type: pyrosetta.rosetta.core.scoring.Rama_Table_Type, phi: float, psi: float) → None

Pick a random phi, psi value from a custom Rama table.

The custom Rama table is lazily loaded, so the custom tables must be mutable data. By default, only the 20 canonical Rama tables are loaded.

The lazy loading is not threadsafe. However, there are only a few custom CDFs, which contribute negligibly to the Rosetta memory footprint. As such, to ensure threadsafety, I’m going to have all of these load when the Ramachandran object is initialized in multi-threaded mode. –VK Mulligan, 4 July 2017.

The type of custom rama table (an enum value).

Randomly-drawn phi value, biased by the custom rama table.

Randomly-drawn psi value, biased by the custom rama table.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::Ramachandran::draw_random_phi_psi_from_extra_cdf(const enum core::scoring::Rama_Table_Type, double &, double &) const –> void

eval_rama_score_all(self: pyrosetta.rosetta.core.scoring.Ramachandran, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

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

eval_rama_score_residue(*args, **kwargs)

Overloaded function.

1. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, res: pyrosetta.rosetta.core.conformation.Residue) -> float

C++: core::scoring::Ramachandran::eval_rama_score_residue(const class core::conformation::Residue &) const –> double

2. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) -> float

3. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, force_mirroring: bool) -> float

C++: core::scoring::Ramachandran::eval_rama_score_residue(const enum core::chemical::AA, const double, const double, const bool) const –> double

4. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, res: pyrosetta.rosetta.core.conformation.Residue, rama: float, drama_dphi: float, drama_dpsi: float) -> None

5. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, res: pyrosetta.rosetta.core.conformation.Residue, rama: float, drama_dphi: float, drama_dpsi: float, force_mirroring: bool) -> None

C++: core::scoring::Ramachandran::eval_rama_score_residue(const class core::conformation::Residue &, double &, double &, double &, const bool) const –> void

6. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, rama: float, drama_dphi: float, drama_dpsi: float) -> None

7. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, rama: float, drama_dphi: float, drama_dpsi: float, force_mirroring: bool) -> None

C++: core::scoring::Ramachandran::eval_rama_score_residue(const enum core::chemical::AA, const double, const double, double &, double &, double &, const bool) const –> void

8. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, use_bicubic_interpolation: bool, rama_not_squared: bool, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, rama: float, drama_dphi: float, drama_dpsi: float) -> None

9. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran, use_bicubic_interpolation: bool, rama_not_squared: bool, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, rama: float, drama_dphi: float, drama_dpsi: float, force_mirroring: bool) -> None

C++: core::scoring::Ramachandran::eval_rama_score_residue(bool, bool, const enum core::chemical::AA, const double, const double, double &, double &, double &, const bool) const –> void

eval_rama_score_residue_nonstandard_connection(*args, **kwargs)

Overloaded function.

1. eval_rama_score_residue_nonstandard_connection(self: pyrosetta.rosetta.core.scoring.Ramachandran, mypose: pyrosetta.rosetta.core.pose.Pose, res: pyrosetta.rosetta.core.conformation.Residue, rama: float, drama_dphi: float, drama_dpsi: float) -> None

2. eval_rama_score_residue_nonstandard_connection(self: pyrosetta.rosetta.core.scoring.Ramachandran, mypose: pyrosetta.rosetta.core.pose.Pose, res: pyrosetta.rosetta.core.conformation.Residue, rama: float, drama_dphi: float, drama_dpsi: float, force_mirroring: bool) -> None

Function to evaluate the rama score for residues whose connection partners are not necessarily adjacent

in linear sequence (e.g. for backbone-cyclized peptides). Note that this assumes that rama is being used only for scoring alpha-amino acids (L- or D-).

Vikram K. Mulligan

C++: core::scoring::Ramachandran::eval_rama_score_residue_nonstandard_connection(const class core::pose::Pose &, const class core::conformation::Residue &, double &, double &, double &, const bool) const –> void

get_custom_rama_table_filename(self: pyrosetta.rosetta.core.scoring.Ramachandran, type: pyrosetta.rosetta.core.scoring.Rama_Table_Type) → str

Given a custom Rama table type, get the filename of the database file containing

the data.

Accesses the options system for this information.

Vikram K. Mulligan (vmullig.edu)

C++: core::scoring::Ramachandran::get_custom_rama_table_filename(const enum core::scoring::Rama_Table_Type) const –> std::string

get_l_equivalent(self: pyrosetta.rosetta.core.scoring.Ramachandran, d_aa: pyrosetta.rosetta.core.chemical.AA) → pyrosetta.rosetta.core.chemical.AA

C++: core::scoring::Ramachandran::get_l_equivalent(const enum core::chemical::AA) const –> enum core::chemical::AA

get_ramatable_name_by_type(self: pyrosetta.rosetta.core.scoring.Ramachandran, type: pyrosetta.rosetta.core.scoring.Rama_Table_Type) → str

Given a Rama_Table_Type, return the name.

Vikram K. Mulligan (vmullig.edu)

C++: core::scoring::Ramachandran::get_ramatable_name_by_type(const enum core::scoring::Rama_Table_Type) const –> std::string

get_ramatable_type_by_name(self: pyrosetta.rosetta.core.scoring.Ramachandran, name: str) → pyrosetta.rosetta.core.scoring.Rama_Table_Type

Given a Rama_Table_Type name, return the type.

Calls get_rama_table_name_by_type().

Vikram K. Mulligan (vmullig.edu)

C++: core::scoring::Ramachandran::get_ramatable_type_by_name(const std::string &) const –> enum core::scoring::Rama_Table_Type

is_canonical_d_aminoacid(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA) → bool

C++: core::scoring::Ramachandran::is_canonical_d_aminoacid(const enum core::chemical::AA) const –> bool

is_normally_connected(self: pyrosetta.rosetta.core.scoring.Ramachandran, res: pyrosetta.rosetta.core.conformation.Residue) → bool

Function to do a quick check that the upper connection is seqpos+1 and the lower connection is seqpos-1. Returns true if this is so, false otherwise.

Vikram K. Mulligan

C++: core::scoring::Ramachandran::is_normally_connected(const class core::conformation::Residue &) const –> bool

minimum_sampling_probability(self: pyrosetta.rosetta.core.scoring.Ramachandran) → float

C++: core::scoring::Ramachandran::minimum_sampling_probability() const –> double

n_phi_bins(self: pyrosetta.rosetta.core.scoring.Ramachandran) → int

C++: core::scoring::Ramachandran::n_phi_bins() const –> unsigned long

n_psi_bins(self: pyrosetta.rosetta.core.scoring.Ramachandran) → int

C++: core::scoring::Ramachandran::n_psi_bins() const –> unsigned long

phipsi_in_allowed_rama(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → bool

Return true if the given phi/psi pair is in the allowed space

sampled by uniform_phipsi_from_allowed_rama.

C++: core::scoring::Ramachandran::phipsi_in_allowed_rama(const enum core::chemical::AA, double, double) const –> bool

phipsi_in_forbidden_rama(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → bool

Return false if the given phi/psi pair is in the allowed space

sampled by uniform_phipsi_from_allowed_rama.

C++: core::scoring::Ramachandran::phipsi_in_forbidden_rama(const enum core::chemical::AA, double, double) const –> bool

rama_power(self: pyrosetta.rosetta.core.scoring.Ramachandran) → float

Get rama_power value.

If used, rama values over 0 are raised to the Nth power. Unused by default.

Vikram K. Mulligan (vmullig.edu) and Brian Koepnick.

C++: core::scoring::Ramachandran::rama_power() const –> const double &

rama_probability(self: pyrosetta.rosetta.core.scoring.Ramachandran, aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → float

C++: core::scoring::Ramachandran::rama_probability(enum core::chemical::AA, double, double) const –> double

random_phipsi_from_rama(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → None

Generate random values for phi and psi, biased by the Ramachandran plot of a particular amino acid.

The amino acid in question.

Output phi value.

Output psi value.

C++: core::scoring::Ramachandran::random_phipsi_from_rama(const enum core::chemical::AA, double &, double &) const –> void

random_phipsi_from_rama_by_torsion_bin(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, torsion_bin: pyrosetta.rosetta.core.conformation.ppo_torsion_bin) → None

functions for torsion-bin specific but otherwise random phi/psi angles

Amelie Stein

C++: core::scoring::Ramachandran::random_phipsi_from_rama_by_torsion_bin(enum core::chemical::AA, double &, double &, enum core::conformation::ppo_torsion_bin) const –> void

set_rama_power(self: pyrosetta.rosetta.core.scoring.Ramachandran, setting: float) → None

Set rama_power value.

If used, rama values over 0 are raised to the Nth power. Unused by default.

Vikram K. Mulligan (vmullig.edu) and Brian Koepnick.

C++: core::scoring::Ramachandran::set_rama_power(const double &) –> void

set_use_rama_power(self: pyrosetta.rosetta.core.scoring.Ramachandran, setting: bool) → None

Set whether we’re using the rama_power option, which scales rama values over 0.

Vikram K. Mulligan (vmullig.edu) and Brian Koepnick.

C++: core::scoring::Ramachandran::set_use_rama_power(const bool) –> void

uniform_phipsi_from_allowed_rama(self: pyrosetta.rosetta.core.scoring.Ramachandran, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → None

Return a phi/psi pair picked uniformly from the regions of rama

space with nonzero weight. Sampling with this method will not give a rama distribution; it will give a flat distribution in only the allowed regions of rama space.

C++: core::scoring::Ramachandran::uniform_phipsi_from_allowed_rama(const enum core::chemical::AA, double &, double &) const –> void

use_rama_power(self: pyrosetta.rosetta.core.scoring.Ramachandran) → bool

Get whether we’re using the rama_power option, which scales rama values over 0.

Vikram K. Mulligan (vmullig.edu) and Brian Koepnick.

C++: core::scoring::Ramachandran::use_rama_power() const –> bool

write_rama_score_all(self: pyrosetta.rosetta.core.scoring.Ramachandran, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::Ramachandran::write_rama_score_all(const class core::pose::Pose &) const –> void

class pyrosetta.rosetta.core.scoring.Ramachandran2B

Bases: pybind11_object

IdealizeRamaEnergy(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, phi: float, psi: float, rama: float, drama_dphi: float, drama_dpsi: float, entropy: float, rama_for_res: pyrosetta.rosetta.ObjexxFCL.FArray2A_double_t) → None

C++: core::scoring::Ramachandran2B::IdealizeRamaEnergy(const double, const double, double &, double &, double &, const double, const class ObjexxFCL::FArray2A<double> &) const –> void

RamaE(*args, **kwargs)

Overloaded function.

1. RamaE(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, rsd: pyrosetta.rosetta.core.conformation.Residue) -> float

C++: core::scoring::Ramachandran2B::RamaE(const class core::conformation::Residue &) const –> double

2. RamaE(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, rsd: pyrosetta.rosetta.core.conformation.Residue, drama_dphi: float, drama_dpsi: float) -> float

C++: core::scoring::Ramachandran2B::RamaE(const class core::conformation::Residue &, double &, double &) const –> double

3. RamaE(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, phi: float, psi: float, rsd: pyrosetta.rosetta.core.chemical.AA, drama_dphi: float, drama_dpsi: float) -> float

C++: core::scoring::Ramachandran2B::RamaE(double, double, const enum core::chemical::AA &, double &, double &) const –> double

RamaE_Lower(*args, **kwargs)

Overloaded function.

1. RamaE_Lower(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, rsd: pyrosetta.rosetta.core.conformation.Residue, neighbor: pyrosetta.rosetta.core.chemical.AA) -> float

C++: core::scoring::Ramachandran2B::RamaE_Lower(const class core::conformation::Residue &, const enum core::chemical::AA &) const –> double

2. RamaE_Lower(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, rsd: pyrosetta.rosetta.core.conformation.Residue, neighbor: pyrosetta.rosetta.core.chemical.AA, drama_dphi: float, drama_dpsi: float) -> float

C++: core::scoring::Ramachandran2B::RamaE_Lower(const class core::conformation::Residue &, const enum core::chemical::AA &, double &, double &) const –> double

3. RamaE_Lower(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, phi: float, psi: float, rsd: pyrosetta.rosetta.core.chemical.AA, neighbor: pyrosetta.rosetta.core.chemical.AA) -> float

C++: core::scoring::Ramachandran2B::RamaE_Lower(double, double, const enum core::chemical::AA &, const enum core::chemical::AA &) const –> double

4. RamaE_Lower(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, phi: float, psi: float, rsd: pyrosetta.rosetta.core.chemical.AA, neighbor: pyrosetta.rosetta.core.chemical.AA, drama_dphi: float, drama_dpsi: float) -> float

C++: core::scoring::Ramachandran2B::RamaE_Lower(double, double, const enum core::chemical::AA &, const enum core::chemical::AA &, double &, double &) const –> double

RamaE_Upper(*args, **kwargs)

Overloaded function.

1. RamaE_Upper(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, rsd: pyrosetta.rosetta.core.conformation.Residue, neighbor: pyrosetta.rosetta.core.chemical.AA) -> float

C++: core::scoring::Ramachandran2B::RamaE_Upper(const class core::conformation::Residue &, const enum core::chemical::AA &) const –> double

2. RamaE_Upper(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, rsd: pyrosetta.rosetta.core.conformation.Residue, neighbor: pyrosetta.rosetta.core.chemical.AA, drama_dphi: float, drama_dpsi: float) -> float

C++: core::scoring::Ramachandran2B::RamaE_Upper(const class core::conformation::Residue &, const enum core::chemical::AA &, double &, double &) const –> double

3. RamaE_Upper(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, phi: float, psi: float, rsd: pyrosetta.rosetta.core.chemical.AA, neighbor: pyrosetta.rosetta.core.chemical.AA) -> float

C++: core::scoring::Ramachandran2B::RamaE_Upper(double, double, const enum core::chemical::AA &, const enum core::chemical::AA &) const –> double

4. RamaE_Upper(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, phi: float, psi: float, rsd: pyrosetta.rosetta.core.chemical.AA, neighbor: pyrosetta.rosetta.core.chemical.AA, drama_dphi: float, drama_dpsi: float) -> float

C++: core::scoring::Ramachandran2B::RamaE_Upper(double, double, const enum core::chemical::AA &, const enum core::chemical::AA &, double &, double &) const –> double

eval_rama_score_all(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

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

eval_rama_score_residue(*args, **kwargs)

Overloaded function.

1. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) -> float

C++: core::scoring::Ramachandran2B::eval_rama_score_residue(const enum core::chemical::AA, const double, const double) const –> double

2. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, res: pyrosetta.rosetta.core.conformation.Residue, left_aa: pyrosetta.rosetta.core.chemical.AA, right_aa: pyrosetta.rosetta.core.chemical.AA, rama: float, drama_dphi: float, drama_dpsi: float) -> None

C++: core::scoring::Ramachandran2B::eval_rama_score_residue(const class core::conformation::Residue &, const enum core::chemical::AA, const enum core::chemical::AA, double &, double &, double &) const –> void

3. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, phi: float, psi: float, res: pyrosetta.rosetta.core.chemical.AA, left_aa: pyrosetta.rosetta.core.chemical.AA, right_aa: pyrosetta.rosetta.core.chemical.AA) -> float

C++: core::scoring::Ramachandran2B::eval_rama_score_residue(double, double, const enum core::chemical::AA, const enum core::chemical::AA, const enum core::chemical::AA) const –> double

4. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, phi: float, psi: float, res: pyrosetta.rosetta.core.chemical.AA, left_aa: pyrosetta.rosetta.core.chemical.AA, right_aa: pyrosetta.rosetta.core.chemical.AA, drama_dphi: float, drama_dpsi: float) -> float

C++: core::scoring::Ramachandran2B::eval_rama_score_residue(double, double, const enum core::chemical::AA, const enum core::chemical::AA, const enum core::chemical::AA, double &, double &) const –> double

5. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, res: pyrosetta.rosetta.core.conformation.Residue, rama: float, drama_dphi: float, drama_dpsi: float) -> None

C++: core::scoring::Ramachandran2B::eval_rama_score_residue(const class core::conformation::Residue &, double &, double &, double &) const –> void

6. eval_rama_score_residue(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, res_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, rama: float, drama_dphi: float, drama_dpsi: float) -> None

C++: core::scoring::Ramachandran2B::eval_rama_score_residue(const enum core::chemical::AA, const double, const double, double &, double &, double &) const –> void

left_cdf(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, aa_left: pyrosetta.rosetta.core.chemical.AA, aa_center: pyrosetta.rosetta.core.chemical.AA) → pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::Ramachandran2B::left_cdf(enum core::chemical::AA, enum core::chemical::AA) const –> const class utility::vector1<double, class std::allocator<double> > &

left_cdf_for_torsion_bin(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, aa_left: pyrosetta.rosetta.core.chemical.AA, aa_center: pyrosetta.rosetta.core.chemical.AA, : pyrosetta.rosetta.core.conformation.ppo_torsion_bin) → pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::Ramachandran2B::left_cdf_for_torsion_bin(enum core::chemical::AA, enum core::chemical::AA, enum core::conformation::ppo_torsion_bin) const –> const class utility::vector1<double, class std::allocator<double> > &

minimum_sampling_probability(self: pyrosetta.rosetta.core.scoring.Ramachandran2B) → float

C++: core::scoring::Ramachandran2B::minimum_sampling_probability() const –> double

n_phi_bins(self: pyrosetta.rosetta.core.scoring.Ramachandran2B) → int

C++: core::scoring::Ramachandran2B::n_phi_bins() const –> unsigned long

n_psi_bins(self: pyrosetta.rosetta.core.scoring.Ramachandran2B) → int

C++: core::scoring::Ramachandran2B::n_psi_bins() const –> unsigned long

rama_bin_probability_left(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, aa_left: pyrosetta.rosetta.core.chemical.AA, aa_center: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → float

C++: core::scoring::Ramachandran2B::rama_bin_probability_left(enum core::chemical::AA, enum core::chemical::AA, double, double) const –> double

rama_bin_probability_right(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, aa_center: pyrosetta.rosetta.core.chemical.AA, aa_right: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → float

C++: core::scoring::Ramachandran2B::rama_bin_probability_right(enum core::chemical::AA, enum core::chemical::AA, double, double) const –> double

random_phipsi_from_rama_by_torsion_bin_left(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, left_aa: pyrosetta.rosetta.core.chemical.AA, pos_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, torsion_bin: pyrosetta.rosetta.core.conformation.ppo_torsion_bin) → None

function for torsion-bin specific but otherwise random phi/psi angles

Amelie Stein

C++: core::scoring::Ramachandran2B::random_phipsi_from_rama_by_torsion_bin_left(const enum core::chemical::AA, const enum core::chemical::AA, double &, double &, const enum core::conformation::ppo_torsion_bin) const –> void

random_phipsi_from_rama_by_torsion_bin_right(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, pos_aa: pyrosetta.rosetta.core.chemical.AA, right_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float, torsion_bin: pyrosetta.rosetta.core.conformation.ppo_torsion_bin) → None

C++: core::scoring::Ramachandran2B::random_phipsi_from_rama_by_torsion_bin_right(const enum core::chemical::AA, const enum core::chemical::AA, double &, double &, const enum core::conformation::ppo_torsion_bin) const –> void

random_phipsi_from_rama_left(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, left_aa: pyrosetta.rosetta.core.chemical.AA, pos_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → None

pick a phi/psi pair chosen from the rama2b distribution so that the most

commonly observed phi/psi pairs are chosen at higher probability than the least commonly observed pairs; use the phi/psi distribution for the central aa (the pos aa) based on its “left” (n-terminal) neighbor’s amino acid type.

C++: core::scoring::Ramachandran2B::random_phipsi_from_rama_left(const enum core::chemical::AA, const enum core::chemical::AA, double &, double &) const –> void

random_phipsi_from_rama_right(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, pos_aa: pyrosetta.rosetta.core.chemical.AA, right_aa: pyrosetta.rosetta.core.chemical.AA, phi: float, psi: float) → None

pick a phi/psi pair chosen from the rama2b distribution so that the most

commonly observed phi/psi pairs are chosen at higher probability than the least commonly observed pairs; use the phi/psi distribution for the central aa (the pos aa) based on its “right” (c-terminal) neighbor’s amino acid type.

C++: core::scoring::Ramachandran2B::random_phipsi_from_rama_right(const enum core::chemical::AA, const enum core::chemical::AA, double &, double &) const –> void

right_cdf(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, aa_center: pyrosetta.rosetta.core.chemical.AA, aa_right: pyrosetta.rosetta.core.chemical.AA) → pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::Ramachandran2B::right_cdf(enum core::chemical::AA, enum core::chemical::AA) const –> const class utility::vector1<double, class std::allocator<double> > &

right_cdf_for_torsion_bin(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, aa_center: pyrosetta.rosetta.core.chemical.AA, aa_right: pyrosetta.rosetta.core.chemical.AA, : pyrosetta.rosetta.core.conformation.ppo_torsion_bin) → pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::Ramachandran2B::right_cdf_for_torsion_bin(enum core::chemical::AA, enum core::chemical::AA, enum core::conformation::ppo_torsion_bin) const –> const class utility::vector1<double, class std::allocator<double> > &

write_rama_score_all(self: pyrosetta.rosetta.core.scoring.Ramachandran2B, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::Ramachandran2B::write_rama_score_all(const class core::pose::Pose &) const –> void

class pyrosetta.rosetta.core.scoring.ResPairMinimizationData

Bases: pybind11_object

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

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

get_data(self: pyrosetta.rosetta.core.scoring.ResPairMinimizationData, index: pyrosetta.rosetta.core.scoring.min_pair_data) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: core::scoring::ResPairMinimizationData::get_data(enum core::scoring::min_pair_data) –> class std::shared_ptr<class basic::datacache::CacheableData>

get_data_ref(self: pyrosetta.rosetta.core.scoring.ResPairMinimizationData, index: pyrosetta.rosetta.core.scoring.min_pair_data) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: core::scoring::ResPairMinimizationData::get_data_ref(enum core::scoring::min_pair_data) –> class basic::datacache::CacheableData &

set_data(self: pyrosetta.rosetta.core.scoring.ResPairMinimizationData, index: pyrosetta.rosetta.core.scoring.min_pair_data, : pyrosetta.rosetta.basic.datacache.CacheableData) → None

C++: core::scoring::ResPairMinimizationData::set_data(enum core::scoring::min_pair_data, class std::shared_ptr<class basic::datacache::CacheableData>) –> void

class pyrosetta.rosetta.core.scoring.ResRangePredicate

Bases: Predicate

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

Bases: pybind11_object

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

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

get_data(self: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, index: pyrosetta.rosetta.core.scoring.min_single_data) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: core::scoring::ResSingleMinimizationData::get_data(enum core::scoring::min_single_data) –> class std::shared_ptr<class basic::datacache::CacheableData>

get_data_ref(self: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, index: pyrosetta.rosetta.core.scoring.min_single_data) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: core::scoring::ResSingleMinimizationData::get_data_ref(enum core::scoring::min_single_data) –> class basic::datacache::CacheableData &

set_data(self: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, index: pyrosetta.rosetta.core.scoring.min_single_data, data: pyrosetta.rosetta.basic.datacache.CacheableData) → None

C++: core::scoring::ResSingleMinimizationData::set_data(enum core::scoring::min_single_data, class std::shared_ptr<class basic::datacache::CacheableData>) –> void

class pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling

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

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

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(std::ostream &) 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(std::ostream &, 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(std::ostream &, 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(std::ostream &, 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(std::ostream &, 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.ResidualDipolarCoupling_Rohl

Bases: CacheableData

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

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

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

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

get_RDC_data(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling_Rohl) → pyrosetta.rosetta.utility.vector1_core_scoring_RDC_Rohl

C++: core::scoring::ResidualDipolarCoupling_Rohl::get_RDC_data() const –> class utility::vector1<class core::scoring::RDC_Rohl, class std::allocator<class core::scoring::RDC_Rohl> >

get_RDC_data_type(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling_Rohl, atom1: str, atom2: str) → int

C++: core::scoring::ResidualDipolarCoupling_Rohl::get_RDC_data_type(const std::string &, const std::string &) –> 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>

read_RDC_file(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling_Rohl) → None

C++: core::scoring::ResidualDipolarCoupling_Rohl::read_RDC_file() –> void

class pyrosetta.rosetta.core.scoring.ResidueExclParams

Bases: pybind11_object

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

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

atm_excluded(*args, **kwargs)

Overloaded function.

1. atm_excluded(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, i: int, value: bool) -> None

C++: core::scoring::ResidueExclParams::atm_excluded(unsigned long, bool) –> void

2. atm_excluded(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, i: int) -> bool

C++: core::scoring::ResidueExclParams::atm_excluded(unsigned long) const –> bool

create_excl_info(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, score_full: bool, score_hybrid: bool) → None

C++: core::scoring::ResidueExclParams::create_excl_info(const bool, const bool) –> void

find_by_atmpairno(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, i: int, j: int) → bool

C++: core::scoring::ResidueExclParams::find_by_atmpairno(unsigned long, unsigned long) const –> bool

find_by_bondno(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, i: int) → bool

C++: core::scoring::ResidueExclParams::find_by_bondno(unsigned long) const –> bool

fully_counted(*args, **kwargs)

Overloaded function.

1. fully_counted(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, value: bool) -> None

C++: core::scoring::ResidueExclParams::fully_counted(const bool) –> void

2. fully_counted(self: pyrosetta.rosetta.core.scoring.ResidueExclParams) -> bool

C++: core::scoring::ResidueExclParams::fully_counted() const –> bool

fully_excluded_1b(*args, **kwargs)

Overloaded function.

1. fully_excluded_1b(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, value: bool) -> None

C++: core::scoring::ResidueExclParams::fully_excluded_1b(const bool) –> void

2. fully_excluded_1b(self: pyrosetta.rosetta.core.scoring.ResidueExclParams) -> bool

C++: core::scoring::ResidueExclParams::fully_excluded_1b() const –> bool

rsd1type(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, rsdtype: pyrosetta.rosetta.core.chemical.ResidueType) → None

C++: core::scoring::ResidueExclParams::rsd1type(const class core::chemical::ResidueType &) –> void

rsd2type(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, rsdtype: pyrosetta.rosetta.core.chemical.ResidueType) → None

C++: core::scoring::ResidueExclParams::rsd2type(const class core::chemical::ResidueType &) –> void

same_rsdpairs(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue) → bool

C++: core::scoring::ResidueExclParams::same_rsdpairs(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

store_by_atmpairno(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, i: int, j: int) → None

C++: core::scoring::ResidueExclParams::store_by_atmpairno(unsigned long, unsigned long) –> void

store_by_bondno(self: pyrosetta.rosetta.core.scoring.ResidueExclParams, i: int) → None

C++: core::scoring::ResidueExclParams::store_by_bondno(unsigned long) –> void

class pyrosetta.rosetta.core.scoring.ResidueNblistData

Bases: CacheableData

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

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

atom_neighbors(self: pyrosetta.rosetta.core.scoring.ResidueNblistData) → pyrosetta.rosetta.utility.vector1_core_scoring_SmallAtNb

C++: core::scoring::ResidueNblistData::atom_neighbors() const –> const class utility::vector1<class core::scoring::SmallAtNb, class std::allocator<class core::scoring::SmallAtNb> > &

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

C++: core::scoring::ResidueNblistData::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(*args, **kwargs)

Overloaded function.

1. initialize(self: pyrosetta.rosetta.core.scoring.ResidueNblistData, res: pyrosetta.rosetta.core.conformation.Residue, cpfxn: pyrosetta.rosetta.core.scoring.etable.count_pair.CountPairFunction) -> None

2. initialize(self: pyrosetta.rosetta.core.scoring.ResidueNblistData, res: pyrosetta.rosetta.core.conformation.Residue, cpfxn: pyrosetta.rosetta.core.scoring.etable.count_pair.CountPairFunction, heavy_heavy_dist_cutoff: float) -> None

3. initialize(self: pyrosetta.rosetta.core.scoring.ResidueNblistData, res: pyrosetta.rosetta.core.conformation.Residue, cpfxn: pyrosetta.rosetta.core.scoring.etable.count_pair.CountPairFunction, heavy_heavy_dist_cutoff: float, heavy_hydrogen_dist_cutoff: float) -> None

4. initialize(self: pyrosetta.rosetta.core.scoring.ResidueNblistData, res: pyrosetta.rosetta.core.conformation.Residue, cpfxn: pyrosetta.rosetta.core.scoring.etable.count_pair.CountPairFunction, heavy_heavy_dist_cutoff: float, heavy_hydrogen_dist_cutoff: float, hydrogen_hydrogen_dist_cutoff: float) -> None

Initialize the residue-nblist; if there are no intra-residue interactions, then provide a null-pointing

count-pair function.

C++: core::scoring::ResidueNblistData::initialize(const class core::conformation::Residue &, class std::shared_ptr<const class core::scoring::etable::count_pair::CountPairFunction>, double, double, double) –> void

class pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

Bases: pybind11_object

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

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

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

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

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

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

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

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

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

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

pre_increment(self: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

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

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

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

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

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

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

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

class pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

Bases: pybind11_object

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pre_increment(self: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

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

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

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

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

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

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

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

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

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

class pyrosetta.rosetta.core.scoring.ResiduePairNeighborList

Bases: CacheableData

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

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

atom_neighbors(self: pyrosetta.rosetta.core.scoring.ResiduePairNeighborList) → pyrosetta.rosetta.utility.vector1_core_scoring_SmallAtNb

C++: core::scoring::ResiduePairNeighborList::atom_neighbors() const –> const class utility::vector1<class core::scoring::SmallAtNb, class std::allocator<class core::scoring::SmallAtNb> > &

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

C++: core::scoring::ResiduePairNeighborList::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_from_residues(*args, **kwargs)

Overloaded function.

1. initialize_from_residues(self: pyrosetta.rosetta.core.scoring.ResiduePairNeighborList, vvd2: float, hvd2: float, hhd2: float, r1: pyrosetta.rosetta.core.conformation.Residue, r2: pyrosetta.rosetta.core.conformation.Residue, cpfxn: pyrosetta.rosetta.core.scoring.etable.count_pair.CountPairFunction) -> None

C++: core::scoring::ResiduePairNeighborList::initialize_from_residues(double, double, double, const class core::conformation::Residue &, const class core::conformation::Residue &, class std::shared_ptr<const class core::scoring::etable::count_pair::CountPairFunction>) –> void

2. initialize_from_residues(self: pyrosetta.rosetta.core.scoring.ResiduePairNeighborList, vvd2: float, hvd2: float, hhd2: float, r1: pyrosetta.rosetta.core.conformation.Residue, r2: pyrosetta.rosetta.core.conformation.Residue, cpfxn: pyrosetta.rosetta.core.scoring.etable.count_pair.CountPairFunction, r1_map: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long, r2_map: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) -> None

C++: core::scoring::ResiduePairNeighborList::initialize_from_residues(double, double, double, const class core::conformation::Residue &, const class core::conformation::Residue &, class std::shared_ptr<const class core::scoring::etable::count_pair::CountPairFunction>, const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &, 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

class pyrosetta.rosetta.core.scoring.SASAPotential

Bases: pybind11_object

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

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

eval_residue_pair_derivatives(self: pyrosetta.rosetta.core.scoring.SASAPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, 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::SASAPotential::eval_residue_pair_derivatives(const class core::conformation::Residue &, const class core::conformation::Residue &, 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_sasa(self: pyrosetta.rosetta.core.scoring.SASAPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue) → float

C++: core::scoring::SASAPotential::get_res_res_sasa(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> double

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.SASAPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::SASAPotential::setup_for_scoring(class core::pose::Pose &) const –> void

vertex_count(self: pyrosetta.rosetta.core.scoring.SASAPotential) → int

C++: core::scoring::SASAPotential::vertex_count() –> unsigned long &

class pyrosetta.rosetta.core.scoring.SAnode

Bases: pybind11_object

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

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

cos_theta(self: pyrosetta.rosetta.core.scoring.SAnode) → float

C++: core::scoring::SAnode::cos_theta() const –> double

inter(self: pyrosetta.rosetta.core.scoring.SAnode) → pyrosetta.rosetta.core.scoring.PDinter

C++: core::scoring::SAnode::inter() const –> const class std::shared_ptr<class core::scoring::PDinter> &

other_atom(self: pyrosetta.rosetta.core.scoring.SAnode) → pyrosetta.rosetta.core.scoring.PDatom

C++: core::scoring::SAnode::other_atom() const –> const class std::shared_ptr<const class core::scoring::PDatom> &

phi(self: pyrosetta.rosetta.core.scoring.SAnode) → float

C++: core::scoring::SAnode::phi() const –> double

set_cos_theta(self: pyrosetta.rosetta.core.scoring.SAnode, ct: float) → None

C++: core::scoring::SAnode::set_cos_theta(double) –> void

set_phi(self: pyrosetta.rosetta.core.scoring.SAnode, p: float) → None

C++: core::scoring::SAnode::set_phi(double) –> void

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

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

class pyrosetta.rosetta.core.scoring.SS_Info

Bases: CacheableData

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

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

_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 std::string &, 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(std::istream &, bool, const std::string &) –> 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: pyrosetta.rosetta.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: pyrosetta.rosetta.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 std::string &) –> void

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 std::string &) –> 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_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_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_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_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) → pyrosetta.rosetta.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: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, 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: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) → 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

static extract_weights_from_file(*args, **kwargs)

Overloaded function.

1. extract_weights_from_file(filename: str) -> pyrosetta.rosetta.core.scoring.EMapVector

2. extract_weights_from_file(filename: str, patch: bool) -> pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunction::extract_weights_from_file(const std::string &, bool) –> class core::scoring::EMapVector

static extract_weights_from_stream(*args, **kwargs)

Overloaded function.

1. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream) -> pyrosetta.rosetta.core.scoring.EMapVector

2. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream, patch: bool) -> pyrosetta.rosetta.core.scoring.EMapVector

3. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream, patch: bool, filename: str) -> pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunction::extract_weights_from_stream(std::istream &, bool, const std::string &) –> class core::scoring::EMapVector

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

finalize_after_minimizing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

Called after minimization.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoreFunction::finalize_after_minimizing(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 –> 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 std::string &) –> void

static list_options_read(option_list: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: core::scoring::ScoreFunction::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

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

provide_citation_info(self: pyrosetta.rosetta.core.scoring.ScoreFunction, citations: pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

This allows the scorefunciton to provide citaitons for itself itself and for any modules that it invokes (particularl energy methods).

The default implementation of this provides a vector of citations from all energy methods that

C++: core::scoring::ScoreFunction::provide_citation_info(class basic::citation_manager::CitationCollectionList &) 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: pyrosetta.rosetta.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 std::string &) –> 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: pyrosetta.rosetta.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: pyrosetta.rosetta.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: pyrosetta.rosetta.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_packing_with_rotsets(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, rotsets: core::pack_basic::RotamerSetsBase) → None

Lets the scoring functions cache anything they need to calculate

energies in a packing step (pack_rotamers) in the context of all available rotamers

The exact order of events when setting up for packing are as follows:

1. setup_for_packing() is called for all energy methods

2. rotamers are built

3. setup_for_packing_with_rotsets() is called for all energy methods

4. prepare_rotamers_for_packing() is called for all energy methods

5. The energy methods are asked to score all rotamers and rotamer pairs

6. Annealing begins

The pose is specifically non-const here so that energy methods can store data in it

: Used in ApproximateBuriedUnsatPenalty to pre-compute compatible rotamers

C++: core::scoring::ScoreFunction::setup_for_packing_with_rotsets(class core::pose::Pose &, const class std::shared_ptr<class core::pack_basic::RotamerSetsBase> &) 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(std::ostream &) 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(std::ostream &, 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(std::ostream &, 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(std::ostream &, 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(std::ostream &) 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(std::ostream &) 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

weighted_sum(self: pyrosetta.rosetta.core.scoring.ScoreFunction, unweighted: pyrosetta.rosetta.core.scoring.EMapVector) → float

Returns the weighted sum of the given energy map, given the current set of weights

example(s):

scorefxn.weighted_sum(scores_emap)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreFunction.weights

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

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

class pyrosetta.rosetta.core.scoring.ScoreFunctionFactory

Bases: SingletonBase_core_scoring_ScoreFunctionFactory_t

A static singleton for making a single score_function.

static 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 std::string &) –> 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 std::string &) –> 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 std::string &, const std::string &) –> 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 std::string &, const std::string &) –> 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 std::string &, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> 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 std::string &, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

static get_instance() → core::scoring::ScoreFunctionFactory

C++: utility::SingletonBase<core::scoring::ScoreFunctionFactory>::get_instance() –> class core::scoring::ScoreFunctionFactory *

static list_read_options(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

A documentation function which reports the set of options read by the create_score_function variants

C++: core::scoring::ScoreFunctionFactory::list_read_options(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

static 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 std::string &, const class utility::options::OptionCollection &) –> bool

static 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 std::string &, const class utility::options::OptionCollection &) –> bool

class pyrosetta.rosetta.core.scoring.ScoreFunctionInfo

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

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

Bases: pybind11_object

A key for looking up previously-loaded scorefunctions (which the ScoreFunctionFactory stores in a map of owning pointers indexed by keys of this type).

The key is the weights file name as a string, a comma-separated list of patches as another string, and a raw pointer to the options collection. Note that a raw pointer is appropriate in this case since the goal is NOT to access the options collection, but simply to have a unique identifier for whether we’ve seen it before. An owning pointer or even a weak pointer (access pointer) would incur unncessary overhead that we don’t need for that goal. If an OptionCollection could be hashed, that might be an even better unique identifier, but for now, we’ll use the memory location.

Vikram K. Mulligan (vmulligan.org).

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

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

class pyrosetta.rosetta.core.scoring.ScoreType

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

Members:

fa_atr

fa_rep

fa_sol

fa_intra_atr

fa_intra_rep

fa_intra_sol

fa_intra_atr_xover4

fa_intra_rep_xover4

fa_intra_sol_xover4

fa_intra_atr_nonprotein

fa_intra_rep_nonprotein

fa_intra_sol_nonprotein

fa_intra_RNA_base_phos_atr

fa_intra_RNA_base_phos_rep

fa_intra_RNA_base_phos_sol

fa_atr_dummy

fa_rep_dummy

fa_sol_dummy

fa_vdw_tinker

lk_hack

lk_ball

lk_ball_wtd

lk_ball_iso

lk_ball_bridge

lk_ball_bridge_uncpl

lk_dome

lk_dome_iso

lk_dome_bridge

lk_dome_bridge_uncpl

lk_ball_bridge2

lk_ball_bridge_uncpl2

lk_dome_pack

coarse_fa_atr

coarse_fa_rep

coarse_fa_sol

coarse_beadlj

mm_lj_intra_rep

mm_lj_intra_atr

mm_lj_inter_rep

mm_lj_inter_atr

mm_twist

mm_bend

mm_stretch

lk_costheta

lk_polar

lk_nonpolar

lk_polar_intra_RNA

lk_nonpolar_intra_RNA

fa_elec

fa_elec_bb_bb

fa_elec_bb_sc

fa_elec_sc_sc

fa_intra_elec

h2o_hbond

dna_dr

dna_bp

dna_bs

dna_ref

peptide_bond

pcs

pcsTs1

pcsTs2

pcsTs3

pcsTs4

pcs2

fastsaxs

saxs_score

saxs_cen_score

saxs_fa_score

pddf_score

fiberdiffraction

fiberdiffractiondens

epr_deer_score

fa_mbenv

fa_mbsolv

fa_elec_rna_phos_phos

fa_elec_rna_phos_sugr

fa_elec_rna_phos_base

fa_elec_rna_sugr_sugr

fa_elec_rna_sugr_base

fa_elec_rna_base_base

fa_elec_rna_phos_phos_fast

fa_elec_rna_phos_sugr_fast

fa_elec_rna_phos_base_fast

fa_elec_rna_sugr_sugr_fast

fa_elec_rna_sugr_base_fast

fa_elec_rna_base_base_fast

fa_elec_aro_aro

fa_elec_aro_all

hack_aro

rna_fa_atr_base

rna_fa_rep_base

rna_data_backbone

ch_bond

ch_bond_bb_bb

ch_bond_sc_sc

ch_bond_bb_sc

pro_close

rama2b

vdw

cenpack

cenpack_smooth

cen_hb

hybrid_vdw

gauss

rna_vdw

rnp_vdw

rna_base_backbone

rna_backbone_backbone

rna_repulsive

rna_base_pair_pairwise

rna_base_axis_pairwise

rna_base_stagger_pairwise

rna_base_stack_pairwise

rna_base_stack_axis_pairwise

rna_data_base

rna_base_pair

rna_base_axis

rna_base_stagger

rna_base_stack

rna_base_stack_axis

rnp_base_pair

rnp_stack

rnp_stack_xy

rnp_pair

rnp_pair_dist

rnp_aa_to_rna_backbone

rna_mg_point

rna_mg_point_indirect

mg

mg_lig

mg_sol

mg_ref

hoh_ref

rna_torsion

rna_torsion_sc

rna_suite

rna_jr_suite

suiteness_bonus

tna_suite

rna_sugar_close

fa_stack

fa_stack_lower

fa_stack_upper

fa_stack_aro

fa_stack_ext

fa_stack_sol

fa_stack_lr

fa_stack_rna_protein

fa_stack_rna_protein_aro

ss_contact_worst

stack_elec

stack_elec_base_base

stack_elec_base_bb

alignment

dna_bb_torsion

dna_sugar_close

dna_base_distance

geom_sol_fast

geom_sol_fast_intra_RNA

fa_cust_pair_dist

custom_atom_pair

orbitals_hpol_bb

pci_cation_pi

pci_pi_pi

pci_salt_bridge

pci_hbond

arg_cation_pi

PyRosettaTwoBodyContextIndepenedentEnergy_first

PyRosettaTwoBodyContextIndepenedentEnergy_last

python

n_ci_2b_score_types

fa_pair

fa_pair_aro_aro

fa_pair_aro_pol

fa_pair_pol_pol

hbond_sr_bb

hbond_lr_bb

hbond_bb_sc

hbond_sr_bb_sc

hbond_lr_bb_sc

hbond_sc

hbond_intra

hbond_wat

wat_entropy

hbond

npd_hbond_sr_bb

npd_hbond_lr_bb

npd_hbond_bb_sc

npd_hbond_sr_bb_sc

npd_hbond_lr_bb_sc

npd_hbond_sc

npd_hbond_intra

npd_hbond

fa_grpelec

PyRosettaTwoBodyContextDependentEnergy_first

PyRosettaTwoBodyContextDependentEnergy_last

interface_dd_pair

geom_sol

geom_sol_intra_RNA

occ_sol_fitted

occ_sol_fitted_onebody

occ_sol_exact

cen_rot_pair

cen_rot_pair_ang

cen_rot_pair_dih

pair

cen_pair_smooth

Mpair

MPPair

FaMPSolv

suck

rna_rg

rna_motif

facts_elec

facts_solv

facts_sasa

motif_dock

pointwater

goap

goap_dist

goap_angle

approximate_buried_unsat_penalty

interchain_pair

interchain_vdw

n_shortranged_2b_score_types

gb_elec

multipole_elec

fa_sasa

dslf_ss_dst

dslf_cs_ang

dslf_ss_dih

dslf_ca_dih

dslf_cbs_ds

dslf_fa13

dslfc_cen_dst

dslfc_cb_dst

dslfc_ang

dslfc_cb_dih

dslfc_bb_dih

dslfc_rot

dslfc_trans

dslfc_RT

atom_pair_constraint

base_pair_constraint

coarse_chainbreak_constraint

constant_constraint

coordinate_constraint

angle_constraint

dihedral_constraint

big_bin_constraint

dunbrack_constraint

site_constraint

metalhash_constraint

metalbinding_constraint

rna_stub_coord_hack

bond_geometry

rna_bond_geometry

Hpol_bond_geometry

rama

omega

fa_dun

fa_dun_dev

fa_dun_rot

fa_dun_semi

cen_rot_dun

dna_chi

p_aa_pp

p_aa_ss

yhh_planarity

hxl_tors

h2o_intra

ref

ref_nc

seqdep_ref

nmer_ref

nmer_pssm

nmer_svm

envsmooth

e_pH

rna_bulge

dna_dihedral_bb

dna_dihedral_chi

dna_dihedral_sugar

sugar_bb

free_suite

free_2HOprime

free_side_chain

free_base

free_res

free_dof

intermol

other_pose

special_rot

PB_elec

cen_env_smooth

cbeta_smooth

cen_rot_env

cen_rot_cbeta

env

cbeta

DFIRE

Menv

Mcbeta

Menv_non_helix

Menv_termini

Menv_tm_proj

Mlipo

rg

rg_local

co

hs_pair

ss_pair

rsigma

sheet

burial_v2

burial

abego

covalent_labeling

covalent_labeling_fa

hrf_ms_labeling

hrf_dynamics

ccs_imms

depc_ms

rnp_env

loop_close

missing_res

MPEnv

MPCbeta

MPLipo

MPTermini

MPNonHelix

MPTMProj

FaMPEnv

FaMPEnvSmooth

fa_water_to_bilayer

FaMPAsymEzCB

FaMPAsymEzCG

MPResidueLipophilicity

span_ins

mp_span_ang

MPHelicality

natbias_ss

natbias_hs

natbias_hh

natbias_stwist

aa_cmp

dock_ens_conf

csa

dc

rdc

rdc_segments

rdc_rohl

nmr_pcs

nmr_rdc

nmr_pre

cen_pair_motifs

cen_pair_motif_degree

holes

holes_decoy

holes_resl

holes_min

holes_min_mean

rna_chem_shift

rna_chem_map

rna_chem_map_lores

rna_partition

dab_sasa

dab_sev

sa

d2h_sa

ProQM

ProQ

interchain_env

interchain_contact

chainbreak

linear_chainbreak

overlap_chainbreak

distance_chainbreak

dof_constraint

branch_conn

linear_branch_conn

rama_prepro

paa_abego3

cart_bonded

cart_bonded_angle

cart_bonded_length

cart_bonded_ring

cart_bonded_torsion

cart_bonded_proper

cart_bonded_improper

gen_bonded

gen_bonded_bond

gen_bonded_angle

gen_bonded_torsion

gen_bonded_improper

neigh_vect

neigh_count

neigh_vect_raw

symE_bonus

sym_lig

mhc_epitope

pack_stat

rms

res_type_constraint

res_type_linking_constraint

pocket_constraint

backbone_stub_constraint

backbone_stub_linear_constraint

surface

p_aa

unfolded

split_unfolded_two_body

fa_atr_ref

fa_rep_ref

fa_sol_ref

fa_elec_ref

hbond_ref

dslf_fa13_ref

fa_intra_atr_ref

fa_intra_rep_ref

fa_intra_sol_ref

pro_close_ref

fa_dun_ref

fa_dun_dev_ref

fa_dun_rot_ref

fa_dun_semi_ref

rama_ref

p_aa_pp_ref

omega_ref

mm_lj_intra_rep_ref

mm_lj_intra_atr_ref

mm_twist_ref

elec_dens_fast

elec_dens_window

elec_dens_whole_structure_ca

elec_dens_whole_structure_allatom

elec_dens_atomwise

grid_vdw

xtal_ml

xtal_rwork

xtal_rfree

hpatch

Menv_smooth

wat_desolv

ring_close

aa_repeat

aa_composition

aspartimide_penalty

hbnet

buried_unsatisfied_penalty

netcharge

voids_penalty

sap_constraint

dna_env

dna_pair

dump_trajectory

PyRosettaEnergy_first

PyRosettaEnergy_last

sidechain_neighbors

target_clash

membrane_span_constraint

membrane_span_term_z_constraint

aromatic_restraint

rna_coarse_dist

total_score

dummy_score_type

n_score_types

end_of_score_type_enumeration

DFIRE = <ScoreType.DFIRE: 318>

FaMPAsymEzCB = <ScoreType.FaMPAsymEzCB: 353>

FaMPAsymEzCG = <ScoreType.FaMPAsymEzCG: 354>

FaMPEnv = <ScoreType.FaMPEnv: 350>

FaMPEnvSmooth = <ScoreType.FaMPEnvSmooth: 351>

FaMPSolv = <ScoreType.FaMPSolv: 228>

Hpol_bond_geometry = <ScoreType.Hpol_bond_geometry: 275>

MPCbeta = <ScoreType.MPCbeta: 345>

MPEnv = <ScoreType.MPEnv: 344>

MPHelicality = <ScoreType.MPHelicality: 358>

MPLipo = <ScoreType.MPLipo: 346>

MPNonHelix = <ScoreType.MPNonHelix: 348>

MPPair = <ScoreType.MPPair: 227>

MPResidueLipophilicity = <ScoreType.MPResidueLipophilicity: 355>

MPTMProj = <ScoreType.MPTMProj: 349>

MPTermini = <ScoreType.MPTermini: 347>

Mcbeta = <ScoreType.Mcbeta: 320>

Menv = <ScoreType.Menv: 319>

Menv_non_helix = <ScoreType.Menv_non_helix: 321>

Menv_smooth = <ScoreType.Menv_smooth: 460>

Menv_termini = <ScoreType.Menv_termini: 322>

Menv_tm_proj = <ScoreType.Menv_tm_proj: 323>

Mlipo = <ScoreType.Mlipo: 324>

Mpair = <ScoreType.Mpair: 226>

PB_elec = <ScoreType.PB_elec: 311>

ProQ = <ScoreType.ProQ: 389>

ProQM = <ScoreType.ProQM: 388>

PyRosettaEnergy_first = <ScoreType.PyRosettaEnergy_first: 474>

PyRosettaEnergy_last = <ScoreType.PyRosettaEnergy_last: 484>

PyRosettaTwoBodyContextDependentEnergy_first = <ScoreType.PyRosettaTwoBodyContextDependentEnergy_first: 204>

PyRosettaTwoBodyContextDependentEnergy_last = <ScoreType.PyRosettaTwoBodyContextDependentEnergy_last: 214>

PyRosettaTwoBodyContextIndepenedentEnergy_first = <ScoreType.PyRosettaTwoBodyContextIndepenedentEnergy_first: 169>

PyRosettaTwoBodyContextIndepenedentEnergy_last = <ScoreType.PyRosettaTwoBodyContextIndepenedentEnergy_last: 179>

aa_cmp = <ScoreType.aa_cmp: 363>

aa_composition = <ScoreType.aa_composition: 464>

aa_repeat = <ScoreType.aa_repeat: 463>

abego = <ScoreType.abego: 334>

alignment = <ScoreType.alignment: 155>

angle_constraint = <ScoreType.angle_constraint: 265>

approximate_buried_unsat_penalty = <ScoreType.approximate_buried_unsat_penalty: 240>

arg_cation_pi = <ScoreType.arg_cation_pi: 168>

aromatic_restraint = <ScoreType.aromatic_restraint: 489>

aspartimide_penalty = <ScoreType.aspartimide_penalty: 465>

atom_pair_constraint = <ScoreType.atom_pair_constraint: 260>

backbone_stub_constraint = <ScoreType.backbone_stub_constraint: 424>

backbone_stub_linear_constraint = <ScoreType.backbone_stub_linear_constraint: 425>

base_pair_constraint = <ScoreType.base_pair_constraint: 261>

big_bin_constraint = <ScoreType.big_bin_constraint: 267>

bond_geometry = <ScoreType.bond_geometry: 273>

branch_conn = <ScoreType.branch_conn: 397>

burial = <ScoreType.burial: 333>

burial_v2 = <ScoreType.burial_v2: 332>

buried_unsatisfied_penalty = <ScoreType.buried_unsatisfied_penalty: 467>

cart_bonded = <ScoreType.cart_bonded: 401>

cart_bonded_angle = <ScoreType.cart_bonded_angle: 402>

cart_bonded_improper = <ScoreType.cart_bonded_improper: 407>

cart_bonded_length = <ScoreType.cart_bonded_length: 403>

cart_bonded_proper = <ScoreType.cart_bonded_proper: 406>

cart_bonded_ring = <ScoreType.cart_bonded_ring: 404>

cart_bonded_torsion = <ScoreType.cart_bonded_torsion: 405>

cbeta = <ScoreType.cbeta: 317>

cbeta_smooth = <ScoreType.cbeta_smooth: 313>

ccs_imms = <ScoreType.ccs_imms: 339>

cen_env_smooth = <ScoreType.cen_env_smooth: 312>

cen_hb = <ScoreType.cen_hb: 103>

cen_pair_motif_degree = <ScoreType.cen_pair_motif_degree: 374>

cen_pair_motifs = <ScoreType.cen_pair_motifs: 373>

cen_pair_smooth = <ScoreType.cen_pair_smooth: 225>

cen_rot_cbeta = <ScoreType.cen_rot_cbeta: 315>

cen_rot_dun = <ScoreType.cen_rot_dun: 282>

cen_rot_env = <ScoreType.cen_rot_env: 314>

cen_rot_pair = <ScoreType.cen_rot_pair: 221>

cen_rot_pair_ang = <ScoreType.cen_rot_pair_ang: 222>

cen_rot_pair_dih = <ScoreType.cen_rot_pair_dih: 223>

cenpack = <ScoreType.cenpack: 101>

cenpack_smooth = <ScoreType.cenpack_smooth: 102>

ch_bond = <ScoreType.ch_bond: 94>

ch_bond_bb_bb = <ScoreType.ch_bond_bb_bb: 95>

ch_bond_bb_sc = <ScoreType.ch_bond_bb_sc: 97>

ch_bond_sc_sc = <ScoreType.ch_bond_sc_sc: 96>

chainbreak = <ScoreType.chainbreak: 392>

co = <ScoreType.co: 327>

coarse_beadlj = <ScoreType.coarse_beadlj: 36>

coarse_chainbreak_constraint = <ScoreType.coarse_chainbreak_constraint: 262>

coarse_fa_atr = <ScoreType.coarse_fa_atr: 33>

coarse_fa_rep = <ScoreType.coarse_fa_rep: 34>

coarse_fa_sol = <ScoreType.coarse_fa_sol: 35>

constant_constraint = <ScoreType.constant_constraint: 263>

coordinate_constraint = <ScoreType.coordinate_constraint: 264>

covalent_labeling = <ScoreType.covalent_labeling: 335>

covalent_labeling_fa = <ScoreType.covalent_labeling_fa: 336>

csa = <ScoreType.csa: 365>

custom_atom_pair = <ScoreType.custom_atom_pair: 162>

d2h_sa = <ScoreType.d2h_sa: 387>

dab_sasa = <ScoreType.dab_sasa: 384>

dab_sev = <ScoreType.dab_sev: 385>

dc = <ScoreType.dc: 366>

depc_ms = <ScoreType.depc_ms: 340>

dihedral_constraint = <ScoreType.dihedral_constraint: 266>

distance_chainbreak = <ScoreType.distance_chainbreak: 395>

dna_base_distance = <ScoreType.dna_base_distance: 158>

dna_bb_torsion = <ScoreType.dna_bb_torsion: 156>

dna_bp = <ScoreType.dna_bp: 56>

dna_bs = <ScoreType.dna_bs: 57>

dna_chi = <ScoreType.dna_chi: 283>

dna_dihedral_bb = <ScoreType.dna_dihedral_bb: 298>

dna_dihedral_chi = <ScoreType.dna_dihedral_chi: 299>

dna_dihedral_sugar = <ScoreType.dna_dihedral_sugar: 300>

dna_dr = <ScoreType.dna_dr: 55>

dna_env = <ScoreType.dna_env: 471>

dna_pair = <ScoreType.dna_pair: 472>

dna_ref = <ScoreType.dna_ref: 58>

dna_sugar_close = <ScoreType.dna_sugar_close: 157>

dock_ens_conf = <ScoreType.dock_ens_conf: 364>

dof_constraint = <ScoreType.dof_constraint: 396>

dslf_ca_dih = <ScoreType.dslf_ca_dih: 249>

dslf_cbs_ds = <ScoreType.dslf_cbs_ds: 250>

dslf_cs_ang = <ScoreType.dslf_cs_ang: 247>

dslf_fa13 = <ScoreType.dslf_fa13: 251>

dslf_fa13_ref = <ScoreType.dslf_fa13_ref: 435>

dslf_ss_dih = <ScoreType.dslf_ss_dih: 248>

dslf_ss_dst = <ScoreType.dslf_ss_dst: 246>

dslfc_RT = <ScoreType.dslfc_RT: 259>

dslfc_ang = <ScoreType.dslfc_ang: 254>

dslfc_bb_dih = <ScoreType.dslfc_bb_dih: 256>

dslfc_cb_dih = <ScoreType.dslfc_cb_dih: 255>

dslfc_cb_dst = <ScoreType.dslfc_cb_dst: 253>

dslfc_cen_dst = <ScoreType.dslfc_cen_dst: 252>

dslfc_rot = <ScoreType.dslfc_rot: 257>

dslfc_trans = <ScoreType.dslfc_trans: 258>

dummy_score_type = <ScoreType.dummy_score_type: 492>

dump_trajectory = <ScoreType.dump_trajectory: 473>

dunbrack_constraint = <ScoreType.dunbrack_constraint: 268>

e_pH = <ScoreType.e_pH: 296>

elec_dens_atomwise = <ScoreType.elec_dens_atomwise: 454>

elec_dens_fast = <ScoreType.elec_dens_fast: 450>

elec_dens_whole_structure_allatom = <ScoreType.elec_dens_whole_structure_allatom: 453>

elec_dens_whole_structure_ca = <ScoreType.elec_dens_whole_structure_ca: 452>

elec_dens_window = <ScoreType.elec_dens_window: 451>

end_of_score_type_enumeration = <ScoreType.dummy_score_type: 492>

env = <ScoreType.env: 316>

envsmooth = <ScoreType.envsmooth: 295>

epr_deer_score = <ScoreType.epr_deer_score: 73>

fa_atr = <ScoreType.fa_atr: 1>

fa_atr_dummy = <ScoreType.fa_atr_dummy: 16>

fa_atr_ref = <ScoreType.fa_atr_ref: 430>

fa_cust_pair_dist = <ScoreType.fa_cust_pair_dist: 161>

fa_dun = <ScoreType.fa_dun: 278>

fa_dun_dev = <ScoreType.fa_dun_dev: 279>

fa_dun_dev_ref = <ScoreType.fa_dun_dev_ref: 441>

fa_dun_ref = <ScoreType.fa_dun_ref: 440>

fa_dun_rot = <ScoreType.fa_dun_rot: 280>

fa_dun_rot_ref = <ScoreType.fa_dun_rot_ref: 442>

fa_dun_semi = <ScoreType.fa_dun_semi: 281>

fa_dun_semi_ref = <ScoreType.fa_dun_semi_ref: 443>

fa_elec = <ScoreType.fa_elec: 49>

fa_elec_aro_all = <ScoreType.fa_elec_aro_all: 89>

fa_elec_aro_aro = <ScoreType.fa_elec_aro_aro: 88>

fa_elec_bb_bb = <ScoreType.fa_elec_bb_bb: 50>

fa_elec_bb_sc = <ScoreType.fa_elec_bb_sc: 51>

fa_elec_ref = <ScoreType.fa_elec_ref: 433>

fa_elec_rna_base_base = <ScoreType.fa_elec_rna_base_base: 81>

fa_elec_rna_base_base_fast = <ScoreType.fa_elec_rna_base_base_fast: 87>

fa_elec_rna_phos_base = <ScoreType.fa_elec_rna_phos_base: 78>

fa_elec_rna_phos_base_fast = <ScoreType.fa_elec_rna_phos_base_fast: 84>

fa_elec_rna_phos_phos = <ScoreType.fa_elec_rna_phos_phos: 76>

fa_elec_rna_phos_phos_fast = <ScoreType.fa_elec_rna_phos_phos_fast: 82>

fa_elec_rna_phos_sugr = <ScoreType.fa_elec_rna_phos_sugr: 77>

fa_elec_rna_phos_sugr_fast = <ScoreType.fa_elec_rna_phos_sugr_fast: 83>

fa_elec_rna_sugr_base = <ScoreType.fa_elec_rna_sugr_base: 80>

fa_elec_rna_sugr_base_fast = <ScoreType.fa_elec_rna_sugr_base_fast: 86>

fa_elec_rna_sugr_sugr = <ScoreType.fa_elec_rna_sugr_sugr: 79>

fa_elec_rna_sugr_sugr_fast = <ScoreType.fa_elec_rna_sugr_sugr_fast: 85>

fa_elec_sc_sc = <ScoreType.fa_elec_sc_sc: 52>

fa_grpelec = <ScoreType.fa_grpelec: 203>

fa_intra_RNA_base_phos_atr = <ScoreType.fa_intra_RNA_base_phos_atr: 13>

fa_intra_RNA_base_phos_rep = <ScoreType.fa_intra_RNA_base_phos_rep: 14>

fa_intra_RNA_base_phos_sol = <ScoreType.fa_intra_RNA_base_phos_sol: 15>

fa_intra_atr = <ScoreType.fa_intra_atr: 4>

fa_intra_atr_nonprotein = <ScoreType.fa_intra_atr_nonprotein: 10>

fa_intra_atr_ref = <ScoreType.fa_intra_atr_ref: 436>

fa_intra_atr_xover4 = <ScoreType.fa_intra_atr_xover4: 7>

fa_intra_elec = <ScoreType.fa_intra_elec: 53>

fa_intra_rep = <ScoreType.fa_intra_rep: 5>

fa_intra_rep_nonprotein = <ScoreType.fa_intra_rep_nonprotein: 11>

fa_intra_rep_ref = <ScoreType.fa_intra_rep_ref: 437>

fa_intra_rep_xover4 = <ScoreType.fa_intra_rep_xover4: 8>

fa_intra_sol = <ScoreType.fa_intra_sol: 6>

fa_intra_sol_nonprotein = <ScoreType.fa_intra_sol_nonprotein: 12>

fa_intra_sol_ref = <ScoreType.fa_intra_sol_ref: 438>

fa_intra_sol_xover4 = <ScoreType.fa_intra_sol_xover4: 9>

fa_mbenv = <ScoreType.fa_mbenv: 74>

fa_mbsolv = <ScoreType.fa_mbsolv: 75>

fa_pair = <ScoreType.fa_pair: 181>

fa_pair_aro_aro = <ScoreType.fa_pair_aro_aro: 182>

fa_pair_aro_pol = <ScoreType.fa_pair_aro_pol: 183>

fa_pair_pol_pol = <ScoreType.fa_pair_pol_pol: 184>

fa_rep = <ScoreType.fa_rep: 2>

fa_rep_dummy = <ScoreType.fa_rep_dummy: 17>

fa_rep_ref = <ScoreType.fa_rep_ref: 431>

fa_sasa = <ScoreType.fa_sasa: 245>

fa_sol = <ScoreType.fa_sol: 3>

fa_sol_dummy = <ScoreType.fa_sol_dummy: 18>

fa_sol_ref = <ScoreType.fa_sol_ref: 432>

fa_stack = <ScoreType.fa_stack: 142>

fa_stack_aro = <ScoreType.fa_stack_aro: 145>

fa_stack_ext = <ScoreType.fa_stack_ext: 146>

fa_stack_lower = <ScoreType.fa_stack_lower: 143>

fa_stack_lr = <ScoreType.fa_stack_lr: 148>

fa_stack_rna_protein = <ScoreType.fa_stack_rna_protein: 149>

fa_stack_rna_protein_aro = <ScoreType.fa_stack_rna_protein_aro: 150>

fa_stack_sol = <ScoreType.fa_stack_sol: 147>

fa_stack_upper = <ScoreType.fa_stack_upper: 144>

fa_vdw_tinker = <ScoreType.fa_vdw_tinker: 19>

fa_water_to_bilayer = <ScoreType.fa_water_to_bilayer: 352>

facts_elec = <ScoreType.facts_elec: 232>

facts_sasa = <ScoreType.facts_sasa: 234>

facts_solv = <ScoreType.facts_solv: 233>

fastsaxs = <ScoreType.fastsaxs: 66>

fiberdiffraction = <ScoreType.fiberdiffraction: 71>

fiberdiffractiondens = <ScoreType.fiberdiffractiondens: 72>

free_2HOprime = <ScoreType.free_2HOprime: 303>

free_base = <ScoreType.free_base: 305>

free_dof = <ScoreType.free_dof: 307>

free_res = <ScoreType.free_res: 306>

free_side_chain = <ScoreType.free_side_chain: 304>

free_suite = <ScoreType.free_suite: 302>

gauss = <ScoreType.gauss: 105>

gb_elec = <ScoreType.gb_elec: 243>

gen_bonded = <ScoreType.gen_bonded: 408>

gen_bonded_angle = <ScoreType.gen_bonded_angle: 410>

gen_bonded_bond = <ScoreType.gen_bonded_bond: 409>

gen_bonded_improper = <ScoreType.gen_bonded_improper: 412>

gen_bonded_torsion = <ScoreType.gen_bonded_torsion: 411>

geom_sol = <ScoreType.geom_sol: 216>

geom_sol_fast = <ScoreType.geom_sol_fast: 159>

geom_sol_fast_intra_RNA = <ScoreType.geom_sol_fast_intra_RNA: 160>

geom_sol_intra_RNA = <ScoreType.geom_sol_intra_RNA: 217>

goap = <ScoreType.goap: 237>

goap_angle = <ScoreType.goap_angle: 239>

goap_dist = <ScoreType.goap_dist: 238>

grid_vdw = <ScoreType.grid_vdw: 455>

h2o_hbond = <ScoreType.h2o_hbond: 54>

h2o_intra = <ScoreType.h2o_intra: 288>

hack_aro = <ScoreType.hack_aro: 90>

hbnet = <ScoreType.hbnet: 466>

hbond = <ScoreType.hbond: 194>

hbond_bb_sc = <ScoreType.hbond_bb_sc: 187>

hbond_intra = <ScoreType.hbond_intra: 191>

hbond_lr_bb = <ScoreType.hbond_lr_bb: 186>

hbond_lr_bb_sc = <ScoreType.hbond_lr_bb_sc: 189>

hbond_ref = <ScoreType.hbond_ref: 434>

hbond_sc = <ScoreType.hbond_sc: 190>

hbond_sr_bb = <ScoreType.hbond_sr_bb: 185>

hbond_sr_bb_sc = <ScoreType.hbond_sr_bb_sc: 188>

hbond_wat = <ScoreType.hbond_wat: 192>

hoh_ref = <ScoreType.hoh_ref: 134>

holes = <ScoreType.holes: 375>

holes_decoy = <ScoreType.holes_decoy: 376>

holes_min = <ScoreType.holes_min: 378>

holes_min_mean = <ScoreType.holes_min_mean: 379>

holes_resl = <ScoreType.holes_resl: 377>

hpatch = <ScoreType.hpatch: 459>

hrf_dynamics = <ScoreType.hrf_dynamics: 338>

hrf_ms_labeling = <ScoreType.hrf_ms_labeling: 337>

hs_pair = <ScoreType.hs_pair: 328>

hxl_tors = <ScoreType.hxl_tors: 287>

hybrid_vdw = <ScoreType.hybrid_vdw: 104>

interchain_contact = <ScoreType.interchain_contact: 391>

interchain_env = <ScoreType.interchain_env: 390>

interchain_pair = <ScoreType.interchain_pair: 241>

interchain_vdw = <ScoreType.interchain_vdw: 242>

interface_dd_pair = <ScoreType.interface_dd_pair: 215>

intermol = <ScoreType.intermol: 308>

linear_branch_conn = <ScoreType.linear_branch_conn: 398>

linear_chainbreak = <ScoreType.linear_chainbreak: 393>

lk_ball = <ScoreType.lk_ball: 21>

lk_ball_bridge = <ScoreType.lk_ball_bridge: 24>

lk_ball_bridge2 = <ScoreType.lk_ball_bridge2: 30>

lk_ball_bridge_uncpl = <ScoreType.lk_ball_bridge_uncpl: 25>

lk_ball_bridge_uncpl2 = <ScoreType.lk_ball_bridge_uncpl2: 31>

lk_ball_iso = <ScoreType.lk_ball_iso: 23>

lk_ball_wtd = <ScoreType.lk_ball_wtd: 22>

lk_costheta = <ScoreType.lk_costheta: 44>

lk_dome = <ScoreType.lk_dome: 26>

lk_dome_bridge = <ScoreType.lk_dome_bridge: 28>

lk_dome_bridge_uncpl = <ScoreType.lk_dome_bridge_uncpl: 29>

lk_dome_iso = <ScoreType.lk_dome_iso: 27>

lk_dome_pack = <ScoreType.lk_dome_pack: 32>

lk_hack = <ScoreType.lk_hack: 20>

lk_nonpolar = <ScoreType.lk_nonpolar: 46>

lk_nonpolar_intra_RNA = <ScoreType.lk_nonpolar_intra_RNA: 48>

lk_polar = <ScoreType.lk_polar: 45>

lk_polar_intra_RNA = <ScoreType.lk_polar_intra_RNA: 47>

loop_close = <ScoreType.loop_close: 342>

membrane_span_constraint = <ScoreType.membrane_span_constraint: 487>

membrane_span_term_z_constraint = <ScoreType.membrane_span_term_z_constraint: 488>

metalbinding_constraint = <ScoreType.metalbinding_constraint: 271>

metalhash_constraint = <ScoreType.metalhash_constraint: 270>

mg = <ScoreType.mg: 130>

mg_lig = <ScoreType.mg_lig: 131>

mg_ref = <ScoreType.mg_ref: 133>

mg_sol = <ScoreType.mg_sol: 132>

mhc_epitope = <ScoreType.mhc_epitope: 418>

missing_res = <ScoreType.missing_res: 343>

mm_bend = <ScoreType.mm_bend: 42>

mm_lj_inter_atr = <ScoreType.mm_lj_inter_atr: 40>

mm_lj_inter_rep = <ScoreType.mm_lj_inter_rep: 39>

mm_lj_intra_atr = <ScoreType.mm_lj_intra_atr: 38>

mm_lj_intra_atr_ref = <ScoreType.mm_lj_intra_atr_ref: 448>

mm_lj_intra_rep = <ScoreType.mm_lj_intra_rep: 37>

mm_lj_intra_rep_ref = <ScoreType.mm_lj_intra_rep_ref: 447>

mm_stretch = <ScoreType.mm_stretch: 43>

mm_twist = <ScoreType.mm_twist: 41>

mm_twist_ref = <ScoreType.mm_twist_ref: 449>

motif_dock = <ScoreType.motif_dock: 235>

mp_span_ang = <ScoreType.mp_span_ang: 357>

multipole_elec = <ScoreType.multipole_elec: 244>

n_ci_2b_score_types = <ScoreType.python: 180>

n_score_types = <ScoreType.dummy_score_type: 492>

n_shortranged_2b_score_types = <ScoreType.interchain_vdw: 242>

property name

natbias_hh = <ScoreType.natbias_hh: 361>

natbias_hs = <ScoreType.natbias_hs: 360>

natbias_ss = <ScoreType.natbias_ss: 359>

natbias_stwist = <ScoreType.natbias_stwist: 362>

neigh_count = <ScoreType.neigh_count: 414>

neigh_vect = <ScoreType.neigh_vect: 413>

neigh_vect_raw = <ScoreType.neigh_vect_raw: 415>

netcharge = <ScoreType.netcharge: 468>

nmer_pssm = <ScoreType.nmer_pssm: 293>

nmer_ref = <ScoreType.nmer_ref: 292>

nmer_svm = <ScoreType.nmer_svm: 294>

nmr_pcs = <ScoreType.nmr_pcs: 370>

nmr_pre = <ScoreType.nmr_pre: 372>

nmr_rdc = <ScoreType.nmr_rdc: 371>

npd_hbond = <ScoreType.npd_hbond: 202>

npd_hbond_bb_sc = <ScoreType.npd_hbond_bb_sc: 197>

npd_hbond_intra = <ScoreType.npd_hbond_intra: 201>

npd_hbond_lr_bb = <ScoreType.npd_hbond_lr_bb: 196>

npd_hbond_lr_bb_sc = <ScoreType.npd_hbond_lr_bb_sc: 199>

npd_hbond_sc = <ScoreType.npd_hbond_sc: 200>

npd_hbond_sr_bb = <ScoreType.npd_hbond_sr_bb: 195>

npd_hbond_sr_bb_sc = <ScoreType.npd_hbond_sr_bb_sc: 198>

occ_sol_exact = <ScoreType.occ_sol_exact: 220>

occ_sol_fitted = <ScoreType.occ_sol_fitted: 218>

occ_sol_fitted_onebody = <ScoreType.occ_sol_fitted_onebody: 219>

omega = <ScoreType.omega: 277>

omega_ref = <ScoreType.omega_ref: 446>

orbitals_hpol_bb = <ScoreType.orbitals_hpol_bb: 163>

other_pose = <ScoreType.other_pose: 309>

overlap_chainbreak = <ScoreType.overlap_chainbreak: 394>

p_aa = <ScoreType.p_aa: 427>

p_aa_pp = <ScoreType.p_aa_pp: 284>

p_aa_pp_ref = <ScoreType.p_aa_pp_ref: 445>

p_aa_ss = <ScoreType.p_aa_ss: 285>

paa_abego3 = <ScoreType.paa_abego3: 400>

pack_stat = <ScoreType.pack_stat: 419>

pair = <ScoreType.pair: 224>

pci_cation_pi = <ScoreType.pci_cation_pi: 164>

pci_hbond = <ScoreType.pci_hbond: 167>

pci_pi_pi = <ScoreType.pci_pi_pi: 165>

pci_salt_bridge = <ScoreType.pci_salt_bridge: 166>

pcs = <ScoreType.pcs: 60>

pcs2 = <ScoreType.pcs2: 65>

pcsTs1 = <ScoreType.pcsTs1: 61>

pcsTs2 = <ScoreType.pcsTs2: 62>

pcsTs3 = <ScoreType.pcsTs3: 63>

pcsTs4 = <ScoreType.pcsTs4: 64>

pddf_score = <ScoreType.pddf_score: 70>

peptide_bond = <ScoreType.peptide_bond: 59>

pocket_constraint = <ScoreType.pocket_constraint: 423>

pointwater = <ScoreType.pointwater: 236>

pro_close = <ScoreType.pro_close: 98>

pro_close_ref = <ScoreType.pro_close_ref: 439>

python = <ScoreType.python: 180>

rama = <ScoreType.rama: 276>

rama2b = <ScoreType.rama2b: 99>

rama_prepro = <ScoreType.rama_prepro: 399>

rama_ref = <ScoreType.rama_ref: 444>

rdc = <ScoreType.rdc: 367>

rdc_rohl = <ScoreType.rdc_rohl: 369>

rdc_segments = <ScoreType.rdc_segments: 368>

ref = <ScoreType.ref: 289>

ref_nc = <ScoreType.ref_nc: 290>

res_type_constraint = <ScoreType.res_type_constraint: 421>

res_type_linking_constraint = <ScoreType.res_type_linking_constraint: 422>

rg = <ScoreType.rg: 325>

rg_local = <ScoreType.rg_local: 326>

ring_close = <ScoreType.ring_close: 462>

rms = <ScoreType.rms: 420>

rna_backbone_backbone = <ScoreType.rna_backbone_backbone: 109>

rna_base_axis = <ScoreType.rna_base_axis: 118>

rna_base_axis_pairwise = <ScoreType.rna_base_axis_pairwise: 112>

rna_base_backbone = <ScoreType.rna_base_backbone: 108>

rna_base_pair = <ScoreType.rna_base_pair: 117>

rna_base_pair_pairwise = <ScoreType.rna_base_pair_pairwise: 111>

rna_base_stack = <ScoreType.rna_base_stack: 120>

rna_base_stack_axis = <ScoreType.rna_base_stack_axis: 121>

rna_base_stack_axis_pairwise = <ScoreType.rna_base_stack_axis_pairwise: 115>

rna_base_stack_pairwise = <ScoreType.rna_base_stack_pairwise: 114>

rna_base_stagger = <ScoreType.rna_base_stagger: 119>

rna_base_stagger_pairwise = <ScoreType.rna_base_stagger_pairwise: 113>

rna_bond_geometry = <ScoreType.rna_bond_geometry: 274>

rna_bulge = <ScoreType.rna_bulge: 297>

rna_chem_map = <ScoreType.rna_chem_map: 381>

rna_chem_map_lores = <ScoreType.rna_chem_map_lores: 382>

rna_chem_shift = <ScoreType.rna_chem_shift: 380>

rna_coarse_dist = <ScoreType.rna_coarse_dist: 490>

rna_data_backbone = <ScoreType.rna_data_backbone: 93>

rna_data_base = <ScoreType.rna_data_base: 116>

rna_fa_atr_base = <ScoreType.rna_fa_atr_base: 91>

rna_fa_rep_base = <ScoreType.rna_fa_rep_base: 92>

rna_jr_suite = <ScoreType.rna_jr_suite: 138>

rna_mg_point = <ScoreType.rna_mg_point: 128>

rna_mg_point_indirect = <ScoreType.rna_mg_point_indirect: 129>

rna_motif = <ScoreType.rna_motif: 231>

rna_partition = <ScoreType.rna_partition: 383>

rna_repulsive = <ScoreType.rna_repulsive: 110>

rna_rg = <ScoreType.rna_rg: 230>

rna_stub_coord_hack = <ScoreType.rna_stub_coord_hack: 272>

rna_sugar_close = <ScoreType.rna_sugar_close: 141>

rna_suite = <ScoreType.rna_suite: 137>

rna_torsion = <ScoreType.rna_torsion: 135>

rna_torsion_sc = <ScoreType.rna_torsion_sc: 136>

rna_vdw = <ScoreType.rna_vdw: 106>

rnp_aa_to_rna_backbone = <ScoreType.rnp_aa_to_rna_backbone: 127>

rnp_base_pair = <ScoreType.rnp_base_pair: 122>

rnp_env = <ScoreType.rnp_env: 341>

rnp_pair = <ScoreType.rnp_pair: 125>

rnp_pair_dist = <ScoreType.rnp_pair_dist: 126>

rnp_stack = <ScoreType.rnp_stack: 123>

rnp_stack_xy = <ScoreType.rnp_stack_xy: 124>

rnp_vdw = <ScoreType.rnp_vdw: 107>

rsigma = <ScoreType.rsigma: 330>

sa = <ScoreType.sa: 386>

sap_constraint = <ScoreType.sap_constraint: 470>

saxs_cen_score = <ScoreType.saxs_cen_score: 68>

saxs_fa_score = <ScoreType.saxs_fa_score: 69>

saxs_score = <ScoreType.saxs_score: 67>

seqdep_ref = <ScoreType.seqdep_ref: 291>

sheet = <ScoreType.sheet: 331>

sidechain_neighbors = <ScoreType.sidechain_neighbors: 485>

site_constraint = <ScoreType.site_constraint: 269>

span_ins = <ScoreType.span_ins: 356>

special_rot = <ScoreType.special_rot: 310>

split_unfolded_two_body = <ScoreType.split_unfolded_two_body: 429>

ss_contact_worst = <ScoreType.ss_contact_worst: 151>

ss_pair = <ScoreType.ss_pair: 329>

stack_elec = <ScoreType.stack_elec: 152>

stack_elec_base_base = <ScoreType.stack_elec_base_base: 153>

stack_elec_base_bb = <ScoreType.stack_elec_base_bb: 154>

suck = <ScoreType.suck: 229>

sugar_bb = <ScoreType.sugar_bb: 301>

suiteness_bonus = <ScoreType.suiteness_bonus: 139>

surface = <ScoreType.surface: 426>

symE_bonus = <ScoreType.symE_bonus: 416>

sym_lig = <ScoreType.sym_lig: 417>

target_clash = <ScoreType.target_clash: 486>

tna_suite = <ScoreType.tna_suite: 140>

total_score = <ScoreType.total_score: 491>

unfolded = <ScoreType.unfolded: 428>

property value

vdw = <ScoreType.vdw: 100>

voids_penalty = <ScoreType.voids_penalty: 469>

wat_desolv = <ScoreType.wat_desolv: 461>

wat_entropy = <ScoreType.wat_entropy: 193>

xtal_ml = <ScoreType.xtal_ml: 456>

xtal_rfree = <ScoreType.xtal_rfree: 458>

xtal_rwork = <ScoreType.xtal_rwork: 457>

yhh_planarity = <ScoreType.yhh_planarity: 286>

class pyrosetta.rosetta.core.scoring.ScoreTypeManager

Bases: pybind11_object

static is_score_type(name: str) → bool

C++: core::scoring::ScoreTypeManager::is_score_type(const std::string &) –> bool

static name_from_score_type(score_type: pyrosetta.rosetta.core.scoring.ScoreType) → str

C++: core::scoring::ScoreTypeManager::name_from_score_type(enum core::scoring::ScoreType) –> std::string

static score_type_from_name(name: str) → pyrosetta.rosetta.core.scoring.ScoreType

C++: core::scoring::ScoreTypeManager::score_type_from_name(const std::string &) –> enum core::scoring::ScoreType

class pyrosetta.rosetta.core.scoring.ScoringManager

Bases: SingletonBase_core_scoring_ScoringManager_t

add_memb_etable(self: pyrosetta.rosetta.core.scoring.ScoringManager, name: str, etable: core::scoring::etable::MembEtable) → None

Add a new membrane energy table to the membrane energy tables map.

Made threadsafe on 25 July 2017.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::add_memb_etable(const std::string &, class std::shared_ptr<class core::scoring::etable::MembEtable>) –> void

static create_mhc_epitope_energy_setup_instance(filename: str) → pyrosetta.rosetta.core.scoring.mhc_epitope_energy.MHCEpitopeEnergySetup

Create an instance of an MHCEpitopeEnergySetup object, by owning pointer.

Needed for threadsafe creation. Loads data from disk. NOT for repeated calls!

Not intended for use outside of ScoringManager.

Chris Bailey-Kellogg (cbk copied from Vikram K. Mulligan’s netcharge_energy

C++: core::scoring::ScoringManager::create_mhc_epitope_energy_setup_instance(const std::string &) –> class std::shared_ptr<class core::scoring::mhc_epitope_energy::MHCEpitopeEnergySetup>

energy_method(self: pyrosetta.rosetta.core.scoring.ScoringManager, t: pyrosetta.rosetta.core.scoring.ScoreType, options: pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions) → pyrosetta.rosetta.core.scoring.methods.EnergyMethod

When a ScoreFunction the weight for a particular ScoreType set from 0

to some non-zero value, it will request an instance of the EnergyMethod class that is responsible for calculating that ScoreType. The ScoringManager responds to that request by asking the EnergyMethodCreator that has claimed responsibility for this ScoreType for a new instance. EnergyMethodCreators must first have registered themselves with the ScoringManager. This should have been done at load time, using a static-variable-initialization function call. See src/core/scoring/etable/EtableEnergy.cc for an example of how the EtableEnergyCreator class registers itself with the ScoringManager.

I THINK that this is threadsafe (VKM, 20 July 2017).

C++: core::scoring::ScoringManager::energy_method(const enum core::scoring::ScoreType &, const class core::scoring::methods::EnergyMethodOptions &) const –> class std::shared_ptr<class core::scoring::methods::EnergyMethod>

etable(*args, **kwargs)

Overloaded function.

1. etable(self: pyrosetta.rosetta.core.scoring.ScoringManager, options_in: pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions) -> pyrosetta.rosetta.std.weak_ptr_const_core_scoring_etable_Etable_t

Request an etable specifying an EnergyMethodOptions object; internally

this will retrieve the EtableOptions object, and invoke the EtableOptions version of this function.

Threadsafe, since this calls the threadsafe etable( EtableOptions) function, below.

Hahnbeom Park (new logic for etable)

One weak point of this method is that, change in frequently called but less relevant options such as weights, will invoke another etable construction.

C++: core::scoring::ScoringManager::etable(const class core::scoring::methods::EnergyMethodOptions &) const –> class std::weak_ptr<const class core::scoring::etable::Etable>

2. etable(self: pyrosetta.rosetta.core.scoring.ScoringManager, options_in: pyrosetta.rosetta.core.scoring.etable.EtableOptions) -> pyrosetta.rosetta.std.weak_ptr_const_core_scoring_etable_Etable_t

Request an etable specifying an EtableOptions; internally this will

query the ScoringManager’s map from EtableOptions to Etables for the desired Etable, and construct a new one if needed.

Made threadsafe on 25 July 2017.

Thread-safety added by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::etable(const class core::scoring::etable::EtableOptions &) const –> class std::weak_ptr<const class core::scoring::etable::Etable>

3. etable(self: pyrosetta.rosetta.core.scoring.ScoringManager, etable_id: str) -> pyrosetta.rosetta.std.weak_ptr_const_core_scoring_etable_Etable_t

Create and return an etable specified only by the etable_type of the

etable::EtableOptions class. This, internally, will create an EtableOptions object, initialized from the command line, set the etable_type of this object, and then invoke the etable( EtableOptions ) method.

Threadsafe, since this calls the threadsafe etable( EtableOptions ) function, above.

C++: core::scoring::ScoringManager::etable(const std::string &) const –> class std::weak_ptr<const class core::scoring::etable::Etable>

factory_register(self: pyrosetta.rosetta.core.scoring.ScoringManager, creator: pyrosetta.rosetta.core.scoring.methods.EnergyMethodCreator) → None

The ScoringManager acts as an EnergyMethodFactory. All EnergyMethods must

create a helper class, an EnergyMethodCreator class, that will respond to a call to its create_energy_method by returning a new instance of that EnergyMethod its helping. This Creator class must also register itself with the ScoringManager at load time and hand an instance of itself to the singleton ScoringManager instance.

I don’t think that this function is threadsafe (VKM, 20 July 2017), but it probably doesn’t matter. Factory registration presumably happens during Rosetta initialization, before any threads are spawned.

C++: core::scoring::ScoringManager::factory_register(class std::shared_ptr<class core::scoring::methods::EnergyMethodCreator>) –> void

get_AtomVDW(self: pyrosetta.rosetta.core.scoring.ScoringManager, atom_type_set_name: str) → pyrosetta.rosetta.core.scoring.AtomVDW

Get an instance of the AtomVDW scoring object.

Threadsafe and lazily loaded.

Each element in the atom_vdw_ map is now threadsafe and lazily loaded (independently). Each of these objects is also threadsafe, as far as I can tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_AtomVDW(const std::string &) const –> const class core::scoring::AtomVDW &

get_CHIEnergyFunction(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::carbohydrates::CHIEnergyFunction

Get an instance of the CHIEnergyFunction scoring object.

C++: core::scoring::ScoringManager::get_CHIEnergyFunction() const –> const class core::scoring::carbohydrates::CHIEnergyFunction &

get_CarbonHBondPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::carbon_hbonds::CarbonHBondPotential

Get an instance of the CarbonHBondPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_CarbonHBondPotential() const –> const class core::scoring::carbon_hbonds::CarbonHBondPotential &

get_CenHBPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.CenHBPotential

Get an instance of the CenHBPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_CenHBPotential() const –> const class core::scoring::CenHBPotential &

get_CenRotEnvPairPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.CenRotEnvPairPotential

Get an instance of the CenRotEnvPairPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_CenRotEnvPairPotential() const –> const class core::scoring::CenRotEnvPairPotential &

get_CentroidDisulfidePotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::disulfides::CentroidDisulfidePotential

Get an instance of the CentroidDisulfidePotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_CentroidDisulfidePotential() const –> const class core::scoring::disulfides::CentroidDisulfidePotential &

get_DDPLookupTable(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::interface_::DDPlookup

Get an instance of the DDPlookup scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_DDPLookupTable() const –> const class core::scoring::interface_::DDPlookup &

get_DNABFormPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::dna::DNABFormPotential

Get an instance of the DNABFormPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_DNABFormPotential() const –> const class core::scoring::dna::DNABFormPotential &

get_DNATorsionPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::dna::DNATorsionPotential

Get an instance of the DNATorsionPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_DNATorsionPotential() const –> const class core::scoring::dna::DNATorsionPotential &

get_DNA_BasePotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::dna::DNA_BasePotential

Get an instance of the DNA_BasePotential scoring object, by const owning pointer.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan.

C++: core::scoring::ScoringManager::get_DNA_BasePotential() const –> const class core::scoring::dna::DNA_BasePotential &

get_DNA_DihedralPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::dna::DNA_DihedralPotential

Get an instance of the DNA_DihedralPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_DNA_DihedralPotential() const –> const class core::scoring::dna::DNA_DihedralPotential &

get_DNA_EnvPairPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::dna::DNA_EnvPairPotential

Get an instance of the DNA_EnvPairPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_DNA_EnvPairPotential() const –> const class core::scoring::dna::DNA_EnvPairPotential &

get_DatabaseOccSolEne(self: pyrosetta.rosetta.core.scoring.ScoringManager, atom_type_set_name: str, min_occ_energy: float) → core::scoring::geometric_solvation::DatabaseOccSolEne

Get an instance of the DatabaseOccSolEne scoring object.

Threadsafe and lazily loaded.

Whatever atom type set name and min occ energy are passed to this function the FIRST time determine the object that gets created. These parameters are unused in subsequent invocations. This aside, the targeted object is threadsafe, as far as I can tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_DatabaseOccSolEne(const std::string &, const double &) const –> const class core::scoring::geometric_solvation::DatabaseOccSolEne &

get_DirectReadoutPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::dna::DirectReadoutPotential

Get an instance of the DirectReadoutPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_DirectReadoutPotential() const –> const class core::scoring::dna::DirectReadoutPotential &

get_DisulfideMatchingPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::disulfides::DisulfideMatchingPotential

Get an instance of the DisulfideMatchingPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_DisulfideMatchingPotential() const –> const class core::scoring::disulfides::DisulfideMatchingPotential &

get_EnvPairPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.EnvPairPotential

Get an instance of the EnvPairPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_EnvPairPotential() const –> const class core::scoring::EnvPairPotential &

get_FACTSPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::facts::FACTSPotential

Get an instance of the FACTSPotential scoring object, by const owning pointer.

Threadsafe and lazily loaded.

The FACTSPotential caches pose data to the global FACTSPotential object during scoring. As such, it is fundamentally NOT THREADSAFE!!! (Only the creation of this object is threadsafe).

Rewritten by Vikram K. Mulligan.

C++: core::scoring::ScoringManager::get_FACTSPotential() const –> const class core::scoring::facts::FACTSPotential &

get_FullatomDisulfidePotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::disulfides::FullatomDisulfidePotential

Get an instance of the FullatomDisulfidePotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_FullatomDisulfidePotential() const –> const class core::scoring::disulfides::FullatomDisulfidePotential &

get_GenBornPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.GenBornPotential

Get a const instance of the GenBornPotential.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan.

C++: core::scoring::ScoringManager::get_GenBornPotential() const –> const class core::scoring::GenBornPotential &

get_GenericBondedPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.GenericBondedPotential

Get an instance of the GenericBondedPotential scoring object, by const owning pointer.

Threadsafe and lazily loaded.

C++: core::scoring::ScoringManager::get_GenericBondedPotential() const –> const class core::scoring::GenericBondedPotential &

get_HydroxylTorsionPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.HydroxylTorsionPotential

Get a const instance of the HydroxylTorsionPotential.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan.

C++: core::scoring::ScoringManager::get_HydroxylTorsionPotential() const –> const class core::scoring::HydroxylTorsionPotential &

get_LoopCloseSixDPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager, database_file: str) → core::scoring::loop_graph::evaluator::SixDTransRotPotential

Get an instance of the SixDTransRotPotential scoring object, by const owning pointer.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_LoopCloseSixDPotential(const std::string &) const –> class std::shared_ptr<const class core::scoring::loop_graph::evaluator::SixDTransRotPotential>

get_MMBondAngleLibrary(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::mm::MMBondAngleLibrary

Get an instance of the MMBondAngleLibrary scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_MMBondAngleLibrary() const –> const class core::scoring::mm::MMBondAngleLibrary &

get_MMBondLengthLibrary(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::mm::MMBondLengthLibrary

Get an instance of the MMBondLengthLibrary scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_MMBondLengthLibrary() const –> const class core::scoring::mm::MMBondLengthLibrary &

get_MMLJEnergyTable(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::mm::MMLJEnergyTable

Get an instance of the MMLJEnergyTable scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_MMLJEnergyTable() const –> const class core::scoring::mm::MMLJEnergyTable &

get_MMLJLibrary(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::mm::MMLJLibrary

Get an instance of the MMLJLibrary scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_MMLJLibrary() const –> const class core::scoring::mm::MMLJLibrary &

get_MMTorsionLibrary(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::mm::MMTorsionLibrary

Get an instance of the MMTorsionLibrary scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_MMTorsionLibrary() const –> const class core::scoring::mm::MMTorsionLibrary &

get_MembraneData(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::membrane::MembraneData

Get an instance of the MembraneData scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_MembraneData() const –> const class core::scoring::membrane::MembraneData &

get_MembranePotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.MembranePotential

Get an instance of the MembranePotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_MembranePotential() const –> const class core::scoring::MembranePotential &

get_Membrane_FAPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.Membrane_FAPotential

Get an instance of the Membrane_FAPotential scoring object.

Threadsafe and lazily loaded.

The Membrane_FAPotential object is fundamentally NOT THREADSAFE!!!

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_Membrane_FAPotential() const –> const class core::scoring::Membrane_FAPotential &

get_MultipoleElecPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager, options: pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions) → pyrosetta.rosetta.core.scoring.MultipoleElecPotential

Get an instance of the MultipoleElecPotential scoring object.

Threadsafe creation, lazily loaded.

The MultipoleElecPotential caches pose data to the global MultipleElecPotential object during scoring. As such, it is fundamentally NOT THREADSAFE!!! (Only the creation of this object is threadsafe.)

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_MultipoleElecPotential(const class core::scoring::methods::EnergyMethodOptions &) const –> const class core::scoring::MultipoleElecPotential &

get_NVLookupTable(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::nv::NVlookup

Get an instance of the NVlookup scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_NVLookupTable() const –> const class core::scoring::nv::NVlookup &

get_OmegaPreferencesFunction(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::carbohydrates::OmegaPreferencesFunction

Get an instance of the OmegaPreferencesFunction scoring object.

C++: core::scoring::ScoringManager::get_OmegaPreferencesFunction() const –> const class core::scoring::carbohydrates::OmegaPreferencesFunction &

get_OmegaTether(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.OmegaTether

Get an instance of the OmegaTether scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_OmegaTether() const –> const class core::scoring::OmegaTether &

get_OneDDistPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager, potential_file_name: str) → pyrosetta.rosetta.core.scoring.OneDDistPotential

Get an instance of an OneDDistPotential

Threadsafe and lazily loaded.

Each element in the one_d_interpolated_potentials_ map is now threadsafe and lazily loaded (independently).

Andy Watkins (amw579.edu)

C++: core::scoring::ScoringManager::get_OneDDistPotential(const std::string &) const –> const class core::scoring::OneDDistPotential &

get_OrbitalsLookupTable(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::orbitals::OrbitalsLookup

Get an instance of the OrbitalsLookup scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_OrbitalsLookupTable() const –> const class core::scoring::orbitals::OrbitalsLookup &

get_P_AA(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.P_AA

Get an instance of the P_AA scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_P_AA() const –> const class core::scoring::P_AA &

get_P_AA_ABEGO3(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.P_AA_ABEGO3

Get an instance of the P_AA_ABEGO3 scoring object.

Threadsafe and lazily loaded. Used by AbegoEnergy.

Targeted object is also threadsafe, to the best of my ability to tell.

imv.edu

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_P_AA_ABEGO3() const –> const class core::scoring::P_AA_ABEGO3 &

get_P_AA_ss(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.P_AA_ss

Get an instance of the P_AA_ss scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_P_AA_ss() const –> const class core::scoring::P_AA_ss &

get_PairEPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.PairEPotential

Get a const instance of the PairEPotential.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan.

C++: core::scoring::ScoringManager::get_PairEPotential() const –> const class core::scoring::PairEPotential &

get_PointWaterPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.PointWaterPotential

C++: core::scoring::ScoringManager::get_PointWaterPotential() const –> const class core::scoring::PointWaterPotential &

get_PoissonBoltzmannPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.PoissonBoltzmannPotential

Get an instance of the PoissonBoltzmannPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_PoissonBoltzmannPotential() const –> const class core::scoring::PoissonBoltzmannPotential &

get_ProQPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.ProQPotential

Get an instance of the ProQPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_ProQPotential() const –> const class core::scoring::ProQPotential &

get_RNA_AtomVDW(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::rna::RNA_AtomVDW

Get an instance of the RNA_AtomVDW scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_RNA_AtomVDW() const –> const class core::scoring::rna::RNA_AtomVDW &

get_RNA_ChemicalShiftPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.rna.chemical_shift.RNA_ChemicalShiftPotential

Get an instance of the RNA_ChemicalShiftPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_RNA_ChemicalShiftPotential() const –> const class core::scoring::rna::chemical_shift::RNA_ChemicalShiftPotential &

get_RNA_DMS_LowResolutionPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::rna::data::RNA_DMS_LowResolutionPotential

Get an instance of the RNA_DMS_LowResolutionPotential scoring object.

Threadsafe and lazily loaded.

The RNA_DMS_LowResolutionPotential itself is fundamentally NOT THREADSAFE!!! Note that this function returns a non-const instance (which it shouldn’t).

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_RNA_DMS_LowResolutionPotential() const –> class core::scoring::rna::data::RNA_DMS_LowResolutionPotential &

get_RNA_DMS_Potential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::rna::data::RNA_DMS_Potential

Get an instance of the RNA_DMS_Potential scoring object.

Threadsafe and lazily loaded.

The RNA_DMS_Potential itself is fundamentally NOT THREADSAFE!!! Note that this function returns a non-const instance (which it shouldn’t).

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_RNA_DMS_Potential() const –> class core::scoring::rna::data::RNA_DMS_Potential &

get_RNA_LowResolutionPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager, database_file: str) → core::scoring::rna::RNA_LowResolutionPotential

Get an instance of the RNA_LowResolutionPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_RNA_LowResolutionPotential(const std::string &) const –> class std::shared_ptr<const class core::scoring::rna::RNA_LowResolutionPotential>

get_RNP_LowResPairDistPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::rna::RNP_LowResPairDistPotential

Get an instance of the RNP_LowResPairDistPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Andrew Watkins (amw579.edu)

C++: core::scoring::ScoringManager::get_RNP_LowResPairDistPotential() const –> const class core::scoring::rna::RNP_LowResPairDistPotential &

get_RNP_LowResPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::rna::RNP_LowResPotential

Get an instance of the RNP_LowResPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_RNP_LowResPotential() const –> const class core::scoring::rna::RNP_LowResPotential &

get_RNP_LowResStackData(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::rna::RNP_LowResStackData

Get an instance of the RNP_LowResStackData scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_RNP_LowResStackData() const –> const class core::scoring::rna::RNP_LowResStackData &

get_RamaPrePro(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.RamaPrePro

Get an instance of the RamaPrePro scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_RamaPrePro() const –> const class core::scoring::RamaPrePro &

get_Ramachandran(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.Ramachandran

Get a const instance of the Ramachandran scoring object.

Threadsafe and lazily loaded.

The Ramachandran object does lazily load custom cumulative distribution functions. However, these are finite and governed by an enum. In the MULTI_THREADED case, these are all loaded on object creation, which should get around thread- safety issues.

Rewritten by Vikram K. Mulligan.

C++: core::scoring::ScoringManager::get_Ramachandran() const –> const class core::scoring::Ramachandran &

get_Ramachandran2B(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.Ramachandran2B

Get an instance of the Ramachandran2B scoring object, by const instance.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_Ramachandran2B() const –> const class core::scoring::Ramachandran2B &

get_Ramachandran2B_ptr(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.Ramachandran2B

Get an instance of the Ramachandran2B scoring object, by const owning pointer.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_Ramachandran2B_ptr() const –> class std::shared_ptr<const class core::scoring::Ramachandran2B>

get_Ramachandran_ptr(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.Ramachandran

Get an instance of the Ramachandran scoring object, by const owning pointer.

Threadsafe and lazily loaded.

The Ramachandran object does lazily load custom cumulative distribution functions. However, these are finite and governed by an enum. In the MULTI_THREADED case, these are all loaded on object creation, which should get around thread- safety issues.

Rewritten by Vikram K. Mulligan.

C++: core::scoring::ScoringManager::get_Ramachandran_ptr() const –> class std::shared_ptr<const class core::scoring::Ramachandran>

get_SASAPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.SASAPotential

Get an instance of the SASAPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_SASAPotential() const –> const class core::scoring::SASAPotential &

get_SecondaryStructurePotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::SecondaryStructurePotential

Get an instance of the SecondaryStructurePotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_SecondaryStructurePotential() const –> const class core::scoring::SecondaryStructurePotential &

get_SmoothEnvPairPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential

Get an instance of the SmoothEnvPairPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_SmoothEnvPairPotential() const –> const class core::scoring::SmoothEnvPairPotential &

get_SplitUnfoldedTwoBodyPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager, label_type: str, value_type: str, score_func_type: str) → core::scoring::SplitUnfoldedTwoBodyPotential

Get an instance of the SplitUnfoldedTwoBodyPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_SplitUnfoldedTwoBodyPotential(const std::string &, const std::string &, const std::string &) const –> const class core::scoring::SplitUnfoldedTwoBodyPotential &

get_UnfoldedStatePotential(self: pyrosetta.rosetta.core.scoring.ScoringManager, type: str) → core::scoring::UnfoldedStatePotential

Get an instance of the UnfoldedStatePotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_UnfoldedStatePotential(const std::string &) const –> const class core::scoring::UnfoldedStatePotential &

get_VdWTinkerPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::VdWTinkerPotential

Get an instance of the VdWTinkerPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_VdWTinkerPotential() const –> const class core::scoring::VdWTinkerPotential &

get_WaterAdductHBondPotential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::WaterAdductHBondPotential

Get an instance of the WaterAdductHBondPotential scoring object.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_WaterAdductHBondPotential() const –> const class core::scoring::WaterAdductHBondPotential &

get_cloned_aa_comp_setup_helpers(self: pyrosetta.rosetta.core.scoring.ScoringManager, options: pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_aa_composition_energy_AACompositionEnergySetup_t

Get a vector of owning pointers to data used by the AACompositionEnergy score term.

If this vector has not yet been populated, this loads the data from disk (lazy loading).

The lazy loading has been made threadsafe, as of the wee hours of 26 July 2017.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_cloned_aa_comp_setup_helpers(const class core::scoring::methods::EnergyMethodOptions &) const –> class utility::vector1<class std::shared_ptr<class core::scoring::aa_composition_energy::AACompositionEnergySetup>, class std::allocator<class std::shared_ptr<class core::scoring::aa_composition_energy::AACompositionEnergySetup> > >

get_cloned_mhc_epitope_setup_helpers(self: pyrosetta.rosetta.core.scoring.ScoringManager, options: pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_mhc_epitope_energy_MHCEpitopeEnergySetup_t

Get a vector of owning pointers to data used by the MHCEpitopeEnergy score term.

If this vector has not yet been populated, this loads the data from disk (lazy loading).

The lazy loading has been made threadsafe.

Chris Bailey-Kellogg (cbk copied from Vikram K. Mulligan’s netcharge_energy

C++: core::scoring::ScoringManager::get_cloned_mhc_epitope_setup_helpers(const class core::scoring::methods::EnergyMethodOptions &) const –> class utility::vector1<class std::shared_ptr<class core::scoring::mhc_epitope_energy::MHCEpitopeEnergySetup>, class std::allocator<class std::shared_ptr<class core::scoring::mhc_epitope_energy::MHCEpitopeEnergySetup> > >

get_cloned_netcharge_setup_helpers(self: pyrosetta.rosetta.core.scoring.ScoringManager, options: pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_netcharge_energy_NetChargeEnergySetup_t

Get a vector of owning pointers to data used by the NetChargeEnergy score term.

If this vector has not yet been populated, this loads the data from disk (lazy loading).

The lazy loading has been made threadsafe.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_cloned_netcharge_setup_helpers(const class core::scoring::methods::EnergyMethodOptions &) const –> class utility::vector1<class std::shared_ptr<class core::scoring::netcharge_energy::NetChargeEnergySetup>, class std::allocator<class std::shared_ptr<class core::scoring::netcharge_energy::NetChargeEnergySetup> > >

get_cp_rep_map_byname(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.std.map_std_string_std_map_std_string_std_string_std_less_std_string_std_allocator_std_pair_const_std_string_std_string_t_std_allocator_std_pair_const_std_string_std_map_std_string_std_string_std_less_std_string_std_allocator_std_pair_const_std_string_std_string_t

Get an owning pointer to data used by the FA_ElecEnergy in beta_nov15 mode.

If the data have not been loaded, this loads the data (lazy loading). Lazy loading is now threadsafe.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_cp_rep_map_byname() const –> class std::shared_ptr<const class std::map<std::string, class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > > > > > >

get_edens_stats_table(self: pyrosetta.rosetta.core.scoring.ScoringManager) → pyrosetta.rosetta.core.scoring.DensityZscoresStatsSetup

Get a const reference to an edens stats std::map.

Gabriella Reggiano

C++: core::scoring::ScoringManager::get_edens_stats_table() const –> const class core::scoring::DensityZscoresStatsSetup &

static get_instance() → core::scoring::ScoringManager

C++: utility::SingletonBase<core::scoring::ScoringManager>::get_instance() –> class core::scoring::ScoringManager *

get_mhc_csv_contents(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str) → pyrosetta.rosetta.std.list_std_string_t

Get a const reference to a std::list containing the contents of a MHCEpitopePredictorPreLoaded csv database file.

This is a PreLoaded csv containing, for example, NetMHCII data to be used by MHCEpitopePredictorPreLoaded.

The file will be loaded as a list and sent back to the Predictor to be parsed, to avoid doing the latter in the ScoringManager class.

Brahm Yachnin (brahm.yachnin.edu).

C++: core::scoring::ScoringManager::get_mhc_csv_contents(const std::string &) const –> const class std::list<std::string, class std::allocator<std::string > > &

get_mhc_map_from_db(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str) → Tuple[pyrosetta.rosetta.std.map_std_string_double, int]

Get a const reference to a std::pair containing the a map corresponding a sqlite MHC db and the peptide length.

This is a PreLoaded database containing, for example, NetMHCII data to be used by MHCEpitopePredictorPreLoaded.

Brahm Yachnin (brahm.yachnin.edu).

C++: core::scoring::ScoringManager::get_mhc_map_from_db(const std::string &) const –> const struct std::pair<class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >, unsigned long> &

get_mhc_matrix_contents(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str) → pyrosetta.rosetta.std.list_std_string_t

Get a const reference to a std::list containing the contents of a MHCEpitopePredictorMatrix matrix file.

This is a matrix file containing, for example, Propred data to be used by MHCEpitopePredictorMatrix.

The file will be loaded as a list and sent back to the Predictor to be parsed, to avoid doing the latter in the ScoringManager class.

Brahm Yachnin (brahm.yachnin.edu).

C++: core::scoring::ScoringManager::get_mhc_matrix_contents(const std::string &) const –> const class std::list<std::string, class std::allocator<std::string > > &

get_nmer_pssm(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str, nmer_length: int) → pyrosetta.rosetta.std.map_core_chemical_AA_utility_vector1_double_std_allocator_double_t_std_allocator_std_pair_const_core_chemical_AA_utility_vector1_double_std_allocator_double_t

Get a const reference to an NMerPSSM.

Brahm Yachnin (brahm.yachnin.edu).

C++: core::scoring::ScoringManager::get_nmer_pssm(const std::string &, unsigned long) const –> const class std::map<enum core::chemical::AA, class utility::vector1<double, class std::allocator<double> >, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, class utility::vector1<double, class std::allocator<double> > > > > &

get_nmer_svm(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str) → utility::libsvm::Svm_rosetta

Get a const reference to an SVM object.

Used by the NMerSVMEnergy. Loaded lazily in a threadsafe manner.

Vikram K. Mulligan (vmulligan.org).

C++: core::scoring::ScoringManager::get_nmer_svm(const std::string &) const –> class std::shared_ptr<const class utility::libsvm::Svm_rosetta>

get_nmer_svm_aa_matrix(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str) → pyrosetta.rosetta.std.map_char_utility_vector1_double_std_allocator_double_t_std_allocator_std_pair_const_char_utility_vector1_double_std_allocator_double_t

Get the map of AA oneletter code->vector of floats used by the NMerSVMEnergy.

Loaded lazily in a threadsafe manner.

Vikram K. Mulligan (vmulligan.org).

C++: core::scoring::ScoringManager::get_nmer_svm_aa_matrix(const std::string &) const –> const class std::map<char, class utility::vector1<double, class std::allocator<double> >, struct std::less<char>, class std::allocator<struct std::pair<const char, class utility::vector1<double, class std::allocator<double> > > > > &

get_nmer_svm_list_file_contents(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str) → str

Get a string listing SVM files.

Used by the NMerSVMEnergy. Loaded lazily in a threadsafe manner.

Vikram K. Mulligan (vmulligan.org).

C++: core::scoring::ScoringManager::get_nmer_svm_list_file_contents(const std::string &) const –> const std::string &

get_nmer_svm_rank(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str) → pyrosetta.rosetta.utility.vector1_double

Get a const reference to a vector of floats corresponding to ranked SVM information.

Used by the NMerSVMEnergy. Loaded lazily in a threadsafe manner.

Vikram K. Mulligan (vmulligan.org).

C++: core::scoring::ScoringManager::get_nmer_svm_rank(const std::string &) const –> const class utility::vector1<double, class std::allocator<double> > &

get_nmer_svm_rank_list_file_contents(self: pyrosetta.rosetta.core.scoring.ScoringManager, filename: str) → str

Get a string listing SVM rank files.

Used by the NMerSVMEnergy. Loaded lazily in a threadsafe manner.

Vikram K. Mulligan (vmulligan.org).

C++: core::scoring::ScoringManager::get_nmer_svm_rank_list_file_contents(const std::string &) const –> const std::string &

get_rama_prepro_mainchain_torsion_potential(self: pyrosetta.rosetta.core.scoring.ScoringManager, restype: pyrosetta.rosetta.core.chemical.ResidueType, use_polycubic_interpolation: bool, prepro_table: bool) → pyrosetta.rosetta.core.chemical.mainchain_potential.MainchainScoreTable

Get a particular MainchainScoreTable for the rama_prepro score term, for a particular residue type.

If this has not yet been populated, loads the data from disk (lazy loading) in a threadsafe manner.

Each restype stores separate tables for general and pre-proline scoring. The prepro_table parameter determines whether we’re loading the default scoring table or the version for residues occurring before a proline.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_rama_prepro_mainchain_torsion_potential(class std::shared_ptr<const class core::chemical::ResidueType>, const bool, const bool) const –> class std::shared_ptr<const class core::chemical::mainchain_potential::MainchainScoreTable>

get_rna_suite_potential(self: pyrosetta.rosetta.core.scoring.ScoringManager, calculate_suiteness_bonus: bool, suiteness_bonus: str) → core::scoring::rna::RNA_SuitePotential

Get an instance of the RNA_SuitePotentialCOP scoring object, by const owning pointer.

Threadsafe and lazily loaded.

Targeted object is also threadsafe, to the best of my ability to tell.

Rewritten by Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoringManager::get_rna_suite_potential(const bool &, const std::string &) const –> class std::shared_ptr<const class core::scoring::rna::RNA_SuitePotential>

get_tna_suite_potential(self: pyrosetta.rosetta.core.scoring.ScoringManager) → core::scoring::rna::TNA_SuitePotential

Get an instance of the TNA_SuitePotentialCOP scoring object, by const owning pointer.

Threadsafe and lazily loaded.

The RNA_SuitePotential caches pose-specific scoring data in the global instance of the TNA_SuitePotential object. As such, it is fundamentally NOT THREADSAFE. (but this can and will be easily corrected)

Andy Watkins (amw579.edu).

C++: core::scoring::ScoringManager::get_tna_suite_potential() const –> const class core::scoring::rna::TNA_SuitePotential &

has_energy_method(self: pyrosetta.rosetta.core.scoring.ScoringManager, t: pyrosetta.rosetta.core.scoring.ScoreType) → bool

Test if there is an EnergyMethod class defined for a

given score type.

I THINK that this is threadsafe (VKM, 20 July 2017).

C++: core::scoring::ScoringManager::has_energy_method(enum core::scoring::ScoreType) const –> bool

make_partially_soft_etable(self: pyrosetta.rosetta.core.scoring.ScoringManager, name: str, etable_options: pyrosetta.rosetta.core.scoring.etable.EtableOptions) → pyrosetta.rosetta.core.scoring.etable.Etable

make etable for extra partially softies

Make etable for extra partial softies, pilot app r_play_with_etables does not really work anymore the etables it added will be somehow cleared or overwriten, so I do it here now

table_id: i.e. FA_STANDARD_SOFT40, the number in the end is a percentage, lj_radius are given for every 5% softie from 5% to 95% in database/chemical/atom_type_sets/fa_standard/extras/extra_soft_rep_params.txt FA_STANDARD_SOFT50 would be halfway between normal softrep and normal hardrep.

This is threadsafe but ugly – it creates a new object every time it’s invoked.

C++: core::scoring::ScoringManager::make_partially_soft_etable(const std::string &, class core::scoring::etable::EtableOptions) const –> class std::shared_ptr<class core::scoring::etable::Etable>

memb_etable(self: pyrosetta.rosetta.core.scoring.ScoringManager, table_id: str) → pyrosetta.rosetta.std.weak_ptr_const_core_scoring_etable_MembEtable_t

Get a membrane energy table from the membrane energy tables map.

Made threadsafe on 25 July 2017.

Rewritten by Vikram K. Mulligan (vmullig.edu)

C++: core::scoring::ScoringManager::memb_etable(const std::string &) const –> class std::weak_ptr<const class core::scoring::etable::MembEtable>

class pyrosetta.rosetta.core.scoring.SecondaryStructurePotential

Bases: pybind11_object

secondary structure scoring cut from classic rosetta structure.h/structure.cc

static rsigma_dot_initializer(rsigma_dot: pyrosetta.rosetta.ObjexxFCL.FArray4D_double_t) → 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_object

Holds weights and flags for configuring a SecondaryStructureEnergy evaluation

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

Bases: Predicate

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

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

class pyrosetta.rosetta.core.scoring.SmallAtNb

Bases: pybind11_object

atomno1(self: pyrosetta.rosetta.core.scoring.SmallAtNb) → int

C++: core::scoring::SmallAtNb::atomno1() const –> unsigned long

atomno2(self: pyrosetta.rosetta.core.scoring.SmallAtNb) → int

C++: core::scoring::SmallAtNb::atomno2() const –> unsigned long

path_dist(self: pyrosetta.rosetta.core.scoring.SmallAtNb) → int

C++: core::scoring::SmallAtNb::path_dist() const –> unsigned long

weight(self: pyrosetta.rosetta.core.scoring.SmallAtNb) → float

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

class pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential

Bases: pybind11_object

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

Bases: pybind11_object

add_gaussian(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs, g_in: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::SmoothScoreTermCoeffs::add_gaussian(class numeric::xyzVector<double>) –> void

add_sigmoid(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs, s_in: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::SmoothScoreTermCoeffs::add_sigmoid(class numeric::xyzVector<double>) –> void

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

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

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

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

dfunc(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs, x: float) → float

C++: core::scoring::SmoothScoreTermCoeffs::dfunc(double) const –> double

func(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs, x: float) → float

C++: core::scoring::SmoothScoreTermCoeffs::func(double) const –> double

gaussian(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs, i: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::SmoothScoreTermCoeffs::gaussian(unsigned long) –> class numeric::xyzVector<double>

ngaussians(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs) → int

C++: core::scoring::SmoothScoreTermCoeffs::ngaussians() –> unsigned long

nsigmoids(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs) → int

C++: core::scoring::SmoothScoreTermCoeffs::nsigmoids() –> unsigned long

shift(*args, **kwargs)

Overloaded function.

1. shift(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs, s_in: float) -> None

C++: core::scoring::SmoothScoreTermCoeffs::shift(double) –> void

2. shift(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs) -> float

C++: core::scoring::SmoothScoreTermCoeffs::shift() –> double

sigmoid(self: pyrosetta.rosetta.core.scoring.SmoothScoreTermCoeffs, i: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::SmoothScoreTermCoeffs::sigmoid(unsigned long) –> class numeric::xyzVector<double>

class pyrosetta.rosetta.core.scoring.SplitUnfoldedTwoBodyPotential

Bases: pybind11_object

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

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

get_restype_emap(self: pyrosetta.rosetta.core.scoring.SplitUnfoldedTwoBodyPotential, restype: pyrosetta.rosetta.core.chemical.ResidueType, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::SplitUnfoldedTwoBodyPotential::get_restype_emap(const class core::chemical::ResidueType &, class core::scoring::EMapVector &) const –> void

get_weights(self: pyrosetta.rosetta.core.scoring.SplitUnfoldedTwoBodyPotential) → pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::SplitUnfoldedTwoBodyPotential::get_weights() const –> class core::scoring::EMapVector

class pyrosetta.rosetta.core.scoring.SpringParams

Bases: pybind11_object

Parameter set for one torsion angle

Stores a set of constants required for enumerating a harmonic

function given length/angle as variable. This set of parameters are required for bond-length/-angle/improper torsion (gen_bonded_bond/_angle/_improper) scoring. More descriptions below:

E = k * (x-delta_)**2

E: Energy value x: variable of the function (e.g. bond length, angle, improper torsion angle) mult_: the specificity/generality of a constraint; when there is ambiguity

in multiple parameter set, one with lower mult_ is selected

delta(self: pyrosetta.rosetta.core.scoring.SpringParams) → float

C++: core::scoring::SpringParams::delta() const –> double

deriv(self: pyrosetta.rosetta.core.scoring.SpringParams, value: float) → float

C++: core::scoring::SpringParams::deriv(double) const –> double

energy(self: pyrosetta.rosetta.core.scoring.SpringParams, value: float) → float

getters

C++: core::scoring::SpringParams::energy(double) const –> double

is_null(self: pyrosetta.rosetta.core.scoring.SpringParams) → bool

C++: core::scoring::SpringParams::is_null() const –> bool

k(self: pyrosetta.rosetta.core.scoring.SpringParams) → float

C++: core::scoring::SpringParams::k() const –> double

multiplicity(self: pyrosetta.rosetta.core.scoring.SpringParams) → int

C++: core::scoring::SpringParams::multiplicity() const –> unsigned long

class pyrosetta.rosetta.core.scoring.Strands

Bases: pybind11_object

property SS_dimer

property SS_resnum

property SS_strand

property SS_strand_end

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

property dimer_neighbor

resize(self: pyrosetta.rosetta.core.scoring.Strands, nres: int) → None

C++: core::scoring::Strands::resize(const unsigned long) –> void

property total_SS_dimer

property total_strands

class pyrosetta.rosetta.core.scoring.TMscore

Bases: pybind11_object

apply(*args, **kwargs)

Overloaded function.

1. apply(self: pyrosetta.rosetta.core.scoring.TMscore, p2: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t) -> None

C++: core::scoring::TMscore::apply(const class ObjexxFCL::FArray2D<double> &) –> void

2. apply(self: pyrosetta.rosetta.core.scoring.TMscore, p2: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, u: pyrosetta.rosetta.utility.vector0_numeric_xyzVector_double_t, t: pyrosetta.rosetta.numeric.xyzVector_double_t, get_ut: bool) -> None

C++: core::scoring::TMscore::apply(const class ObjexxFCL::FArray2D<double> &, class utility::vector0<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, class numeric::xyzVector<double> &, const bool) –> void

get_GDTHA(self: pyrosetta.rosetta.core.scoring.TMscore) → float

C++: core::scoring::TMscore::get_GDTHA() const –> double

get_GDTTS(self: pyrosetta.rosetta.core.scoring.TMscore) → float

C++: core::scoring::TMscore::get_GDTTS() const –> double

get_TMscore(self: pyrosetta.rosetta.core.scoring.TMscore) → float

C++: core::scoring::TMscore::get_TMscore() const –> double

class pyrosetta.rosetta.core.scoring.TMscoreStore

Bases: pybind11_object

property GDTHA

property GDTTS

property TM

property TM10

property TM10_max

property TM_max

property TM_sum

property TM_sum10

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

property maxsub

property maxsub_max

property maxsub_sum

property n_GDT05

property n_GDT05_max

property n_GDT1

property n_GDT1_max

property n_GDT2

property n_GDT2_max

property n_GDT4

property n_GDT4_max

property n_GDT8

property n_GDT8_max

property n_cut

property nseq_

property nseq_ref_

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

Bases: Edge

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

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

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.TenANeighborEdge) → int

C++: core::scoring::TenANeighborEdge::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.TenANeighborEdge) → int

C++: core::scoring::TenANeighborEdge::count_static_memory() const –> unsigned long

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

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

class pyrosetta.rosetta.core.scoring.TenANeighborGraph

Bases: ContextGraph

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 *

all_pairs_shortest_paths(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.ObjexxFCL.FArray2D_int_t

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.TenANeighborGraph, source: pyrosetta.rosetta.core.scoring.TenANeighborGraph) → pyrosetta.rosetta.core.scoring.TenANeighborGraph

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

clone(self: pyrosetta.rosetta.core.scoring.TenANeighborGraph) → pyrosetta.rosetta.core.scoring.ContextGraph

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

conditionally_add_edge(self: pyrosetta.rosetta.core.scoring.TenANeighborGraph, lower_node_id: int, upper_node_id: int, dsq: float) → None

C++: core::scoring::TenANeighborGraph::conditionally_add_edge(unsigned long, unsigned long, double) –> void

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.TenANeighborGraph, edge: pyrosetta.rosetta.utility.graph.Edge) → None

C++: core::scoring::TenANeighborGraph::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 *

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

neighbor_cutoff(self: pyrosetta.rosetta.core.scoring.TenANeighborGraph) → float

C++: core::scoring::TenANeighborGraph::neighbor_cutoff() const –> double

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(std::ostream &) 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(std::ostream &) 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_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

update_from_pose(self: pyrosetta.rosetta.core.scoring.TenANeighborGraph, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::TenANeighborGraph::update_from_pose(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.core.scoring.TenANeighborNode

Bases: Node

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_neighbors_mass(self: pyrosetta.rosetta.core.scoring.TenANeighborNode, neighbors_mass: float) → None

To be called by TenANeighborEdge only

called at the time of edge addition

C++: core::scoring::TenANeighborNode::add_neighbors_mass(double) –> 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.TenANeighborNode, source: pyrosetta.rosetta.utility.graph.Node) → None

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

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.TenANeighborNode) → int

C++: core::scoring::TenANeighborNode::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.TenANeighborNode) → int

C++: core::scoring::TenANeighborNode::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

neighbor_mass(*args, **kwargs)

Overloaded function.

1. neighbor_mass(self: pyrosetta.rosetta.core.scoring.TenANeighborNode, mass: float) -> None

set the neighbor mass for a vertex

C++: core::scoring::TenANeighborNode::neighbor_mass(double) –> void

2. neighbor_mass(self: pyrosetta.rosetta.core.scoring.TenANeighborNode) -> float

return the neighbor mass for a vertex

C++: core::scoring::TenANeighborNode::neighbor_mass() const –> double

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.utility.graph.Node) → None

send summaray data about this node to the screen

C++: utility::graph::Node::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

subtract_neighbors_mass(self: pyrosetta.rosetta.core.scoring.TenANeighborNode, neighbors_mass: float) → None

To be called by TenANeighborEdge only

called at the time of edge deletion

C++: core::scoring::TenANeighborNode::subtract_neighbors_mass(double) –> void

sum_of_neighbors_masses(self: pyrosetta.rosetta.core.scoring.TenANeighborNode) → float

C++: core::scoring::TenANeighborNode::sum_of_neighbors_masses() const –> double

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

Bases: pybind11_object

property atm

property delta

property k

property n

class pyrosetta.rosetta.core.scoring.TwelveANeighborEdge

Bases: Edge

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

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

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.TwelveANeighborEdge) → int

C++: core::scoring::TwelveANeighborEdge::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.TwelveANeighborEdge) → int

C++: core::scoring::TwelveANeighborEdge::count_static_memory() const –> unsigned long

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

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

class pyrosetta.rosetta.core.scoring.TwelveANeighborGraph

Bases: ContextGraph

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 *

all_pairs_shortest_paths(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.ObjexxFCL.FArray2D_int_t

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.TwelveANeighborGraph, source: pyrosetta.rosetta.core.scoring.TwelveANeighborGraph) → pyrosetta.rosetta.core.scoring.TwelveANeighborGraph

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

clone(self: pyrosetta.rosetta.core.scoring.TwelveANeighborGraph) → pyrosetta.rosetta.core.scoring.ContextGraph

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

conditionally_add_edge(self: pyrosetta.rosetta.core.scoring.TwelveANeighborGraph, lower_node_id: int, upper_node_id: int, dsq: float) → None

C++: core::scoring::TwelveANeighborGraph::conditionally_add_edge(unsigned long, unsigned long, double) –> void

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.TwelveANeighborGraph, edge: pyrosetta.rosetta.utility.graph.Edge) → None

C++: core::scoring::TwelveANeighborGraph::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 *

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

neighbor_cutoff(self: pyrosetta.rosetta.core.scoring.TwelveANeighborGraph) → float

C++: core::scoring::TwelveANeighborGraph::neighbor_cutoff() const –> double

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(std::ostream &) 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(std::ostream &) 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_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

update_from_pose(self: pyrosetta.rosetta.core.scoring.TwelveANeighborGraph, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::TwelveANeighborGraph::update_from_pose(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.core.scoring.TwelveANeighborNode

Bases: Node

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.TwelveANeighborNode, source: pyrosetta.rosetta.utility.graph.Node) → None

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

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.TwelveANeighborNode) → int

C++: core::scoring::TwelveANeighborNode::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.TwelveANeighborNode) → int

C++: core::scoring::TwelveANeighborNode::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

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.utility.graph.Node) → None

send summaray data about this node to the screen

C++: utility::graph::Node::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.UnfoldedStatePotential

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

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 std::string &, class core::scoring::EMapVector &) const –> void

class pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo

Bases: CacheableData

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_object

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 std::string &, const std::string &, const std::string &) 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: CacheableData

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

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_object

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

This only does heavyatoms, not truly all atoms!

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_incl_hydrogens(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → float

This does heavyatoms and hydrogens.

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

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

Overloaded function.

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

2. all_atom_rmsd_nosuper(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, pose1_residues: pyrosetta.rosetta.utility.vector1_unsigned_long, pose2_residues: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: core::scoring::all_atom_rmsd_nosuper(const class core::pose::Pose &, const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> 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<std::string, class std::allocator<std::string > > &) –> void

pyrosetta.rosetta.core.scoring.are_atomid_vector_maps_enabled(: pyrosetta.rosetta.std.map_core_id_AtomID_utility_vector1_double_std_allocator_double_t_std_allocator_std_pair_const_core_id_AtomID_utility_vector1_double_std_allocator_double_t, : pyrosetta.rosetta.std.map_std_pair_core_id_AtomID_core_id_AtomID_t_utility_vector1_double_std_allocator_double_t_std_less_std_pair_core_id_AtomID_core_id_AtomID_t_std_allocator_std_pair_const_std_pair_core_id_AtomID_core_id_AtomID_utility_vector1_double_std_allocator_double_t) → bool

Conceit to make the nested types bound in PYROSETTA

Always returns true.

C++: core::scoring::are_atomid_vector_maps_enabled(class std::map<class core::id::AtomID, class utility::vector1<double, class std::allocator<double> >, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class utility::vector1<double, class std::allocator<double> > > > >, class std::map<struct std::pair<class core::id::AtomID, class core::id::AtomID>, class utility::vector1<double, class std::allocator<double> >, struct std::less<struct std::pair<class core::id::AtomID, class core::id::AtomID> >, class std::allocator<struct std::pair<const struct std::pair<class core::id::AtomID, class core::id::AtomID>, class utility::vector1<double, class std::allocator<double> > > > >) –> bool

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

Overloaded function.

1. attributes_for_get_score_function_name(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None

Appends the attributes read by get_score_function_name

C++: core::scoring::attributes_for_get_score_function_name(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

2. attributes_for_get_score_function_name(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, option_name: str) -> None

Appends the attributes read by get_score_function_name w/ name argument

C++: core::scoring::attributes_for_get_score_function_name(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> void

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

Overloaded function.

1. attributes_for_get_score_function_name_w_description(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str) -> None

Appends the attributes read by get_score_function_name

C++: core::scoring::attributes_for_get_score_function_name_w_description(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> void

2. attributes_for_get_score_function_name_w_description(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, option_name: str, description: str) -> None

Appends the attributes read by get_score_function_name w/ name argument

C++: core::scoring::attributes_for_get_score_function_name_w_description(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &, const std::string &) –> void

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

Overloaded function.

1. attributes_for_parse_score_function(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None

Appends the attributes read by parse_score_function

C++: core::scoring::attributes_for_parse_score_function(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

2. attributes_for_parse_score_function(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, sfxn_option_name: str) -> None

Appends the attributes read by parse_score_function w/ name argument

C++: core::scoring::attributes_for_parse_score_function(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> void

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

Overloaded function.

1. attributes_for_parse_score_function_w_description(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str) -> None

Appends the attributes read by parse_score_function with description

C++: core::scoring::attributes_for_parse_score_function_w_description(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> void

2. attributes_for_parse_score_function_w_description(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, sfxn_option_name: str, description: str) -> None

Appends the attributes read by parse_score_function w/ name argument and description

C++: core::scoring::attributes_for_parse_score_function_w_description(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &, const std::string &) –> void

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

Overloaded function.

1. attributes_for_parse_score_function_w_description_when_required(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, sfxn_option_name: str) -> None

2. attributes_for_parse_score_function_w_description_when_required(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, sfxn_option_name: str, description: str) -> None

Appends the attributes read by parse_score_function w/ name argument and description.

This version appends the attributes as required attributes.

Vikram K. Mulligan.

C++: core::scoring::attributes_for_parse_score_function_w_description_when_required(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &, const std::string &) –> 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.basename_for_score_function(sfxn_name: str) → str

returns family name for a specific score function.

For example, ref2015_cart returns ref2015 and beta_nov16_cst returns beta_nov16 Returns an empty string if no match is found

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

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)

Protein-specific.

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

pyrosetta.rosetta.core.scoring.bin_from_bond(bn: pyrosetta.rosetta.core.chemical.BondName, br: pyrosetta.rosetta.core.chemical.BondRingness) → int

convert a bond type to a bin index

C++: core::scoring::bin_from_bond(enum core::chemical::BondName, enum core::chemical::BondRingness) –> unsigned long

pyrosetta.rosetta.core.scoring.bondorders_map(bt: str) → pyrosetta.rosetta.utility.vector1_unsigned_long

helper function to convert string specification of bondorders to indices

C++: core::scoring::bondorders_map(std::string) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

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.check_score_function_sanity(*args, **kwargs)

Overloaded function.

1. check_score_function_sanity(options: pyrosetta.rosetta.utility.options.OptionCollection, scorefxn_key: str) -> bool

2. check_score_function_sanity(options: pyrosetta.rosetta.utility.options.OptionCollection, scorefxn_key: str, throw_exception: bool) -> bool

Check if a score function is requested with incompatible option

flags Will return true if scorefunction is “sane” and false if not. If throw_exception is true, will raise an exception instead of returning false.

C++: core::scoring::check_score_function_sanity(const class utility::options::OptionCollection &, const std::string &, bool) –> bool

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_and_store_atom_tree_minimization_graph(sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_map: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::create_and_store_atom_tree_minimization_graph(const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &) –> void

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_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.deep_copy(source: core::scoring::ScoreFunction) → core::scoring::ScoreFunction

C++: core::scoring::deep_copy(const class core::scoring::ScoreFunction &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

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(const std::string &, const std::string &) –> 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() → pyrosetta.rosetta.ObjexxFCL.FArray2D_int_t

C++: core::scoring::get_angles() –> const class ObjexxFCL::FArray2D<int> &

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

Overloaded function.

1. get_atomistic_energies(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, types: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) -> pyrosetta.rosetta.std.map_core_id_AtomID_utility_vector1_double_std_allocator_double_t_std_allocator_std_pair_const_core_id_AtomID_utility_vector1_double_std_allocator_double_t

2. get_atomistic_energies(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, types: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType, subset: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.std.map_core_id_AtomID_utility_vector1_double_std_allocator_double_t_std_allocator_std_pair_const_core_id_AtomID_utility_vector1_double_std_allocator_double_t

Get the per-atom contributions to the energy.

This differs from get_single_atom_energies() in that it also considers the atoms’ contributions to pairwise energies. The output vector will be ordered by the types in the passed ScoreTypes If subset is passed, only atoms in residues from the subset will be considered

Pose will be rescored with the scorefunction (hence it being non-const) Not all energies are atomistic

C++: core::scoring::get_atomistic_energies(class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &, class std::shared_ptr<class utility::vector1<bool, class std::allocator<bool> > >) –> class std::map<class core::id::AtomID, class utility::vector1<double, class std::allocator<double> >, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class utility::vector1<double, class std::allocator<double> > > > >

pyrosetta.rosetta.core.scoring.get_current_default_score_function_name() → str

C++: core::scoring::get_current_default_score_function_name() –> std::string

pyrosetta.rosetta.core.scoring.get_masks() → pyrosetta.rosetta.ObjexxFCL.FArray2D_ObjexxFCL_ubyte_t

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_pairwise_atom_energies(*args, **kwargs)

Overloaded function.

1. get_pairwise_atom_energies(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, types: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) -> pyrosetta.rosetta.std.map_std_pair_core_id_AtomID_core_id_AtomID_t_utility_vector1_double_std_allocator_double_t_std_less_std_pair_core_id_AtomID_core_id_AtomID_t_std_allocator_std_pair_const_std_pair_core_id_AtomID_core_id_AtomID_utility_vector1_double_std_allocator_double_t

2. get_pairwise_atom_energies(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, types: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType, subset1: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.std.map_std_pair_core_id_AtomID_core_id_AtomID_t_utility_vector1_double_std_allocator_double_t_std_less_std_pair_core_id_AtomID_core_id_AtomID_t_std_allocator_std_pair_const_std_pair_core_id_AtomID_core_id_AtomID_utility_vector1_double_std_allocator_double_t

3. get_pairwise_atom_energies(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, types: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType, subset1: pyrosetta.rosetta.utility.vector1_bool, subset2: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.std.map_std_pair_core_id_AtomID_core_id_AtomID_t_utility_vector1_double_std_allocator_double_t_std_less_std_pair_core_id_AtomID_core_id_AtomID_t_std_allocator_std_pair_const_std_pair_core_id_AtomID_core_id_AtomID_utility_vector1_double_std_allocator_double_t

Get the pairwise energies for a set of atoms.

Only atom pairs with non-zero energies will be present in the returned map. The output vector will be ordered by the types in the passed ScoreTypes If both subsets are passed, only pairwise interactions between atoms in residues across the two sets will be considered If just subset1 is passed, only pairwise interactions which involve at least one atom in a residue in the set will be considered If neither is passed, all pairwise interactions will be considered.

Pose will be rescored with the scorefunction (hence it being non-const) Not all energies are atomistic

C++: core::scoring::get_pairwise_atom_energies(class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &, class std::shared_ptr<class utility::vector1<bool, class std::allocator<bool> > >, class std::shared_ptr<class utility::vector1<bool, class std::allocator<bool> > >) –> class std::map<struct std::pair<class core::id::AtomID, class core::id::AtomID>, class utility::vector1<double, class std::allocator<double> >, struct std::less<struct std::pair<class core::id::AtomID, class core::id::AtomID> >, class std::allocator<struct std::pair<const struct std::pair<class core::id::AtomID, class core::id::AtomID>, class utility::vector1<double, class std::allocator<double> > > > >

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

Overloaded function.

1. get_parameter_hash(bondtypr: int, type1: int, type2: int) -> int

2. get_parameter_hash(bondtypr: int, type1: int, type2: int, type3: int) -> int

3. get_parameter_hash(bondtypr: int, type1: int, type2: int, type3: int, type4: int) -> int

compress 5 values into one unsigned int; use 12 bits for each

C++: core::scoring::get_parameter_hash(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) –> unsigned long

pyrosetta.rosetta.core.scoring.get_rmsd_type_name_map() → pyrosetta.rosetta.std.map_std_string_core_scoring_rmsd_atoms

Setup a name mapping for rmsd_atoms

C++: core::scoring::get_rmsd_type_name_map() –> class std::map<std::string, enum core::scoring::rmsd_atoms, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, enum core::scoring::rmsd_atoms> > >

pyrosetta.rosetta.core.scoring.get_rmsd_type_names() → pyrosetta.rosetta.utility.vector1_std_string

Setup a name mapping for rmsd_atoms

C++: core::scoring::get_rmsd_type_names() –> class utility::vector1<std::string, class std::allocator<std::string > >

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(pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.ScoreFunction

4. get_score_function(pose: pyrosetta.rosetta.core.pose.Pose, is_fullatom: bool) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Get a ScoreFunction from cmd-line settings and dependant on the symmetrical state of the pose.

C++: core::scoring::get_score_function(const class core::pose::Pose &, const bool) –> class std::shared_ptr<class core::scoring::ScoreFunction>

5. get_score_function(pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.core.scoring.ScoreFunction

6. get_score_function(pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection, is_fullatom: bool) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Get a ScoreFunction from cmd-line settings and dependant on the symmetrical state of the pose.

Local Options collection.

C++: core::scoring::get_score_function(const class core::pose::Pose &, const class utility::options::OptionCollection &, const bool) –> class std::shared_ptr<class core::scoring::ScoreFunction>

7. get_score_function(options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.core.scoring.ScoreFunction

8. 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(const std::string &, const std::string &) –> 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 &, const std::string &, const std::string &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

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

Overloaded function.

1. get_score_function_name(tag: pyrosetta.rosetta.utility.tag.Tag, option_name: str) -> str

Look up the name of assigned score function to the given option. Use this to prevent hard coding default score functions into protocols.

C++: core::scoring::get_score_function_name(class std::shared_ptr<const class utility::tag::Tag>, const std::string &) –> std::string

2. get_score_function_name(tag: pyrosetta.rosetta.utility.tag.Tag) -> str

Look up the name of assigned score function to the ‘scorefxn=’ option. Use this to prevent hard coding default score functions into protocols.

C++: core::scoring::get_score_function_name(class std::shared_ptr<const class utility::tag::Tag>) –> std::string

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

Overloaded function.

1. get_single_atom_energies(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, types: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) -> pyrosetta.rosetta.std.map_core_id_AtomID_utility_vector1_double_std_allocator_double_t_std_allocator_std_pair_const_core_id_AtomID_utility_vector1_double_std_allocator_double_t

2. get_single_atom_energies(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, types: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType, subset: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.std.map_core_id_AtomID_utility_vector1_double_std_allocator_double_t_std_allocator_std_pair_const_core_id_AtomID_utility_vector1_double_std_allocator_double_t

Get the (pseudo-one-body) energies for a set of atoms.

Only atoms with non-zero energies will be present in the returned map. The output vector will be ordered by the types in the passed ScoreTypes If subset is passed, only atoms in residues from the subset will be considered

Pose will be rescored with the scorefunction (hence it being non-const) Not all energies are atomistic

C++: core::scoring::get_single_atom_energies(class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &, class std::shared_ptr<class utility::vector1<bool, class std::allocator<bool> > >) –> class std::map<class core::id::AtomID, class utility::vector1<double, class std::allocator<double> >, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class utility::vector1<double, class std::allocator<double> > > > >

pyrosetta.rosetta.core.scoring.input_sasa_dats() → None

C++: core::scoring::input_sasa_dats() –> void

pyrosetta.rosetta.core.scoring.interpolate_value_and_deriv(potential: pyrosetta.rosetta.ObjexxFCL.FArray1D_double_t, 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_any_atom(: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, : int, : int) → bool

Returns true always.

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

pyrosetta.rosetta.core.scoring.is_carbohydrate_ring_atom(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

Return true is the pose residue and atom specified

is a non-virtual, heavy ring atom of a carbohydrate

Morgan Nance <morganlnance.com>

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

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

class pyrosetta.rosetta.core.scoring.lDDT_Calculator

Bases: pybind11_object

Calculate the lDDT between the reference and the model. https://dx.doi.org/10.1093/bioinformatics/btt473 Uses the same defaults as https://swissmodel.expasy.org/lddt/ Not implemented is any consideration for stereochemical/bond/angle deviation penalties

R0(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, val: float) → None

The inclusion radius: the cutoff to determine which distances are “local”

C++: core::scoring::lDDT_Calculator::R0(double) –> void

all_lDDT(*args, **kwargs)

Overloaded function.

1. all_lDDT(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose, residue_lddt: pyrosetta.rosetta.std.map_unsigned_long_double, atom_lddt: pyrosetta.rosetta.std.map_core_id_AtomID_double) -> float

Get all lDDT statistics (global, residue and atom)

Assumes reference and model are the same length and match 1:1 The residue/atom IDs for the returned values are based on the reference structure.

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

2. all_lDDT(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose, res_map: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long, residue_lddt: pyrosetta.rosetta.std.map_unsigned_long_double, atom_lddt: pyrosetta.rosetta.std.map_core_id_AtomID_double) -> float

Get all lDDT statistics (global, residue and atom)

Only reference residues in res_map are considered for pairings. To include residues but set them unmatched, map them to zero. The residue/atom IDs for the returned values are based on the reference structure.

C++: core::scoring::lDDT_Calculator::all_lDDT(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> > > &, class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &, class std::map<class core::id::AtomID, double, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, double> > > &) const –> double

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

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

atom_lDDT(*args, **kwargs)

Overloaded function.

1. atom_lDDT(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.std.map_core_id_AtomID_double

Get the atom lDDTs for all atoms in the poses

Assumes reference and model are the same length and match 1:1 The atom IDs for the returned value are based on the reference structure.

C++: core::scoring::lDDT_Calculator::atom_lDDT(const class core::pose::Pose &, const class core::pose::Pose &) const –> class std::map<class core::id::AtomID, double, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, double> > >

2. atom_lDDT(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose, res_map: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long, atom_lddt: pyrosetta.rosetta.std.map_core_id_AtomID_double) -> None

Get the atom lDDTs, for the residue pairings specified in res_map.

Only reference residues in res_map are considered for pairings. To include residues but set them unmatched, map them to zero. The atom IDs for the returned atom_lddt value are based on the reference structure.

C++: core::scoring::lDDT_Calculator::atom_lDDT(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> > > &, class std::map<class core::id::AtomID, double, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, double> > > &) const –> void

consider_alt_states(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, setting: bool) → None

When doing the calculation, use exact matching of atoms (false),

Or consider chemically-equivaleint (automorphic) states to get the best value. Turning this off will speed calculations where alternate states aren’t relevant (e.g. Calpha or backbone-only)

C++: core::scoring::lDDT_Calculator::consider_alt_states(bool) –> void

ignore_oxt(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, setting: bool) → None

The default is to ignore any interactions with the OXT atom.

C++: core::scoring::lDDT_Calculator::ignore_oxt(bool) –> void

predicate(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, predicate: pyrosetta.rosetta.core.scoring.Predicate) → None

Set the predicate for which atoms to consider

The default is all heavy atoms. Note the default of considering alternate chemical states is (currently) incompatible with including hydrogen atoms, so it is recommended to turn that off with any predicate which includes (potentially equivalent) hydrogens.

C++: core::scoring::lDDT_Calculator::predicate(class std::shared_ptr<const class core::scoring::Predicate>) –> void

residue_lDDT(*args, **kwargs)

Overloaded function.

1. residue_lDDT(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_double

Get the residue lDDTs, for all atoms in the pose

Assumes reference and model are the same length and match 1:1

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

2. residue_lDDT(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose, res_map: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long, residue_lddt: pyrosetta.rosetta.std.map_unsigned_long_double) -> None

Get the residue lDDTs, for the pairing specified in res_map.

Only reference residues in res_map are considered for pairings. To include residues but set them unmatched, map them to zero. The indicies for the returned residue_lddt are based on the reference structure.

C++: core::scoring::lDDT_Calculator::residue_lDDT(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> > > &, class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &) const –> void

seqsep(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, ss: int) → None

Only consider pairs if the polymeric sequence separation is seqsep or greater

(different chains are infinite) This is different (one more) from the reference, to allow 0 to include distances within the same residue

C++: core::scoring::lDDT_Calculator::seqsep(unsigned long) –> void

thresholds(self: pyrosetta.rosetta.core.scoring.lDDT_Calculator, setting: pyrosetta.rosetta.utility.vector1_double) → None

The distance similarity threasholds to use.

The reported value will be an average of the lDDT for each individual threshold.

C++: core::scoring::lDDT_Calculator::thresholds(const class utility::vector1<double, class std::allocator<double> > &) –> void

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

Overloaded function.

1. lddt(ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose) -> float

2. lddt(ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose, consider_alt: bool) -> float

Calculate the lDDT between two structures (1:1 residue correspondence)

across all heavy atoms. If consider_alt is false, use the quicker algorithm which doesn’t consider automorphic changes (e.g. PHE ring flips)

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

pyrosetta.rosetta.core.scoring.list_read_options_in_get_score_function(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

A documentation function which reports the set of options read by get_score_function.

C++: core::scoring::list_read_options_in_get_score_function(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

pyrosetta.rosetta.core.scoring.list_read_options_in_get_score_function_legacy(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

A documentation function which reports the set of options read by get_score_function_legacy.

C++: core::scoring::list_read_options_in_get_score_function_legacy(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

class pyrosetta.rosetta.core.scoring.min_pair_data

Bases: pybind11_object

Members:

etab_pair_nblist

etab_classic_intrares_pair_nblist

lkball_nblist

lkdome_nblist

cst_respair_data

elec_pair_nblist

rna_elec_pair_nblist

geom_solv_pair_nblist

fa_stack_pair_nblist

lk_PolarNonPolar_pair_nblist

fa_dslf_respair_data

fa_custom_pair_dist_data

lkb_respair_data

lkd_respair_data

vdw_respair_data

mp_respair_data

mg_pair_nblist

hbond_respair_data

n_min_pair_data

cst_respair_data = <min_pair_data.cst_respair_data: 5>

elec_pair_nblist = <min_pair_data.elec_pair_nblist: 6>

etab_classic_intrares_pair_nblist = <min_pair_data.etab_classic_intrares_pair_nblist: 2>

etab_pair_nblist = <min_pair_data.etab_pair_nblist: 1>

fa_custom_pair_dist_data = <min_pair_data.fa_custom_pair_dist_data: 12>

fa_dslf_respair_data = <min_pair_data.fa_dslf_respair_data: 11>

fa_stack_pair_nblist = <min_pair_data.fa_stack_pair_nblist: 9>

geom_solv_pair_nblist = <min_pair_data.geom_solv_pair_nblist: 8>

hbond_respair_data = <min_pair_data.hbond_respair_data: 18>

lk_PolarNonPolar_pair_nblist = <min_pair_data.lk_PolarNonPolar_pair_nblist: 10>

lkb_respair_data = <min_pair_data.lkb_respair_data: 13>

lkball_nblist = <min_pair_data.lkball_nblist: 3>

lkd_respair_data = <min_pair_data.lkd_respair_data: 14>

lkdome_nblist = <min_pair_data.lkdome_nblist: 4>

mg_pair_nblist = <min_pair_data.mg_pair_nblist: 17>

mp_respair_data = <min_pair_data.mp_respair_data: 16>

n_min_pair_data = <min_pair_data.hbond_respair_data: 18>

property name

rna_elec_pair_nblist = <min_pair_data.rna_elec_pair_nblist: 7>

property value

vdw_respair_data = <min_pair_data.vdw_respair_data: 15>

class pyrosetta.rosetta.core.scoring.min_single_data

Bases: pybind11_object

Members:

etab_single_nblist

etab_classic_intrares_single_nblist

mm_lj_intra_nblist

cst_res_data

lkb_res_data

vdw_res_data

mp_res_data

hbond_res_data

n_min_single_data

cst_res_data = <min_single_data.cst_res_data: 4>

etab_classic_intrares_single_nblist = <min_single_data.etab_classic_intrares_single_nblist: 2>

etab_single_nblist = <min_single_data.etab_single_nblist: 1>

hbond_res_data = <min_single_data.hbond_res_data: 8>

lkb_res_data = <min_single_data.lkb_res_data: 5>

mm_lj_intra_nblist = <min_single_data.mm_lj_intra_nblist: 3>

mp_res_data = <min_single_data.mp_res_data: 7>

n_min_single_data = <min_single_data.hbond_res_data: 8>

property name

property value

vdw_res_data = <min_single_data.vdw_res_data: 6>

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: 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.parse_score_function(*args, **kwargs)

Overloaded function.

1. parse_score_function(tag: pyrosetta.rosetta.utility.tag.Tag, option_name: str, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.scoring.ScoreFunction

2. parse_score_function(tag: pyrosetta.rosetta.utility.tag.Tag, option_name: str, data: pyrosetta.rosetta.basic.datacache.DataMap, dflt_key: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Look up the score function defined in the <SCOREFXNS/>

through the given option. Defaults to ‘commandline’.

C++: core::scoring::parse_score_function(class std::shared_ptr<const class utility::tag::Tag>, const std::string &, const class basic::datacache::DataMap &, const std::string &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

3. parse_score_function(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.scoring.ScoreFunction

4. parse_score_function(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, dflt_key: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Look up the score function defined in the <SCOREFXNS/> through the option ‘scorefxn=’. Defaults to ‘commandline’.

C++: core::scoring::parse_score_function(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &, const std::string &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

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

Overloaded function.

1. per_res_lddt(ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_double

2. per_res_lddt(ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose, consider_alt: bool) -> pyrosetta.rosetta.utility.vector1_double

Calculate the per-residue lDDT between two structures (1:1 residue correspondence)

across all heavy atoms. If consider_alt is false, use the quicker algorithm which doesn’t consider automorphic changes (e.g. PHE ring flips)

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

pyrosetta.rosetta.core.scoring.per_res_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, mask: pyrosetta.rosetta.utility.vector1_bool) → pyrosetta.rosetta.std.map_unsigned_long_double

Calculate RMS for each residue in mask, return a map of res to value.

Mask and result corresponds to MOD POSE, not the reference pose!

C++: core::scoring::per_res_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<bool, class std::allocator<bool> > &) –> class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > >

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

Overloaded function.

1. residue_rmsd_nosuper(rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, atom_map: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

2. residue_rmsd_nosuper(rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, atom_map: pyrosetta.rosetta.utility.vector1_unsigned_long, skip_hydro: bool) -> float

Calculate the RMSD between two residues, using the provided atom map.

The atom map is indexed by rsd1 index, and give the corresponding rsd2 index. Use a value of 0 to omit the rsd pairing. Does not superimpose the residues.

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

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

Overloaded function.

1. residue_rmsd_super(rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, atom_map: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

2. residue_rmsd_super(rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, atom_map: pyrosetta.rosetta.utility.vector1_unsigned_long, skip_hydro: bool) -> float

Calculate the RMSD between two residues, using the provided atom map.

The atom map is indexed by rsd1 index, and give the corresponding rsd2 index. Use a value of 0 to omit the rsd pairing. Superimposes the residues (remove rigid-body rotational/translational component of the rmsd.)

C++: core::scoring::residue_rmsd_super(const class core::conformation::Residue &, const class core::conformation::Residue &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, bool) –> 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

class pyrosetta.rosetta.core.scoring.rmsd_atoms

Bases: pybind11_object

Members:

rmsd_protein_bb_heavy

rmsd_protein_bb_heavy_including_O

rmsd_protein_bb_ca

rmsd_sc_heavy

rmsd_sc

rmsd_all_heavy

rmsd_all

rmsd_atom_total

property name

rmsd_all = <rmsd_atoms.rmsd_all: 7>

rmsd_all_heavy = <rmsd_atoms.rmsd_all_heavy: 6>

rmsd_atom_total = <rmsd_atoms.rmsd_all: 7>

rmsd_protein_bb_ca = <rmsd_atoms.rmsd_protein_bb_ca: 3>

rmsd_protein_bb_heavy = <rmsd_atoms.rmsd_protein_bb_heavy: 1>

rmsd_protein_bb_heavy_including_O = <rmsd_atoms.rmsd_protein_bb_heavy_including_O: 2>

rmsd_sc = <rmsd_atoms.rmsd_sc: 5>

rmsd_sc_heavy = <rmsd_atoms.rmsd_sc_heavy: 4>

property value

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 std::string &) –> 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<std::string, class std::allocator<std::string > > &, 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.setup_rmsd_atom_names() → pyrosetta.rosetta.std.map_core_scoring_rmsd_atoms_utility_vector1_std_string_std_allocator_std_string_t_std_allocator_std_pair_const_core_scoring_rmsd_atoms_utility_vector1_std_string_std_allocator_std_string_t

Returns a map of the rmsd_atom enum and a list of atom names for which this

RMSD setting selects for the calculation

C++: core::scoring::setup_rmsd_atom_names() –> class std::map<enum core::scoring::rmsd_atoms, class utility::vector1<std::string, class std::allocator<std::string > >, struct std::less<enum core::scoring::rmsd_atoms>, class std::allocator<struct std::pair<const enum core::scoring::rmsd_atoms, class utility::vector1<std::string, class std::allocator<std::string > > > > >

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_polymer_heavyatoms(*args, **kwargs)

Overloaded function.

1. superimpose_polymer_heavyatoms(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, mainchain_only: bool) -> float

2. superimpose_polymer_heavyatoms(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, mainchain_only: bool, rms_calc_offset_val: float) -> float

3. superimpose_polymer_heavyatoms(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, mainchain_only: bool, rms_calc_offset_val: float, realign: bool) -> float

4. superimpose_polymer_heavyatoms(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, mainchain_only: bool, rms_calc_offset_val: float, realign: bool, throw_on_failure: bool) -> float

Superimpose polymer heavyatoms of mod_pose onto ref_pose, and return

the computed RMSD. If mainchain_only is true, this restricts itself to mainchain heavyatoms; otherwise it does all polymer heavyatoms.

General, for any heteropolymer. Ignores ligands and hydrogen atoms.

Vikram K. Mulligan (vmulligan.org).

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

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

4. 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, throw_on_failure: 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). If throw_on_failure is true, this function throws if the RMSD calculation fails; otherwise it fails silently and returns 0.0 for the RMSD.

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, const bool) –> double

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) -> 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) -> float

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

8. 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, throw_on_failure: 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). If throw_on_failure is true, this function throws if the RMSD calculation fails; otherwise it fails silently and returns 0.0 for the RMSD.

WARNING: This will give you errors if you try to superimpose a non-symmetric pose onto a symmetric one, even with the correct

atom_map. It will not fail, but the superposition will be bad and any subsequent RMSD calculation will be wrong.

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, const bool) –> double

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) -> float

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

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

12. 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, throw_on_failure: 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). If throw_on_failure is true, this function throws if the RMSD calculation fails; otherwise it fails silently and returns 0.0 for the RMSD.

WARNING: this will give you errors if you try to superimpose a non-symmetric pose onto a symmetric one, even with the correct

atom_map. It will not fail, but the superposition will be bad and any subsequent RMSD calculation will be wrong.

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, const bool) –> double

class pyrosetta.rosetta.core.scoring.tableID

Bases: pybind11_object

property aa

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

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

property name1

property name2

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

Overloaded function.

1. xyz_gdtmm(p1a: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, p2a: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, 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: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, p2a: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t) -> 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: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, p2a: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, 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: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, p2a: pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t, natoms: int) → int

C++: core::scoring::xyz_maxsub(class ObjexxFCL::FArray2D<double>, class ObjexxFCL::FArray2D<double>, int) –> int