sparta¶

Bindings for protocols::sparta namespace

class pyrosetta.rosetta.protocols.sparta.ANN¶

Bases: pybind11_object

property ANN_IN_MTX¶

property ANN_IN_MTX_LEVEL1¶

property ANN_IN_MTX_LEVEL2¶

property ANN_OUT_MTX_LEVEL1¶

property ANN_OUT_MTX_LEVEL2¶

property B2I_1¶

property B2I_2¶

property B2I_3¶

property B2L1_1¶

property B2L1_2¶

property B2L1_3¶

property B2L2_1¶

property B2L2_2¶

property B2L2_3¶

property BI_1¶

property BI_2¶

property BI_3¶

property BL1_1¶

property BL1_2¶

property BL1_3¶

property BL2_1¶

property BL2_2¶

property BL2_3¶

property DB_FNAME_LEVEL1_1¶

property DB_FNAME_LEVEL1_2¶

property DB_FNAME_LEVEL1_3¶

property DB_FNAME_LEVEL2_1¶

property DB_FNAME_LEVEL2_2¶

property DB_FNAME_LEVEL2_3¶

property DB_NAME_PREFIX¶

property DB_PATH¶

property N1_NODE_H¶

property N1_NODE_I¶

property N1_NODE_O¶

property N2_NODE_H¶

property N2_NODE_I¶

property N2_NODE_O¶

property W2I_1¶

property W2I_2¶

property W2I_3¶

property W2L1_1¶

property W2L1_2¶

property W2L1_3¶

property W2L2_1¶

property W2L2_2¶

property W2L2_3¶

property WI_1¶

property WI_2¶

property WI_3¶

property WL1_1¶

property WL1_2¶

property WL1_3¶

property WL2_1¶

property WL2_2¶

property WL2_3¶

applyANNTransformation(self: pyrosetta.rosetta.protocols.sparta.ANN, inp: pyrosetta.rosetta.utility.vector0_float, w: pyrosetta.rosetta.std.map_int_utility_vector0_float_std_allocator_float_t_std_allocator_std_pair_const_int_utility_vector0_float_std_allocator_float_t, b: pyrosetta.rosetta.utility.vector0_float, out: pyrosetta.rosetta.utility.vector0_float, code: int) → None¶: C++: protocols::sparta::ANN::applyANNTransformation(class utility::vector0<float, class std::allocator<float> > &, class std::map<int, class utility::vector0<float, class std::allocator<float> >, struct std::less<int>, class std::allocator<struct std::pair<const int, class utility::vector0<float, class std::allocator<float> > > > > &, class utility::vector0<float, class std::allocator<float> > &, class utility::vector0<float, class std::allocator<float> > &, int) –> void

applyVecAverage(self: pyrosetta.rosetta.protocols.sparta.ANN, v1: pyrosetta.rosetta.utility.vector0_float, v2: pyrosetta.rosetta.utility.vector0_float, v3: pyrosetta.rosetta.utility.vector0_float, vout: pyrosetta.rosetta.utility.vector0_float) → None¶: C++: protocols::sparta::ANN::applyVecAverage(class utility::vector0<float, class std::allocator<float> > &, class utility::vector0<float, class std::allocator<float> > &, class utility::vector0<float, class std::allocator<float> > &, class utility::vector0<float, class std::allocator<float> > &) –> void

applyVecNormalization(self: pyrosetta.rosetta.protocols.sparta.ANN, v: pyrosetta.rosetta.utility.vector0_float) → None¶: C++: protocols::sparta::ANN::applyVecNormalization(class utility::vector0<float, class std::allocator<float> > &) –> void

assign(self: pyrosetta.rosetta.protocols.sparta.ANN, : pyrosetta.rosetta.protocols.sparta.ANN) → pyrosetta.rosetta.protocols.sparta.ANN¶: C++: protocols::sparta::ANN::operator=(const class protocols::sparta::ANN &) –> class protocols::sparta::ANN &

calcLevel1(self: pyrosetta.rosetta.protocols.sparta.ANN) → None¶: C++: protocols::sparta::ANN::calcLevel1() –> void

calcLevel2(self: pyrosetta.rosetta.protocols.sparta.ANN) → None¶: C++: protocols::sparta::ANN::calcLevel2() –> void

ftoa(*args, **kwargs)¶

Overloaded function.

