sparta

Bindings for protocols::sparta namespace

class pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the ChemicalShiftsEvaluatorCreator class

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.sparta.ChemicalShiftEvaluatorCreator) → None

__init_subclass__()

This method is called when a class is subclassed.

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

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

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

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

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

add_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

pyrosetta.rosetta.protocols.sparta.MKDIR(dirName: str) → int

C++: protocols::sparta::MKDIR(const char *) –> int

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

Overloaded function.

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

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

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

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

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

Overloaded function.

1. ftoa(n: float, buff: str) -> str
2. ftoa(n: float, buff: str, f: str) -> str
3. ftoa(n: float, buff: str, f: str, prec: int) -> str

C++: protocols::sparta::ftoa(float, char *, 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 class std::basic_string<char> &) –> 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.

1. itoa(n: int, buff: str) -> str
2. itoa(n: int, buff: str, base: int) -> str

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

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

Overloaded function.

1. section(str: str, seq: str, buff: str, start: int) -> str
2. section(str: str, seq: str, buff: str, start: int, end: int) -> str

C++: protocols::sparta::section(const class std::basic_string<char> &, const char &, char *, int, int) –> char *

pyrosetta.rosetta.protocols.sparta.simplifyWhiteSpace(str: str) → str

C++: protocols::sparta::simplifyWhiteSpace(const class std::basic_string<char> &) –> std::string

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

Overloaded function.

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

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

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

C++: protocols::sparta::split(const class std::basic_string<char> &, const class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> class utility::vector0<std::string, class std::allocator<std::string > >