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>

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

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