ftoa(self: pyrosetta.rosetta.protocols.sparta.ANN, n: float, buff: str, s: int) -> str
ftoa(self: pyrosetta.rosetta.protocols.sparta.ANN, n: float, buff: str, s: int, f: str) -> str
ftoa(self: pyrosetta.rosetta.protocols.sparta.ANN, n: float, buff: str, s: int, f: str, prec: int) -> str

C++: protocols::sparta::ANN::ftoa(float, char *, unsigned long, char, int) –> char *

getConfidence(self: pyrosetta.rosetta.protocols.sparta.ANN, v: pyrosetta.rosetta.utility.vector0_float) → float¶: C++: protocols::sparta::ANN::getConfidence(class utility::vector0<float, class std::allocator<float> > &) –> float

getNumberMissCS(self: pyrosetta.rosetta.protocols.sparta.ANN, v: pyrosetta.rosetta.utility.vector0_float) → int¶: C++: protocols::sparta::ANN::getNumberMissCS(class utility::vector0<float, class std::allocator<float> > &) –> int

getSlashChar(self: pyrosetta.rosetta.protocols.sparta.ANN) → None¶: C++: protocols::sparta::ANN::getSlashChar() –> void

init(self: pyrosetta.rosetta.protocols.sparta.ANN, N1_nodeI: int, N1_nodeH: int, N1_nodeO: int, N2_nodeI: int, N2_nodeH: int, N2_nodeO: int, dPATH: str, dNAME_PREFIX: str) → None¶: C++: protocols::sparta::ANN::init(int, int, int, int, int, int, const std::string &, const std::string &) –> void

property input_code¶

itoa(*args, **kwargs)¶

Overloaded function.

itoa(self: pyrosetta.rosetta.protocols.sparta.ANN, n: int, buff: str, s: int) -> str
itoa(self: pyrosetta.rosetta.protocols.sparta.ANN, n: int, buff: str, s: int, base: int) -> str

C++: protocols::sparta::ANN::itoa(int, char *, unsigned long, int) –> char *

loadWeightBias3(self: pyrosetta.rosetta.protocols.sparta.ANN, fName: str, W1: pyrosetta.rosetta.std.map_int_utility_vector0_float_std_allocator_float_t_std_allocator_std_pair_const_int_utility_vector0_float_std_allocator_float_t, B1: pyrosetta.rosetta.utility.vector0_float, W2: pyrosetta.rosetta.std.map_int_utility_vector0_float_std_allocator_float_t_std_allocator_std_pair_const_int_utility_vector0_float_std_allocator_float_t, B2: pyrosetta.rosetta.utility.vector0_float, W3: pyrosetta.rosetta.std.map_int_utility_vector0_float_std_allocator_float_t_std_allocator_std_pair_const_int_utility_vector0_float_std_allocator_float_t, B3: pyrosetta.rosetta.utility.vector0_float, N_W_row: int, N_W_col: int, N_B: int) → None¶: C++: protocols::sparta::ANN::loadWeightBias3(const std::string &, class std::map<int, class utility::vector0<float, class std::allocator<float> >, struct std::less<int>, class std::allocator<struct std::pair<const int, class utility::vector0<float, class std::allocator<float> > > > > &, class utility::vector0<float, class std::allocator<float> > &, class std::map<int, class utility::vector0<float, class std::allocator<float> >, struct std::less<int>, class std::allocator<struct std::pair<const int, class utility::vector0<float, class std::allocator<float> > > > > &, class utility::vector0<float, class std::allocator<float> > &, class std::map<int, class utility::vector0<float, class std::allocator<float> >, struct std::less<int>, class std::allocator<struct std::pair<const int, class utility::vector0<float, class std::allocator<float> > > > > &, class utility::vector0<float, class std::allocator<float> > &, int, int, int) –> void

loadWeights(self: pyrosetta.rosetta.protocols.sparta.ANN) → None¶: C++: protocols::sparta::ANN::loadWeights() –> void

runSpartaANN(self: pyrosetta.rosetta.protocols.sparta.ANN, inMatrix: pyrosetta.rosetta.std.map_int_utility_vector0_float_std_allocator_float_t_std_allocator_std_pair_const_int_utility_vector0_float_std_allocator_float_t) → None¶: C++: protocols::sparta::ANN::runSpartaANN(class std::map<int, class utility::vector0<float, class std::allocator<float> >, struct std::less<int>, class std::allocator<struct std::pair<const int, class utility::vector0<float, class std::allocator<float> > > > > &) –> void

set_input_code(self: pyrosetta.rosetta.protocols.sparta.ANN, c: int) → None¶: C++: protocols::sparta::ANN::set_input_code(int) –> void

property slash_char¶

class pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluator¶

Bases: SingleValuePoseEvaluator_double_t

applicable(self: pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluator, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::sparta::ChemicalShiftEvaluator::applicable(const class core::pose::Pose &) const –> bool

apply(self: pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluator, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::sparta::ChemicalShiftEvaluator::apply(class core::pose::Pose &) const –> double

assign(self: pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluator, : pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluator) → pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluator¶: C++: protocols::sparta::ChemicalShiftEvaluator::operator=(const class protocols::sparta::ChemicalShiftEvaluator &) –> class protocols::sparta::ChemicalShiftEvaluator &

name(*args, **kwargs)¶

Overloaded function.

name(self: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t, : int) -> str

C++: protocols::evaluation::SingleValuePoseEvaluator<double>::name(unsigned long) const –> std::string

name(self: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t, : int) -> str

C++: protocols::evaluation::PoseEvaluator::name(unsigned long) const –> std::string

size(*args, **kwargs)¶

Overloaded function.

size(self: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t) -> int

C++: protocols::evaluation::SingleValuePoseEvaluator<double>::size() const –> unsigned long

size(self: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t) -> int

C++: protocols::evaluation::PoseEvaluator::size() const –> unsigned long

class pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator¶

Bases: EvaluatorCreator

creator for the ChemicalShiftsEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None¶: C++: protocols::sparta::ChemicalShiftEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator, : pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator) → pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator¶: C++: protocols::sparta::ChemicalShiftEvaluatorCreator::operator=(const class protocols::sparta::ChemicalShiftEvaluatorCreator &) –> class protocols::sparta::ChemicalShiftEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator) → None¶: C++: protocols::sparta::ChemicalShiftEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator) → str¶: C++: protocols::sparta::ChemicalShiftEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.sparta.GDB¶

Bases: pybind11_object

property DATA¶

property EMPTY¶

property Entries¶

property FORMAT¶

property FORMAT_str¶

FORMAT_str_parser(self: pyrosetta.rosetta.protocols.sparta.GDB, str: str) → None¶: C++: protocols::sparta::GDB::FORMAT_str_parser(const std::string &) –> void

property GDBfileName¶

property REMARKS¶

property VARS¶

property VARS_str¶

VARS_str_parser(self: pyrosetta.rosetta.protocols.sparta.GDB, str: str) → None¶: C++: protocols::sparta::GDB::VARS_str_parser(const std::string &) –> void

property VarsNumber¶

addEntry(self: pyrosetta.rosetta.protocols.sparta.GDB, VarName: str, VarVal: str) → None¶: C++: protocols::sparta::GDB::addEntry(const std::string &, const std::string &) –> void

addRemark(self: pyrosetta.rosetta.protocols.sparta.GDB, str: str) → None¶: C++: protocols::sparta::GDB::addRemark(const std::string &) –> void

addVAR(self: pyrosetta.rosetta.protocols.sparta.GDB, VAR_Name: str, FORMAT_Name: str) → None¶: C++: protocols::sparta::GDB::addVAR(const std::string &, const std::string &) –> void

assign(self: pyrosetta.rosetta.protocols.sparta.GDB, : pyrosetta.rosetta.protocols.sparta.GDB) → pyrosetta.rosetta.protocols.sparta.GDB¶: C++: protocols::sparta::GDB::operator=(const class protocols::sparta::GDB &) –> class protocols::sparta::GDB &

checkFormat(self: pyrosetta.rosetta.protocols.sparta.GDB, f: str) → bool¶: C++: protocols::sparta::GDB::checkFormat(const std::string &) –> bool

property firstResID¶

getData(self: pyrosetta.rosetta.protocols.sparta.GDB, DataName: str) → str¶: C++: protocols::sparta::GDB::getData(const std::string &) –> std::string

getEntryCount(self: pyrosetta.rosetta.protocols.sparta.GDB) → int¶: C++: protocols::sparta::GDB::getEntryCount() –> int

getResidName(self: pyrosetta.rosetta.protocols.sparta.GDB, rNum: int) → str¶: C++: protocols::sparta::GDB::getResidName(int) –> std::string

isVarFloat(*args, **kwargs)¶

Overloaded function.

isVarFloat(self: pyrosetta.rosetta.protocols.sparta.GDB, index: int) -> bool

C++: protocols::sparta::GDB::isVarFloat(int) –> bool

isVarFloat(self: pyrosetta.rosetta.protocols.sparta.GDB, VarName: str) -> bool

C++: protocols::sparta::GDB::isVarFloat(const std::string &) –> bool

isVarInt(*args, **kwargs)¶

Overloaded function.

isVarInt(self: pyrosetta.rosetta.protocols.sparta.GDB, index: int) -> bool

C++: protocols::sparta::GDB::isVarInt(int) –> bool

isVarInt(self: pyrosetta.rosetta.protocols.sparta.GDB, VarName: str) -> bool

C++: protocols::sparta::GDB::isVarInt(const std::string &) –> bool

isVarString(*args, **kwargs)¶

Overloaded function.

isVarString(self: pyrosetta.rosetta.protocols.sparta.GDB, index: int) -> bool

C++: protocols::sparta::GDB::isVarString(int) –> bool

isVarString(self: pyrosetta.rosetta.protocols.sparta.GDB, VarName: str) -> bool

C++: protocols::sparta::GDB::isVarString(const std::string &) –> bool

loadGDB(self: pyrosetta.rosetta.protocols.sparta.GDB, fileName: str) → None¶: C++: protocols::sparta::GDB::loadGDB(const std::string &) –> void

presetClass(self: pyrosetta.rosetta.protocols.sparta.GDB, ClassName: str) → None¶: C++: protocols::sparta::GDB::presetClass(const std::string &) –> void

property residList¶

saveGDB(self: pyrosetta.rosetta.protocols.sparta.GDB, fileName: str) → None¶: C++: protocols::sparta::GDB::saveGDB(const std::string &) –> void

setData(self: pyrosetta.rosetta.protocols.sparta.GDB, DataName: str, DataVal: str) → None¶: C++: protocols::sparta::GDB::setData(const std::string &, const std::string &) –> void

setEntry(self: pyrosetta.rosetta.protocols.sparta.GDB, index: int, VarName: str, VarVal: str) → None¶: C++: protocols::sparta::GDB::setEntry(int, const std::string &, const std::string &) –> void

setVAR(self: pyrosetta.rosetta.protocols.sparta.GDB, index: int, VAR_Name: str, FORMAT_Name: str) → None¶: C++: protocols::sparta::GDB::setVAR(int, const std::string &, const std::string &) –> void

set_plaintext(self: pyrosetta.rosetta.protocols.sparta.GDB) → None¶: C++: protocols::sparta::GDB::set_plaintext() –> void

showGDB(self: pyrosetta.rosetta.protocols.sparta.GDB, os: pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::sparta::GDB::showGDB(std::ostream &) –> void

pyrosetta.rosetta.protocols.sparta.MKDIR(dirName: str) → int¶: C++: protocols::sparta::MKDIR(const char *) –> int

class pyrosetta.rosetta.protocols.sparta.PDB¶

Bases: pybind11_object

property ATOMS¶

property AtomSurfaceFullList¶

property AtomSurfacePartList¶

property Conformers¶

property EMPTY¶

property ElectricField¶

property HBDistList¶

property HBEnergyList¶

property HB_DHO_AngleList¶

property HB_HOA_AngleList¶

property HN_S2¶

property NeighborList¶

property PDBfileName¶

property ResSurfaceFullList¶

property ResSurfacePartList¶

property RingNo¶

property SpherePointNo¶

property SurfPrec¶

property VDW_RAD¶

property acceptorList¶

assign(self: pyrosetta.rosetta.protocols.sparta.PDB, : pyrosetta.rosetta.protocols.sparta.PDB) → pyrosetta.rosetta.protocols.sparta.PDB¶: C++: protocols::sparta::PDB::operator=(const class protocols::sparta::PDB &) –> class protocols::sparta::PDB &

calcPlane(self: pyrosetta.rosetta.protocols.sparta.PDB, ringP: pyrosetta.rosetta.protocols.sparta.RingData) → None¶: C++: protocols::sparta::PDB::calcPlane(struct protocols::sparta::RingData *) –> void

calcSurface(self: pyrosetta.rosetta.protocols.sparta.PDB, rad_sol: float) → None¶: C++: protocols::sparta::PDB::calcSurface(float) –> void

calc_ElectricField(self: pyrosetta.rosetta.protocols.sparta.PDB) → None¶: C++: protocols::sparta::PDB::calc_ElectricField() –> void

calc_HN_S2(self: pyrosetta.rosetta.protocols.sparta.PDB) → None¶: C++: protocols::sparta::PDB::calc_HN_S2() –> void

collect_HN_S2_and_EF(self: pyrosetta.rosetta.protocols.sparta.PDB) → None¶: C++: protocols::sparta::PDB::collect_HN_S2_and_EF() –> void

property donorList¶

findNeighors(self: pyrosetta.rosetta.protocols.sparta.PDB, rad_sol: float) → None¶: C++: protocols::sparta::PDB::findNeighors(float) –> void

getBondAngle(self: pyrosetta.rosetta.protocols.sparta.PDB, a: pyrosetta.rosetta.protocols.sparta.PDB_Entry, b: pyrosetta.rosetta.protocols.sparta.PDB_Entry, c: pyrosetta.rosetta.protocols.sparta.PDB_Entry) → float¶: C++: protocols::sparta::PDB::getBondAngle(struct protocols::sparta::PDB_Entry, struct protocols::sparta::PDB_Entry, struct protocols::sparta::PDB_Entry) –> float

getChi1(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, resNum: int) → float¶: C++: protocols::sparta::PDB::getChi1(int, int) –> float

getChi2(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, resNum: int) → float¶: C++: protocols::sparta::PDB::getChi2(int, int) –> float

getDihedralAngle(self: pyrosetta.rosetta.protocols.sparta.PDB, a: pyrosetta.rosetta.protocols.sparta.PDB_Entry, b: pyrosetta.rosetta.protocols.sparta.PDB_Entry, c: pyrosetta.rosetta.protocols.sparta.PDB_Entry, d: pyrosetta.rosetta.protocols.sparta.PDB_Entry) → float¶: C++: protocols::sparta::PDB::getDihedralAngle(struct protocols::sparta::PDB_Entry, struct protocols::sparta::PDB_Entry, struct protocols::sparta::PDB_Entry, struct protocols::sparta::PDB_Entry) –> float

getDist(self: pyrosetta.rosetta.protocols.sparta.PDB, A: pyrosetta.rosetta.protocols.sparta.PDB_Entry, B: pyrosetta.rosetta.protocols.sparta.PDB_Entry) → float¶: C++: protocols::sparta::PDB::getDist(struct protocols::sparta::PDB_Entry, struct protocols::sparta::PDB_Entry) –> float

getEntry(*args, **kwargs)¶

Overloaded function.

getEntry(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, rNum: int, aName: str) -> pyrosetta.rosetta.protocols.sparta.PDB_Entry

C++: protocols::sparta::PDB::getEntry(int, int, const std::string &) –> struct protocols::sparta::PDB_Entry

getEntry(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, aNum: int) -> pyrosetta.rosetta.protocols.sparta.PDB_Entry

C++: protocols::sparta::PDB::getEntry(int, int) –> struct protocols::sparta::PDB_Entry

getField(self: pyrosetta.rosetta.protocols.sparta.PDB, str: str, index: int) → str¶: C++: protocols::sparta::PDB::getField(const std::string &, int) –> std::string

getHBondDist(*args, **kwargs)¶

Overloaded function.

getHBondDist(self: pyrosetta.rosetta.protocols.sparta.PDB, D: pyrosetta.rosetta.protocols.sparta.PDB_Entry) -> float

C++: protocols::sparta::PDB::getHBondDist(struct protocols::sparta::PDB_Entry) –> float

getHBondDist(self: pyrosetta.rosetta.protocols.sparta.PDB, resNum: int, atomName: str) -> float

C++: protocols::sparta::PDB::getHBondDist(int, std::string) –> float

getOmega(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, resNum: int) → float¶: C++: protocols::sparta::PDB::getOmega(int, int) –> float

getOneAAName(self: pyrosetta.rosetta.protocols.sparta.PDB, a: str) → str¶: C++: protocols::sparta::PDB::getOneAAName(const std::string &) –> std::string

getOrbitalShift(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, resNum: int, aName: str) → float¶: C++: protocols::sparta::PDB::getOrbitalShift(int, int, const std::string &) –> float

getPhi(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, resNum: int) → float¶: C++: protocols::sparta::PDB::getPhi(int, int) –> float

getPsi(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, resNum: int) → float¶: C++: protocols::sparta::PDB::getPsi(int, int) –> float

getThreeAAName(self: pyrosetta.rosetta.protocols.sparta.PDB, a: str) → str¶: C++: protocols::sparta::PDB::getThreeAAName(char) –> std::string

initHBond(*args, **kwargs)¶

Overloaded function.

initHBond(self: pyrosetta.rosetta.protocols.sparta.PDB) -> None
initHBond(self: pyrosetta.rosetta.protocols.sparta.PDB, DIST: float) -> None
initHBond(self: pyrosetta.rosetta.protocols.sparta.PDB, DIST: float, ANGLE: float) -> None

C++: protocols::sparta::PDB::initHBond(float, float) –> void

initOrbitalShift(self: pyrosetta.rosetta.protocols.sparta.PDB) → None¶: C++: protocols::sparta::PDB::initOrbitalShift() –> void

isAcceptor(self: pyrosetta.rosetta.protocols.sparta.PDB, A: pyrosetta.rosetta.protocols.sparta.PDB_Entry) → pyrosetta.rosetta.protocols.sparta.PDB_Entry¶: C++: protocols::sparta::PDB::isAcceptor(struct protocols::sparta::PDB_Entry) –> struct protocols::sparta::PDB_Entry

isDonor(self: pyrosetta.rosetta.protocols.sparta.PDB, D: pyrosetta.rosetta.protocols.sparta.PDB_Entry) → pyrosetta.rosetta.protocols.sparta.PDB_Entry¶: C++: protocols::sparta::PDB::isDonor(struct protocols::sparta::PDB_Entry) –> struct protocols::sparta::PDB_Entry

isSSBonded(self: pyrosetta.rosetta.protocols.sparta.PDB, conformerID: int, resNum: int) → bool¶: C++: protocols::sparta::PDB::isSSBonded(int, int) –> bool

loadPDB(*args, **kwargs)¶

Overloaded function.

loadPDB(self: pyrosetta.rosetta.protocols.sparta.PDB, fileName: str) -> None

C++: protocols::sparta::PDB::loadPDB(const std::string &) –> void

loadPDB(self: pyrosetta.rosetta.protocols.sparta.PDB, file: pyrosetta.rosetta.std.istream) -> None

C++: protocols::sparta::PDB::loadPDB(std::istream &) –> void

loadPDB(self: pyrosetta.rosetta.protocols.sparta.PDB, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::sparta::PDB::loadPDB(const class core::pose::Pose &) –> void

loadPDB_Entry(self: pyrosetta.rosetta.protocols.sparta.PDB, str: str, entry: pyrosetta.rosetta.protocols.sparta.PDB_Entry) → None¶: C++: protocols::sparta::PDB::loadPDB_Entry(const std::string &, struct protocols::sparta::PDB_Entry &) –> void

property r1¶

property rN¶

property residList¶

property residListOne¶

class pyrosetta.rosetta.protocols.sparta.PDB_Entry¶

Bases: pybind11_object

property B_Factor¶

property X¶

property Y¶

property Z¶

assign(self: pyrosetta.rosetta.protocols.sparta.PDB_Entry, : pyrosetta.rosetta.protocols.sparta.PDB_Entry) → pyrosetta.rosetta.protocols.sparta.PDB_Entry¶: C++: protocols::sparta::PDB_Entry::operator=(const struct protocols::sparta::PDB_Entry &) –> struct protocols::sparta::PDB_Entry &

property atomName¶

property atomNum¶

property chainName¶

property resName¶

property resNum¶

class pyrosetta.rosetta.protocols.sparta.RingData¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.sparta.RingData, : pyrosetta.rosetta.protocols.sparta.RingData) → pyrosetta.rosetta.protocols.sparta.RingData¶: C++: protocols::sparta::RingData::operator=(const struct protocols::sparta::RingData &) –> struct protocols::sparta::RingData &

property atomNo¶

property rad¶

property resID¶

property resName¶

property ringFact¶

class pyrosetta.rosetta.protocols.sparta.Sparta¶

Bases: pybind11_object

property REF_CS_Tab¶

class SpartaLib¶

Bases: pybind11_object

{ most of the original SPARTA class goes into SpartaLib – to be reused between different evaluators…

property AAlist¶

property ADJ_Tab¶

property ANN_CS_OUTPUT_FULL¶

property ANN_IN_MTX¶

property BLOSUM_62¶

property CHI2_ANGLES¶

property EXCLUDED¶

property FIT_Tab¶

property HOMO_Tab¶

property NEXT_Tab¶

property OMEGA_ANGLES¶

property PDB_DIR¶

property PRED_DIR¶

property PREV_Tab¶

property RC_Tab¶

property SHIFT_DIR¶

property SPARTA_ANN¶

property SPARTA_DIR¶

property SPARTA_ERR_SURF¶

property SURFACE_EXPOSURE¶

property TAB_DIR¶

property TRIPLET_Tab¶

property WEIGHT_Tab¶

property aN¶

property adjFileName¶

assign(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, : pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib) → pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib¶: C++: protocols::sparta::Sparta::SpartaLib::operator=(const class protocols::sparta::Sparta::SpartaLib &) –> class protocols::sparta::Sparta::SpartaLib &

deallocate_arrays(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib) → None¶: C++: protocols::sparta::Sparta::SpartaLib::deallocate_arrays() –> void

property firstRes¶

property fitFileName¶

getANN_PredError(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, phi: float, psi: float, aa: str, aName: str) → float¶: C++: protocols::sparta::Sparta::SpartaLib::getANN_PredError(float, float, std::string, std::string) –> float

getNextRCadj(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, next_rName: str, aName: str) → float¶: C++: protocols::sparta::Sparta::SpartaLib::getNextRCadj(const std::string &, const std::string &) –> float

getPrevRCadj(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, prev_rName: str, aName: str) → float¶: C++: protocols::sparta::Sparta::SpartaLib::getPrevRCadj(const std::string &, const std::string &) –> float

getRC(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, resName: str, aName: str) → float¶: C++: protocols::sparta::Sparta::SpartaLib::getRC(const std::string &, const std::string &) –> float

getRCadj(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, resName: str, aName: str) → float¶: C++: protocols::sparta::Sparta::SpartaLib::getRCadj(const std::string &, const std::string &) –> float

getResInfo(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, create_output: bool) → None¶: C++: protocols::sparta::Sparta::SpartaLib::getResInfo(bool) –> void

getWeight(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, Name: str, aName: str) → float¶: C++: protocols::sparta::Sparta::SpartaLib::getWeight(const std::string &, const std::string &) –> float

get_ANN_data(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, create_output: bool) → pyrosetta.rosetta.protocols.sparta.GDB¶: C++: protocols::sparta::Sparta::SpartaLib::get_ANN_data(bool) –> class protocols::sparta::GDB

property homoFileName¶

property inName¶

property inNames¶

property inPDB¶

property inTab¶

init(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib) → None¶: C++: protocols::sparta::Sparta::SpartaLib::init() –> void

init_PredErrorSurface(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib) → None¶: C++: protocols::sparta::Sparta::SpartaLib::init_PredErrorSurface() –> void

property lastRes¶

property matchCount¶

mkdir_pred(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, d: str) → None¶: C++: protocols::sparta::Sparta::SpartaLib::mkdir_pred(const std::string &) –> void

property nextFileName¶

property pdbListName¶

property prevFileName¶

property r1¶

property rN¶

property rcFileName¶

property residList¶

property sequence¶

setup_defaults(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib) → None¶: C++: protocols::sparta::Sparta::SpartaLib::setup_defaults() –> void

setup_for_scoring(self: pyrosetta.rosetta.protocols.sparta.Sparta.SpartaLib, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::sparta::Sparta::SpartaLib::setup_for_scoring(const class core::pose::Pose &) –> void

property slash_char¶

property sourceName¶

property sumName¶

property tVal¶

property tripFileName¶

property weightFileName¶

assign(self: pyrosetta.rosetta.protocols.sparta.Sparta, : pyrosetta.rosetta.protocols.sparta.Sparta) → pyrosetta.rosetta.protocols.sparta.Sparta¶: C++: protocols::sparta::Sparta::operator=(const class protocols::sparta::Sparta &) –> class protocols::sparta::Sparta &

property bCreateOutput_¶

check_pose(self: pyrosetta.rosetta.protocols.sparta.Sparta, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::sparta::Sparta::check_pose(const class core::pose::Pose &) –> void

lib(self: pyrosetta.rosetta.protocols.sparta.Sparta) → protocols::sparta::Sparta::SpartaLib¶: C++: protocols::sparta::Sparta::lib() –> class protocols::sparta::Sparta::SpartaLib &

property refCSFileName¶

static register_options() → None¶: C++: protocols::sparta::Sparta::register_options() –> void

run_A_ANN_Prediction(self: pyrosetta.rosetta.protocols.sparta.Sparta) → float¶: C++: protocols::sparta::Sparta::run_A_ANN_Prediction() –> double

score_pose(self: pyrosetta.rosetta.protocols.sparta.Sparta, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::sparta::Sparta::score_pose(const class core::pose::Pose &) –> double

score_pose_per_residue(self: pyrosetta.rosetta.protocols.sparta.Sparta, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_float¶: C++: protocols::sparta::Sparta::score_pose_per_residue(const class core::pose::Pose &) –> class utility::vector1<float, class std::allocator<float> >

pyrosetta.rosetta.protocols.sparta.contains(*args, **kwargs)¶

Overloaded function.

contains(str: str, c: str) -> int

C++: protocols::sparta::contains(const std::string &, const std::string &) –> int

contains(str: str, c: str) -> int

C++: protocols::sparta::contains(const std::string &, const char &) –> int

pyrosetta.rosetta.protocols.sparta.ftoa(*args, **kwargs)¶

Overloaded function.

ftoa(n: float, buff: str, s: int) -> str
ftoa(n: float, buff: str, s: int, f: str) -> str
ftoa(n: float, buff: str, s: int, f: str, prec: int) -> str

C++: protocols::sparta::ftoa(float, char *, unsigned long, char, int) –> char *

pyrosetta.rosetta.protocols.sparta.getAVG(v1: pyrosetta.rosetta.utility.vector0_float) → float¶: C++: protocols::sparta::getAVG(class utility::vector0<float, class std::allocator<float> > &) –> float

pyrosetta.rosetta.protocols.sparta.getDiff(ang1: float, ang2: float) → float¶: C++: protocols::sparta::getDiff(float, float) –> float

pyrosetta.rosetta.protocols.sparta.getRMS(v1: pyrosetta.rosetta.utility.vector0_float, v2: pyrosetta.rosetta.utility.vector0_float) → float¶: C++: protocols::sparta::getRMS(class utility::vector0<float, class std::allocator<float> > &, class utility::vector0<float, class std::allocator<float> > &) –> float

pyrosetta.rosetta.protocols.sparta.getSTD(v1: pyrosetta.rosetta.utility.vector0_float) → float¶: C++: protocols::sparta::getSTD(class utility::vector0<float, class std::allocator<float> > &) –> float

pyrosetta.rosetta.protocols.sparta.isDigit(c: str) → bool¶: C++: protocols::sparta::isDigit(const char &) –> bool

pyrosetta.rosetta.protocols.sparta.isDirExists(Dir: str) → bool¶: C++: protocols::sparta::isDirExists(const std::string &) –> bool

pyrosetta.rosetta.protocols.sparta.isSpace(c: str) → bool¶: C++: protocols::sparta::isSpace(const char &) –> bool

pyrosetta.rosetta.protocols.sparta.itoa(*args, **kwargs)¶

Overloaded function.

itoa(n: int, buff: str, s: int) -> str
itoa(n: int, buff: str, s: int, base: int) -> str

C++: protocols::sparta::itoa(int, char *, unsigned long, int) –> char *

pyrosetta.rosetta.protocols.sparta.section(*args, **kwargs)¶

Overloaded function.

section(str: str, seq: str, buff: str, n: int, start: int) -> str
section(str: str, seq: str, buff: str, n: int, start: int, end: int) -> str

C++: protocols::sparta::section(const std::string &, const char &, char *, unsigned long, int, int) –> char *

pyrosetta.rosetta.protocols.sparta.simplifyWhiteSpace(str: str) → str¶: C++: protocols::sparta::simplifyWhiteSpace(const std::string &) –> std::string

pyrosetta.rosetta.protocols.sparta.split(*args, **kwargs)¶

Overloaded function.

split(sep: str, str: str) -> pyrosetta.rosetta.utility.vector0_std_string

C++: protocols::sparta::split(const char, const std::string &) –> class utility::vector0<std::string, class std::allocator<std::string > >

split(sep: str, str: str) -> pyrosetta.rosetta.utility.vector0_std_string

C++: protocols::sparta::split(const std::string &, const std::string &) –> class utility::vector0<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.protocols.sparta.split_WhiteSpace(str: str) → pyrosetta.rosetta.utility.vector0_std_string¶: C++: protocols::sparta::split_WhiteSpace(const std::string &) –> class utility::vector0<std::string, class std::allocator<std::string > >