pose¶

Bindings for core::pose namespace

class pyrosetta.rosetta.core.pose.MiniPose¶

Bases: pybind11_object

not quite (silent_structs don’t necessarily have xyz). Kind of like a Conformation but without the overtree of an atom_tree.

Should save memory compared to keeping the full pose (which includes atom_tree, energies etc.) This is a bit like the SilentStruct – although that class has gotten a bit complicated – easier to start from scratch.

assign(self: pyrosetta.rosetta.core.pose.MiniPose, : pyrosetta.rosetta.core.pose.MiniPose) → pyrosetta.rosetta.core.pose.MiniPose¶: C++: core::pose::MiniPose::operator=(const class core::pose::MiniPose &) –> class core::pose::MiniPose &

atom_name(self: pyrosetta.rosetta.core.pose.MiniPose, atom_id: pyrosetta.rosetta.core.id.AtomID) → str¶: C++: core::pose::MiniPose::atom_name(class core::id::AtomID) const –> const std::string &

atom_names_list(self: pyrosetta.rosetta.core.pose.MiniPose) → pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t¶: C++: core::pose::MiniPose::atom_names_list() const –> const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &

coords(self: pyrosetta.rosetta.core.pose.MiniPose) → pyrosetta.rosetta.utility.vector1_utility_vector1_numeric_xyzVector_double_std_allocator_numeric_xyzVector_double_t¶: C++: core::pose::MiniPose::coords() const –> const class utility::vector1<class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >, class std::allocator<class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > > > &

fold_tree(self: pyrosetta.rosetta.core.pose.MiniPose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: core::pose::MiniPose::fold_tree() const –> const class core::kinematics::FoldTree &

sequence(self: pyrosetta.rosetta.core.pose.MiniPose) → str¶: C++: core::pose::MiniPose::sequence() const –> const std::string &

size(self: pyrosetta.rosetta.core.pose.MiniPose) → int¶: C++: core::pose::MiniPose::size() const –> unsigned long

variant_types(self: pyrosetta.rosetta.core.pose.MiniPose, seq_num: int) → pyrosetta.rosetta.utility.vector1_std_string¶: C++: core::pose::MiniPose::variant_types(const unsigned long) const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

variant_types_list(self: pyrosetta.rosetta.core.pose.MiniPose) → pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t¶: C++: core::pose::MiniPose::variant_types_list() const –> const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &

xyz(self: pyrosetta.rosetta.core.pose.MiniPose, atom_id: pyrosetta.rosetta.core.id.AtomID) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::pose::MiniPose::xyz(class core::id::AtomID) const –> const class numeric::xyzVector<double> &

class pyrosetta.rosetta.core.pose.PDBInfo¶

Bases: pybind11_object

maintains pdb residue & atom information inside a Pose

Upon creation of new residue records, e.g. when calling the: constructors without ‘init’ or appending/prepending residues, the chain letter for the new records will be set to a character, currently ‘^’, denoting “empty record”. This character may be looked up by calling the static method PDBInfo::empty_record().
Class implementation is biased towards simplicity and fast lookup.: Residue/atom information are kept in vectors. An internally maintained PDBPoseMap provides mapping from pdb -> pose residue numbering. This causes residue mutators to be a bit more expensive due to map updates, but this is ok because they are typically called sparingly. Accessors and mutators have overloaded method convention, while special mutators use .set_* convention.

class AtomRecord¶

Bases: pybind11_object

internal struct for storing PDB atom related information

property altLoc¶

property isHet¶

property occupancy¶

property temperature¶

class ResidueRecord¶

Bases: pybind11_object

internal struct for storing PDB residue related information

assign(self: pyrosetta.rosetta.core.pose.PDBInfo.ResidueRecord, : pyrosetta.rosetta.core.pose.PDBInfo.ResidueRecord) → pyrosetta.rosetta.core.pose.PDBInfo.ResidueRecord¶: C++: core::pose::PDBInfo::ResidueRecord::operator=(const struct core::pose::PDBInfo::ResidueRecord &) –> struct core::pose::PDBInfo::ResidueRecord &

property atomRec¶

property chainID¶

property iCode¶

property label¶

property resSeq¶

property segmentID¶

add_reslabel(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, label: str) → None¶

adds a label associated to a pose resid.

residue in pose numbering

string that is the “label”

C++: core::pose::PDBInfo::add_reslabel(unsigned long, const std::string &) –> void

add_unrecognized_atoms(self: pyrosetta.rosetta.core.pose.PDBInfo, UAs: pyrosetta.rosetta.utility.vector1_core_pose_UnrecognizedAtomRecord) → None¶

remembers info about atoms not read into the pose

C++: core::pose::PDBInfo::add_unrecognized_atoms(class utility::vector1<class core::pose::UnrecognizedAtomRecord, class std::allocator<class core::pose::UnrecognizedAtomRecord> >) –> void

alt_loc(*args, **kwargs)¶

Overloaded function.

alt_loc(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int) -> str

Returns the alternate location for the <atom_index> atom of pose

residue <res>

example(s):: pose.pdb_info().alt_loc(1,1)
See also:: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::alt_loc(const unsigned long, const unsigned long) const –> const char &

alt_loc(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int, loc: str) -> None

Sets the alternate location of the <atom_index> atom of pose: residue <res> to <loc>

: <loc> is an alternate location character

C++: core::pose::PDBInfo::alt_loc(const unsigned long, const unsigned long, const char) –> void

append_res(*args, **kwargs)¶

Overloaded function.

append_res(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, natoms: int) -> None
append_res(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, natoms: int, n: int) -> None

Appends residue records given a pose residue number <res>

residue to append after (in internal/pose numbering)

number of atoms in type of appended residue

number of residue records to append

C++: core::pose::PDBInfo::append_res(const unsigned long, const unsigned long, const unsigned long) –> void

assign(self: pyrosetta.rosetta.core.pose.PDBInfo, info: pyrosetta.rosetta.core.pose.PDBInfo) → pyrosetta.rosetta.core.pose.PDBInfo¶

copy assignment

C++: core::pose::PDBInfo::operator=(const class core::pose::PDBInfo &) –> class core::pose::PDBInfo &

attach_to(self: pyrosetta.rosetta.core.pose.PDBInfo, conf: pyrosetta.rosetta.core.conformation.Conformation) → None¶

Attaches the Conformation <conf> and begins observation

example(s):

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::attach_to(class core::conformation::Conformation &) –> void

bfactor(*args, **kwargs)¶

Overloaded function.

bfactor(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int) -> float

Returns the temperature for the <atom_index> atom of pose residue <res>

example(s):
pose.pdb_info().temperature(1,1)

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::bfactor(const unsigned long, const unsigned long) const –> const double &

bfactor(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int, t: float) -> None

Sets the temperature of the <atom_index> atom of pose residue: <res> to <t>

C++: core::pose::PDBInfo::bfactor(const unsigned long, const unsigned long, const double) –> void

chain(*args, **kwargs)¶

Overloaded function.

chain(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) -> str

Returns the chain letter for pose residue <res>

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):
pose.pdb_info().chain(3)

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::chain(const unsigned long) const –> const char &

chain(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, chain_id: str) -> None

Sets the chain letter of pose residue <res> to <chain_id>

chain_id should not be the empty record character, currently ‘^’

Returns the pdb insertion code of residue <res>

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):
pose.pdb_info().chain(3,”R”)

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::chain(const unsigned long, const char) –> void

chain_sequences(*args, **kwargs)¶

Overloaded function.

chain_sequences(self: pyrosetta.rosetta.core.pose.PDBInfo, chain_sequences: pyrosetta.rosetta.std.map_char_utility_vector1_std_string_std_allocator_std_string_t_std_allocator_std_pair_const_char_utility_vector1_std_string_std_allocator_std_string_t) -> None

Note: The chain sequences information is only initialized if it is needed.: Generally this requires using the -run:preserve_header options flag.

C++: core::pose::PDBInfo::chain_sequences(class std::map<char, class utility::vector1<std::string, class std::allocator<std::string > >, struct std::less<char>, class std::allocator<struct std::pair<const char, class utility::vector1<std::string, class std::allocator<std::string > > > > >) –> void

chain_sequences(self: pyrosetta.rosetta.core.pose.PDBInfo, chain: str) -> pyrosetta.rosetta.utility.vector1_std_string

C++: core::pose::PDBInfo::chain_sequences(char) –> class utility::vector1<std::string, class std::allocator<std::string > >

chain_sequences(self: pyrosetta.rosetta.core.pose.PDBInfo) -> pyrosetta.rosetta.std.map_char_utility_vector1_std_string_std_allocator_std_string_t_std_allocator_std_pair_const_char_utility_vector1_std_string_std_allocator_std_string_t

C++: core::pose::PDBInfo::chain_sequences() –> class std::map<char, class utility::vector1<std::string, class std::allocator<std::string > >, struct std::less<char>, class std::allocator<struct std::pair<const char, class utility::vector1<std::string, class std::allocator<std::string > > > > >

clear_reslabel(*args, **kwargs)¶

Overloaded function.

clear_reslabel(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) -> None

clean all the label(s) associated to a pose resid.

residue in pose numbering

C++: core::pose::PDBInfo::clear_reslabel(const unsigned long) –> void

clear_reslabel(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, match_label: str) -> None

Clean a specific label of a specific residue if that label contains: the string.

C++: core::pose::PDBInfo::clear_reslabel(const unsigned long, const std::string &) –> void

copy(self: pyrosetta.rosetta.core.pose.PDBInfo, input_info: pyrosetta.rosetta.core.pose.PDBInfo, copy_from: int, copy_to: int, start_from: int) → None¶

Copyies a section from PDBInfo <input_info>

the PDBInfo to copy from

the first residue position in input_info to copy

the final residue position in input_info to copy

the first residue position in this PDBInfo to
copy into

C++: core::pose::PDBInfo::copy(const class core::pose::PDBInfo &, const unsigned long, const unsigned long, const unsigned long) –> void

crystinfo(self: pyrosetta.rosetta.core.pose.PDBInfo) → pyrosetta.rosetta.core.io.CrystInfo¶

Returns the pdb crystinfo

C++: core::pose::PDBInfo::crystinfo() const –> class core::io::CrystInfo

delete_res(*args, **kwargs)¶

Overloaded function.

delete_res(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) -> None
delete_res(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, n: int) -> None

Deletes <n> residue records starting from pose residue <res>

residue to start deleting from (in internal/pose numbering)

number of residue records to delete

C++: core::pose::PDBInfo::delete_res(const unsigned long, const unsigned long) –> void

detach_from(self: pyrosetta.rosetta.core.pose.PDBInfo) → None¶

Detaches the Conformation and stops observation

takes no arguments because PDBInfo can only observe one Conformation at a time

example(s):
pose.pdb_info().detach_from()

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::detach_from() –> void

static empty_record() → str¶

Returns the chain letter character specifying “empty record”,: currently ‘^’

C++: core::pose::PDBInfo::empty_record() –> char

get_num_unrecognized_atoms(self: pyrosetta.rosetta.core.pose.PDBInfo) → int¶: C++: core::pose::PDBInfo::get_num_unrecognized_atoms() const –> const unsigned long &

get_num_unrecognized_res(self: pyrosetta.rosetta.core.pose.PDBInfo) → int¶: C++: core::pose::PDBInfo::get_num_unrecognized_res() const –> const unsigned long &

get_reslabels(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) → pyrosetta.rosetta.utility.vector1_std_string¶

returns the pose(number) labels associated to the residue

residue in pose numbering

C++: core::pose::PDBInfo::get_reslabels(const unsigned long) const –> class utility::vector1<std::string, class std::allocator<std::string > >

get_unrecognized_atoms(self: pyrosetta.rosetta.core.pose.PDBInfo) → pyrosetta.rosetta.utility.vector1_core_pose_UnrecognizedAtomRecord¶

remembers info about atoms not read into the pose

C++: core::pose::PDBInfo::get_unrecognized_atoms() const –> const class utility::vector1<class core::pose::UnrecognizedAtomRecord, class std::allocator<class core::pose::UnrecognizedAtomRecord> > &

get_unrecognized_res_name(self: pyrosetta.rosetta.core.pose.PDBInfo, i: int) → str¶: C++: core::pose::PDBInfo::get_unrecognized_res_name(const unsigned long &) const –> const std::string &

get_unrecognized_res_size(self: pyrosetta.rosetta.core.pose.PDBInfo, i: int) → int¶: C++: core::pose::PDBInfo::get_unrecognized_res_size(const unsigned long &) const –> const unsigned long &

header_information(*args, **kwargs)¶

Overloaded function.

header_information(self: pyrosetta.rosetta.core.pose.PDBInfo, header_information: pyrosetta.rosetta.core.io.HeaderInformation) -> None

Note: The header information is only initialized if it is needed.: Generally this requires using the -run:preserve_header options flag.

C++: core::pose::PDBInfo::header_information(class std::shared_ptr<class core::io::HeaderInformation>) –> void

header_information(self: pyrosetta.rosetta.core.pose.PDBInfo) -> pyrosetta.rosetta.core.io.HeaderInformation

C++: core::pose::PDBInfo::header_information() –> class std::shared_ptr<class core::io::HeaderInformation>

icode(*args, **kwargs)¶

Overloaded function.

icode(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) -> str

Returns the pdb insertion code of residue <res>

example(s):
pose.pdb_info().icode(3)

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::icode(const unsigned long) const –> const char &

icode(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, ins_code: str) -> None

Sets the insertion code of pose residue <res> to _code>

Returns the pdb insertion code of residue <res>

example(s):

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::icode(const unsigned long, const char) –> void

is_het(*args, **kwargs)¶

Overloaded function.

is_het(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int) -> bool

Returns true if the <atom_index> atom of pose residue <res>: is a heteratom
: atom index within instance of core::conformation::Residue,: currently Rosetta’s pdb file output treats the value of .is_het() as an override – if this is set to true, the record will be hetatm, otherwise it will decide by Residue type (the usual default)

C++: core::pose::PDBInfo::is_het(const unsigned long, const unsigned long) const –> const bool &

is_het(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int, flag: bool) -> None

Sets the heteroatom flag of the <atom_index> atom of pose

residue <res> to <flag>

currently Rosetta’s pdb file output treats the value of .is_het() as an override – if this is set to true, the record will be hetatm, otherwise it will decide by Residue type (the usual default)

C++: core::pose::PDBInfo::is_het(const unsigned long, const unsigned long, const bool) –> void

is_observing(self: pyrosetta.rosetta.core.pose.PDBInfo) → pyrosetta.rosetta.std.weak_ptr_const_core_conformation_Conformation_t¶

Returns the Conformation if this PDBInfo is currently observing

a conformation, otherwise return NULL

example(s):: pose.pdb_info().is_observing()
See also:: Pose PDBInfo

C++: core::pose::PDBInfo::is_observing() –> class std::weak_ptr<const class core::conformation::Conformation>

modeltag(*args, **kwargs)¶

Overloaded function.

modeltag(self: pyrosetta.rosetta.core.pose.PDBInfo) -> str

Returns the model tag for a multi-model pdb

example(s):
pose.pdb_info().modeltag()

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::modeltag() const –> const std::string &

modeltag(self: pyrosetta.rosetta.core.pose.PDBInfo, tag: str) -> None

Sets the model tag for a multi-model pdb to <tag>

example(s):
pose.pdb_info().modeltag(‘Number1’)

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::modeltag(const std::string &) –> void

name(*args, **kwargs)¶

Overloaded function.

name(self: pyrosetta.rosetta.core.pose.PDBInfo) -> str

Returns the pdb name

example(s):
pose.pdb_info().name()

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::name() const –> const std::string &

name(self: pyrosetta.rosetta.core.pose.PDBInfo, s: str) -> None

Sets the pdb name

example(s):
pose.pdb_info().name(‘MyPDB’)

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::name(const std::string &) –> void

natoms(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) → int¶

Returns the number of atoms represented for the residue <res>

: residue <res> must be in pose numbering

example(s):
pose.pdb_info().natoms(3)

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::natoms(const unsigned long) const –> unsigned long

nres(self: pyrosetta.rosetta.core.pose.PDBInfo) → int¶

Returns the number of residues represented in PDBInfo

example(s):
pose.pdb_info().nres()

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::nres() const –> unsigned long

num_chains(self: pyrosetta.rosetta.core.pose.PDBInfo) → int¶

Returns the total number of (chain letter) chains in the pose

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):
pose.pdb_info().num_chains()

see also:

pose pose.annotated_sequence pose.fold_tree pose.num_jump

pose.pdb_info().chain pose.pdb_info().pdb2pose

C++: core::pose::PDBInfo::num_chains() const –> int

number(*args, **kwargs)¶

Overloaded function.

number(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) -> int

Returns the pdb sequence number of pose residue <res>

example(s):
pose.pdb_info().number(3)

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::number(const unsigned long) const –> const int &

number(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, pdb_res: int) -> None

Sets the pdb sequence residue number of pose residue <res> to <pdb_res>

Returns the pdb insertion code of residue <res>

example(s):
pose.pdb_info().number(3,81)

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::number(const unsigned long, const int) –> void

obsolete(*args, **kwargs)¶

Overloaded function.

obsolete(self: pyrosetta.rosetta.core.pose.PDBInfo) -> bool

Returns true if PDBInfo is obsolete and needs updating

This flag is currently not used within the class and is provided for user convenience. Setting this will forcibly turn off pdb numbering when dumping pdbs.

example(s):
pose.pdb_info().obsolete()

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::obsolete() const –> bool

obsolete(self: pyrosetta.rosetta.core.pose.PDBInfo, flag: bool) -> None

Sets the obsolete state to <flag>

this flag is currently not used within the class and is provided for user convenience. Setting this will forcibly turn off pdb numbering when dumping pdbs.

C++: core::pose::PDBInfo::obsolete(bool) –> void

occupancy(*args, **kwargs)¶

Overloaded function.

occupancy(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int) -> float

Returns the occupancy for the <atom_index> atom of pose residue <res>

example(s):
pose.pdb_info().occupancy(1,1)

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::occupancy(const unsigned long, const unsigned long) const –> const double &

occupancy(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int, occ: float) -> None

Sets the occupancy of the <atom_index> atom of pose residue: <res> to <occ>

C++: core::pose::PDBInfo::occupancy(const unsigned long, const unsigned long, const double) –> void

on_connection_change(self: pyrosetta.rosetta.core.pose.PDBInfo, event: pyrosetta.rosetta.core.conformation.signals.ConnectionEvent) → None¶

Updates when connection to Conformation is changed

C++: core::pose::PDBInfo::on_connection_change(const struct core::conformation::signals::ConnectionEvent &) –> void

on_identity_change(self: pyrosetta.rosetta.core.pose.PDBInfo, event: pyrosetta.rosetta.core.conformation.signals.IdentityEvent) → None¶

Updates atom records when residue identity changes in Conformation

C++: core::pose::PDBInfo::on_identity_change(const struct core::conformation::signals::IdentityEvent &) –> void

on_length_change(self: pyrosetta.rosetta.core.pose.PDBInfo, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) → None¶

Updates residue and atom records when length changes in Conformation,: obsoletes PDBInfo

C++: core::pose::PDBInfo::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

parse_pdbinfo_labels(self: pyrosetta.rosetta.core.pose.PDBInfo, lines: pyrosetta.rosetta.utility.vector1_std_string, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

parse PDBInfo-LABEL: lines from a collection of lines

Lines not containing PDBInfo-LABEL are ignored

the lines to parse

C++: core::pose::PDBInfo::parse_pdbinfo_labels(const class utility::vector1<std::string, class std::allocator<std::string > > &, const class core::pose::Pose &) –> void

pdb2pose(*args, **kwargs)¶

Overloaded function.

pdb2pose(self: pyrosetta.rosetta.core.pose.PDBInfo, chain: str, res: int) -> int
pdb2pose(self: pyrosetta.rosetta.core.pose.PDBInfo, chain: str, res: int, icode: str) -> int
pdb2pose(self: pyrosetta.rosetta.core.pose.PDBInfo, chain: str, res: int, icode: str, segmentID: str) -> int

Returns the pose numbering of the pdb residue with chain letter <chain>,

pdb residue <res>, and insertion code <icode>

: <icode> is not required, returns 0 if not found,

pose numbering is sequential ie. starts at 1 and goes up pdb numbering can be anything

example(s):: pose.pdb_info().pdb2pose(“B”,5)
See also:: Pose PDBInfo PDBInfo.pose2pdb

C++: core::pose::PDBInfo::pdb2pose(const char, const int, const char, const std::string &) const –> unsigned long

pdb2pose(self: pyrosetta.rosetta.core.pose.PDBInfo) -> pyrosetta.rosetta.core.pose.PDBPoseMap

Returns the internally maintained PDBPoseMap

example(s):

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::pdb2pose() const –> const class core::pose::PDBPoseMap &

pose2pdb(*args, **kwargs)¶

Overloaded function.

pose2pdb(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) -> str
pose2pdb(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, conn: str) -> str

Returns the pdb numbering string of pose residue <res>

: pdb string contains the chain letter and number

pose numbering is sequential ie. starts at 1 and goes up pdb numbering can be anything

example(s):: pose.pdb_info().pose2pdb(25)
See also:: Pose PDBInfo PDBInfo.pdb2pose

C++: core::pose::PDBInfo::pose2pdb(const unsigned long, const std::string &) const –> std::string

prepend_res(*args, **kwargs)¶

Overloaded function.

prepend_res(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, natoms: int) -> None
prepend_res(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, natoms: int, n: int) -> None

Prepends residue records before given pose residue number <res>

residue to prepend before (in internal/pose numbering)

number of atoms in type of appended residue

number of residue records to prepend

C++: core::pose::PDBInfo::prepend_res(const unsigned long, const unsigned long, const unsigned long) –> void

rebuild_pdb2pose(self: pyrosetta.rosetta.core.pose.PDBInfo) → None¶

rebuilds PDBPoseMap from scratch

C++: core::pose::PDBInfo::rebuild_pdb2pose() –> void

remarks(*args, **kwargs)¶

Overloaded function.

remarks(self: pyrosetta.rosetta.core.pose.PDBInfo) -> pyrosetta.rosetta.core.io.Remarks

Returns the pdb remarks (mutable)

we allow direct access to the remarks vector because its state is independent of the rest of PDBInfo and it’s much more convenient for the user

example(s):
pose.pdb_info().remarks()

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::remarks() –> class core::io::Remarks &

remarks(self: pyrosetta.rosetta.core.pose.PDBInfo, in: pyrosetta.rosetta.core.io.Remarks) -> None

Sets the pdb remarks to <in>

example(s):

See also:
Pose PDBInfo

C++: core::pose::PDBInfo::remarks(const class core::io::Remarks &) –> void

replace_res(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, natoms: int) → None¶

“Replaces” residue record for pose residue <res>

Leaves information in residue record untouched, but resizes and zeroes atom records for the residue.

residue to replace

number of atoms in type of residue

C++: core::pose::PDBInfo::replace_res(const unsigned long, const unsigned long) –> void

replace_res_remap_bfactors(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, tgt: pyrosetta.rosetta.core.conformation.Residue) → None¶

same as replace_res BUT remaps B factors from src to tgt

C++: core::pose::PDBInfo::replace_res_remap_bfactors(const unsigned long, const class core::conformation::Residue &) –> void

res_haslabel(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, target_label: str) → bool¶

uses std iterators to check if a residue has a label associated to it

residue in pose numbering

string to look for inside the labes associated to the residue

C++: core::pose::PDBInfo::res_haslabel(unsigned long, const std::string &) const –> bool

resize_atom_records(*args, **kwargs)¶

Overloaded function.

resize_atom_records(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, n: int) -> None
resize_atom_records(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, n: int, zero: bool) -> None

Ensures <n> atom records for residue <res> are available

: if <zero> is true, zero the atom records for this residue

C++: core::pose::PDBInfo::resize_atom_records(const unsigned long, const unsigned long, const bool) –> void

resize_atom_records(self: pyrosetta.rosetta.core.pose.PDBInfo, n: int) -> None
resize_atom_records(self: pyrosetta.rosetta.core.pose.PDBInfo, n: int, zero: bool) -> None

Ensures <n> atom records for residue <res> are available

: if <zero> is true, zero the atom records for this residue

C++: core::pose::PDBInfo::resize_atom_records(const unsigned long, const bool) –> void

resize_atom_records(self: pyrosetta.rosetta.core.pose.PDBInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Updates the number of atom records with respect to atoms in <pose>

Number of internally available atom records will be adjusted to match number of atoms within each residue in Pose. Only newly created records will be zeroed, any existing records are untouched.

C++: core::pose::PDBInfo::resize_atom_records(const class core::pose::Pose &) –> void

resize_residue_records(self: pyrosetta.rosetta.core.pose.PDBInfo, n: int) → None¶

Resizes for <n> residue records

Leaves atom record state inconsistent. Atom records for remaining residues are untouched while new residues have no atom records, so make sure and call one of resize_atom_records() afterwards if necessary.

Do not use this method for ins/del of residues, as it leaves the data state inconsistent. See append_res/prepend_res/delete_res for that type of functionality.

C++: core::pose::PDBInfo::resize_residue_records(const unsigned long) –> void

segmentID(*args, **kwargs)¶

Overloaded function.

segmentID(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) -> str

Returns the segment ID code of residue <res>

example(s):
pose.pdb_info().icode(3)

C++: core::pose::PDBInfo::segmentID(const unsigned long) const –> const std::string &

segmentID(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, segmentID: str) -> None

Sets the insertion code of pose residue <res> to _code>

Returns the pdb insertion code of residue <res>

example(s):

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::segmentID(const unsigned long, const std::string &) –> void

set_chains(self: pyrosetta.rosetta.core.pose.PDBInfo, id: str) → None¶

Sets all residue chain ids to the character <id>

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::PDBInfo::set_chains(const char) –> void

set_crystinfo(self: pyrosetta.rosetta.core.pose.PDBInfo, crystinfoin: pyrosetta.rosetta.core.io.CrystInfo) → None¶

Sets the pdb crystinfo

C++: core::pose::PDBInfo::set_crystinfo(class core::io::CrystInfo) –> void

set_resinfo(*args, **kwargs)¶

Overloaded function.

set_resinfo(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, chain_id: str, pdb_res: int) -> None
set_resinfo(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, chain_id: str, pdb_res: int, ins_code: str) -> None
set_resinfo(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, chain_id: str, pdb_res: int, ins_code: str, segmentID: str) -> None
set_resinfo(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, chain_id: str, pdb_res: int, ins_code: str, segmentID: str, clear_labels: bool) -> None

Sets the chain letter, pdb sequence residue numbering, and insertion

code for pose residue <res> to <chain_id> , <pdb_res> , and _code> respectfully

: convenience method; more efficient than doing each individually

due to map updates

Returns the pdb insertion code of residue <res>

example(s):: pose.pdb_info().icode(3)
See also:: Pose PDBInfo PDBInfo.chain PDBInfo.icode PDBInfo.number PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::set_resinfo(const unsigned long, const char, const int, const char, const std::string &, bool) –> void

short_desc(self: pyrosetta.rosetta.core.pose.PDBInfo) → str¶

Returns a short description of the contents of the PDBInfo.

The current format of this is something like “A:1-3 B:9-11”

example(s);: pose.pdb_info().short_desc()
See Also:: PDBInfo PDBInfo.show Pose.pdb_info

C++: core::pose::PDBInfo::short_desc() const –> std::string

show(self: pyrosetta.rosetta.core.pose.PDBInfo, out: pyrosetta.rosetta.std.ostream) → None¶

Displays segments of PDB information, segments may or may not

be entire chains

example(s);: pose.pdb_info().show()
See Also:: PDBInfo PDBInfo.chain PDBInfo.icode PDBInfo.nres PDBInfo.number Pose Pose.pdb_info

C++: core::pose::PDBInfo::show(std::ostream &) const –> void

tag(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int) → str¶

Returns a tag for residue <res> like C:1235 (or C:QA:1235 if segment ID is present)

example(s):
pose.pdb_info().icode(3)

C++: core::pose::PDBInfo::tag(const unsigned long) const –> std::string

temperature(*args, **kwargs)¶

Overloaded function.

temperature(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int) -> float

Returns the temperature for the <atom_index> atom of pose residue <res>

example(s):
pose.pdb_info().temperature(1,1)

See also:
Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++: core::pose::PDBInfo::temperature(const unsigned long, const unsigned long) const –> const double &

temperature(self: pyrosetta.rosetta.core.pose.PDBInfo, res: int, atom_index: int, t: float) -> None

Sets the temperature of the <atom_index> atom of pose residue: <res> to <t>

C++: core::pose::PDBInfo::temperature(const unsigned long, const unsigned long, const double) –> void

tighten_memory(self: pyrosetta.rosetta.core.pose.PDBInfo) → None¶

Tightens memory usage

C++: core::pose::PDBInfo::tighten_memory() –> void

write_pdbinfo_labels(self: pyrosetta.rosetta.core.pose.PDBInfo, remark_lines: pyrosetta.rosetta.utility.vector1_std_string) → None¶

write REMARK PDBInfo-LABEL: lines for output to pose

the output container

C++: core::pose::PDBInfo::write_pdbinfo_labels(class utility::vector1<std::string, class std::allocator<std::string > > &) const –> void

class pyrosetta.rosetta.core.pose.PDBPoseMap¶

Bases: pybind11_object

PDBPoseMap can be queried with PDB information (chain, sequence position): and returns a pose’s resid position. Useful for handing input/output in terms of PDB positions. Can be tucked into the pose for repeated access, or generated just-in-time for a single use. Basically a wrapper class for std::map.
danpf.edu – In order to avoid breaking workflows I added a secondary map: that tracks the map<ResidueKey, Size> without the segmentID field being checked. This is sort of a strange if you use segmentIDs, but if you don’t you won’t notice any differences.

assign(self: pyrosetta.rosetta.core.pose.PDBPoseMap, m: pyrosetta.rosetta.core.pose.PDBPoseMap) → pyrosetta.rosetta.core.pose.PDBPoseMap¶

copy assignment

C++: core::pose::PDBPoseMap::operator=(const class core::pose::PDBPoseMap &) –> class core::pose::PDBPoseMap &

clear(self: pyrosetta.rosetta.core.pose.PDBPoseMap) → None¶

clear the current mapping data

C++: core::pose::PDBPoseMap::clear() –> void

conditional_erase(self: pyrosetta.rosetta.core.pose.PDBPoseMap, chain: str, pdb_res: int, ins_code: str, segmentID: str, pose_res: int) → bool¶

remove mapping for pdb residue key only if Pose residue matches

chain id

pdb residue numbering

insertion code, use ‘ ‘ if no insertion code

the mapped Pose residue

true if key-value pair erase, false otherwise

C++: core::pose::PDBPoseMap::conditional_erase(const char, const int, const char, const std::string &, const unsigned long) –> bool

erase(*args, **kwargs)¶

Overloaded function.

erase(self: pyrosetta.rosetta.core.pose.PDBPoseMap, chain: str, pdb_res: int, ins_code: str) -> None
erase(self: pyrosetta.rosetta.core.pose.PDBPoseMap, chain: str, pdb_res: int, ins_code: str, segmentID: str) -> None

forcibly remove mapping for pdb residue key

chain id

pdb residue numbering

insertion code, use ‘ ‘ if no insertion code

C++: core::pose::PDBPoseMap::erase(const char, const int, const char, const std::string &) –> void

fill(self: pyrosetta.rosetta.core.pose.PDBPoseMap, info: core::pose::PDBInfo) → None¶

fill with corresponding pdb -> pose residue mapping

does not clear any currently existing mapping data

C++: core::pose::PDBPoseMap::fill(const class core::pose::PDBInfo &) –> void

find(*args, **kwargs)¶

Overloaded function.

find(self: pyrosetta.rosetta.core.pose.PDBPoseMap, chain: str, pdb_res: int) -> int
find(self: pyrosetta.rosetta.core.pose.PDBPoseMap, chain: str, pdb_res: int, ins_code: str) -> int
find(self: pyrosetta.rosetta.core.pose.PDBPoseMap, chain: str, pdb_res: int, ins_code: str, segmentID: str) -> int

lookup pose numbering

chain id

pdb residue numbering

insertion code

pose numbering for residue, returns 0 if not found

this will default to return the no-segmentID version if we can’t find it!

C++: core::pose::PDBPoseMap::find(const char, const int, const char, const std::string &) const –> unsigned long

insert(self: pyrosetta.rosetta.core.pose.PDBPoseMap, chain: str, pdb_res: int, ins_code: str, segmentID: str, pose_res: int) → None¶

insert pdb -> pose number mapping

chain id

pdb residue numbering

insertion code, use ‘ ‘ if no insertion code

pose numbering for residue

if the chain is equal to the PDBInfo’s empty record character,
the insertion will be skipped

C++: core::pose::PDBPoseMap::insert(const char, const int, const char, const std::string &, const unsigned long) –> void

size(self: pyrosetta.rosetta.core.pose.PDBPoseMap) → int¶

number of mappings

C++: core::pose::PDBPoseMap::size() const –> unsigned long

class pyrosetta.rosetta.core.pose.Pose¶

Bases: pybind11_object

The Pose class represents a molecular system (protein-dna-ligand…) as a container of Rosetta Residue objects together with a Conformation object that defines how internal coordinate changes propagate through the system and an Energies object that stores information from the last energy evaluation.

The main responsibilities of the pose are:

Kinematic:

(a) to update the xyz coordinates in response to changes to internal degrees of freedom, and (b) to update internal coordinates when the user modifes the xyz (Cartesian) coords,

Scoring:

(a) to keep track of what parts of the structure have changed since the last score evaluation, and (b) to cache residue and residue-pair energies for efficient re-use

As a container:

The pose provides a single object for passing a molecular system and for copying of entire molecules or stretches of molecules from one Pose object into another.

Output Methods: Common Methods: Pose.assign Pose.atom_tree Pose.conformation Pose.dump_pdb Pose.dump_cif Pose.dump_mmtf Pose.dump_file Pose.energies Pose.fold_tree Pose.pdb_info Pose.residue Pose.sequence Pose.size

aa(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → pyrosetta.rosetta.core.chemical.AA¶

Returns the chemical::AA of the residue at <seqpos>

example(s):
pose.aa(17)

See also:
Pose

Pose.Residue
Pose.sequence Residue

C++: core::pose::Pose::aa(const unsigned long) const –> enum core::chemical::AA

add_constraint(self: pyrosetta.rosetta.core.pose.Pose, cst: core::scoring::constraints::Constraint) → core::scoring::constraints::Constraint¶

adding a constraint is done by cloning the input constraint. A const copy is then returned

C++: core::pose::Pose::add_constraint(class std::shared_ptr<const class core::scoring::constraints::Constraint>) –> class std::shared_ptr<const class core::scoring::constraints::Constraint>

add_constraints(self: pyrosetta.rosetta.core.pose.Pose, csts: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t¶

Add a list of constraints to a pose.

C++: core::pose::Pose::add_constraints(const class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > > &) –> class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > >

alpha(self: pyrosetta.rosetta.core.pose.Pose, pos: int) → float¶

Returns the alpha torsion angle of residue <seqpos>

assumes the residue is an nucleic acid

example(s):
pose.alpha(1)

See also:
Pose Pose.residue Pose.set_alpha Residue

C++: core::pose::Pose::alpha(const unsigned long) const –> double

annotated_sequence(*args, **kwargs)¶

Overloaded function.

annotated_sequence(self: pyrosetta.rosetta.core.pose.Pose) -> str
annotated_sequence(self: pyrosetta.rosetta.core.pose.Pose, show_all_variants: bool) -> str

Returns the variant-tagged string representing the

residue types that make up a conformation; e.g. M[MET:N-Terminus-Variant]CDH[HIS_D]LLR[ARG:C-Terminus-Variant]

example(s):: pose.annotated_sequence()
See also:: Pose Pose.sequence Pose.size

Residue

C++: core::pose::Pose::annotated_sequence(bool) const –> std::string

append_polymer_residue_after_seqpos(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, build_ideal_geometry: bool) → None¶

glues to seqpos and perhaps also seqpos+1

C++: core::pose::Pose::append_polymer_residue_after_seqpos(const class core::conformation::Residue &, const unsigned long, const bool) –> void

append_pose_by_jump(*args, **kwargs)¶

Overloaded function.

append_pose_by_jump(self: pyrosetta.rosetta.core.pose.Pose, src: pyrosetta.rosetta.core.pose.Pose, jump_anchor_residue: int) -> None
append_pose_by_jump(self: pyrosetta.rosetta.core.pose.Pose, src: pyrosetta.rosetta.core.pose.Pose, jump_anchor_residue: int, jump_anchor_atom: str) -> None
append_pose_by_jump(self: pyrosetta.rosetta.core.pose.Pose, src: pyrosetta.rosetta.core.pose.Pose, jump_anchor_residue: int, jump_anchor_atom: str, jump_root_atom: str) -> None

Appends source pose conformation to pose by a new jump

C++: core::pose::Pose::append_pose_by_jump(const class core::pose::Pose &, const unsigned long, const std::string &, const std::string &) –> void

append_residue_by_atoms(*args, **kwargs)¶

Overloaded function.

append_residue_by_atoms(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool, connect_atom: str, anchor_rsd_seqpos: int, anchor_connect_atom: str) -> None
append_residue_by_atoms(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool, connect_atom: str, anchor_rsd_seqpos: int, anchor_connect_atom: str, start_new_chain: bool) -> None
append_residue_by_atoms(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool, connect_atom: str, anchor_rsd_seqpos: int, anchor_connect_atom: str, start_new_chain: bool, lookup_bond_length: bool) -> None

Appends <new_rsd> (a residue) to pose by a new bond to a given atom

This function effectively wraps append_residue_by_bond for an easier syntax. Instead of having to know what the connection, anchor residue, and anchor connection are, we give the atoms and query the ResidueType for the remaining information.

If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond geometry of the new bond is ideal according to the icoor_internal data in the residues.

Otherwise the incoming coordinates of new_rsd are preserved.

C++: core::pose::Pose::append_residue_by_atoms(const class core::conformation::Residue &, const bool, const std::string &, const unsigned long, const std::string &, const bool, const bool) –> void

append_residue_by_bond(*args, **kwargs)¶

Overloaded function.

append_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue) -> None
append_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool) -> None
append_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool, connection: int) -> None
append_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool, connection: int, anchor_residue: int) -> None
append_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool, connection: int, anchor_residue: int, anchor_connection: int) -> None
append_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool, connection: int, anchor_residue: int, anchor_connection: int, start_new_chain: bool) -> None
append_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, build_ideal_geometry: bool, connection: int, anchor_residue: int, anchor_connection: int, start_new_chain: bool, lookup_bond_length: bool) -> None

Appends <new_rsd> (a residue) to pose by a new bond

The default behavior is to append by a polymeric connection to the preceding residue If we want to connect via a non-polymer connection, we give the connection number, anchor residue and the connection number for the anchor residue. These connection numbers are wrt the connections_ arrays in Residue and ResidueType

If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond geometry of the new bond is ideal according to the icoor_internal data in the residues.

Otherwise the incoming coordinates of new_rsd are preserved.

C++: core::pose::Pose::append_residue_by_bond(const class core::conformation::Residue &, const bool, const int, const unsigned long, const int, const bool, const bool) –> void

append_residue_by_jump(*args, **kwargs)¶

Overloaded function.

append_residue_by_jump(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, jump_anchor_residue: int) -> None
append_residue_by_jump(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, jump_anchor_residue: int, jump_anchor_atom: str) -> None
append_residue_by_jump(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, jump_anchor_residue: int, jump_anchor_atom: str, jump_root_atom: str) -> None
append_residue_by_jump(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, jump_anchor_residue: int, jump_anchor_atom: str, jump_root_atom: str, start_new_chain: bool) -> None

Appends <new_rsd> (a residue) to pose by a new jump

C++: core::pose::Pose::append_residue_by_jump(const class core::conformation::Residue &, const unsigned long, const std::string &, const std::string &, const bool) –> void

append_residues(self: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_conformation_Residue_t, jump_connection: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶

Convenience function to add a bunch of residues at once to the end of the pose: jump_connection lists the residue (in the new pose) to which to attach the residue by jump a value of 0 for jump_connection means that the residue will be attached polymerically to the previous residue.

C++: core::pose::Pose::append_residues(const class utility::vector1<class std::shared_ptr<class core::conformation::Residue>, class std::allocator<class std::shared_ptr<class core::conformation::Residue> > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

apply_transform(xform)¶

Apply a homogeneous transform to the current pose.

Args:: xform (np.ndarray): A homogeneous transform.

apply_transform_Rx_plus_v(self: pyrosetta.rosetta.core.pose.Pose, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶

Apply a transform of the Rx + v form, where R is a: rotation matrix and v is a translation vector.

C++: core::pose::Pose::apply_transform_Rx_plus_v(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &) –> void

assign(self: pyrosetta.rosetta.core.pose.Pose, src: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pose.Pose¶

Copies <src> into the pose where it remains possible that two

Poses may point to each other in non-const ways or share non-bitwise constant data between them (E.g. the AtomTree observer system).

example(s):: test_pose.assign(pose)
See also:: Pose

C++: core::pose::Pose::operator=(const class core::pose::Pose &) –> class core::pose::Pose &

atom_tree(self: pyrosetta.rosetta.core.pose.Pose) → core::kinematics::AtomTree¶

Returns the pose AtomTree

C++: core::pose::Pose::atom_tree() const –> const class core::kinematics::AtomTree &

batch_get_xyz(self: pyrosetta.rosetta.core.pose.Pose, ids: pyrosetta.rosetta.utility.vector1_core_id_AtomID, points: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t) → None¶

Gets the locations (xyz) of pose AtomIDs in <ids>

C++: core::pose::Pose::batch_get_xyz(const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &) const –> void

batch_set_xyz(self: pyrosetta.rosetta.core.pose.Pose, ids: pyrosetta.rosetta.utility.vector1_core_id_AtomID, points: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t) → None¶

Sets the locations (xyz) of pose AtomIDs in <ids>: to mathcing PointPositions in <points>

C++: core::pose::Pose::batch_set_xyz(const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, const class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &) –> void

beta(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the beta torsion angle of residue <seqpos>

assumes the residue is an nucleic acid

example(s):
pose.beta(2)

See also:
Pose Pose.residue Pose.set_beta Residue

C++: core::pose::Pose::beta(const unsigned long) const –> double

center(self: pyrosetta.rosetta.core.pose.Pose) → None¶

Sets pose coordinates such that the pose center is at the Euclidean origin

C++: core::pose::Pose::center() –> void

chain(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → int¶

Returns the chain number of residue <seqpos>

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):
pose.chain(3)

see also:
pose pose.num_chains pose.annotated_sequence

pose.chain_sequence
pose.fold_tree pose.sequence foldtree

C++: core::pose::Pose::chain(const unsigned long) const –> unsigned long

chain_begin(self: pyrosetta.rosetta.core.pose.Pose, chain_num: int) → int¶

Returns the sequence position of the beginning of chain <chain_num>.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps. This is a pass-through function which returns conformation_->chain_begin( chain_num )

example(s):
pose.chain_begin(1)

see also:
pose pose.num_chains pose.annotated_sequence

pose.chain_sequence
pose.fold_tree pose.sequence foldtree

C++: core::pose::Pose::chain_begin(const unsigned long) const –> unsigned long

chain_end(self: pyrosetta.rosetta.core.pose.Pose, chain_num: int) → int¶

Returns the sequence position of the end of chain <chain_num>.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps. This is a pass-through function which returns conformation_->chain_end( chain_num )

example(s):
pose.chain_end(1)

see also:
pose pose.num_chains pose.annotated_sequence

pose.chain_sequence
pose.fold_tree pose.sequence foldtree

C++: core::pose::Pose::chain_end(const unsigned long) const –> unsigned long

chain_sequence(self: pyrosetta.rosetta.core.pose.Pose, chain_in: int) → str¶

Returns the sequence for the chain number <chain_in>

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

Example(s):
pose.chain_sequence(1)

See also:
Pose Pose.chain Pose.residue Pose.sequence

C++: core::pose::Pose::chain_sequence(const unsigned long) const –> std::string

chi(*args, **kwargs)¶

Overloaded function.

chi(self: pyrosetta.rosetta.core.pose.Pose, chino: int, seqpos: int) -> float

Returns the <chino> chi torsion angle of residue <seqpos>

assumes the residue is an amino acid or monosaccharide

example(s):
pose.chi(1,7)

See also:
Pose Pose.set_chi Pose.residue Residue

C++: core::pose::Pose::chi(const int, const unsigned long) const –> double

chi(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) -> float

Returns the chi torsion angle of residue <seqpos>

assumes the residue is an nucleic acid

example(s):
pose.chi(7)

See also:
Pose Pose.residue Pose.set_chi Residue

C++: core::pose::Pose::chi(const unsigned long) const –> double

clear(self: pyrosetta.rosetta.core.pose.Pose) → None¶

Empty the pose contents

example(s):
pose.clear()

See also:
Pose Pose.assign Pose.empty

C++: core::pose::Pose::clear() –> void

clear_sequence_constraints(self: pyrosetta.rosetta.core.pose.Pose) → None¶

Remove all sequence constraints from this pose.

C++: core::pose::Pose::clear_sequence_constraints() –> void

clone(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pose.Pose¶

clone the conformation

C++: core::pose::Pose::clone() const –> class std::shared_ptr<class core::pose::Pose>

conformation(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.conformation.Conformation¶

Returns the pose Conformation (non-const access)

C++: core::pose::Pose::conformation() –> class core::conformation::Conformation &

conformation_ptr(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.conformation.Conformation¶

Returns the pose Conformation pointer (nonconst access)

WHOA: This is not cool. The Pose cannot hand out access to the OP directly. Do not use.

C++: core::pose::Pose::conformation_ptr() –> class std::shared_ptr<class core::conformation::Conformation> &

const_data_cache(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.basic.datacache.ConstDataMap¶

Read access to the const data cache

C++: core::pose::Pose::const_data_cache() const –> const class basic::datacache::ConstDataMap &

constraint_set(*args, **kwargs)¶

Overloaded function.

constraint_set(self: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet

C++: core::pose::Pose::constraint_set() const –> class std::shared_ptr<const class core::scoring::constraints::ConstraintSet>

constraint_set(self: pyrosetta.rosetta.core.pose.Pose, : core::scoring::constraints::ConstraintSet) -> None

C++: core::pose::Pose::constraint_set(class std::shared_ptr<class core::scoring::constraints::ConstraintSet>) –> void

copy_segment(self: pyrosetta.rosetta.core.pose.Pose, size: int, src: pyrosetta.rosetta.core.pose.Pose, begin: int, src_begin: int) → None¶

Copy a stretch of coordinates/torsions from <src>: to pose

C++: core::pose::Pose::copy_segment(const unsigned long, const class core::pose::Pose &, const unsigned long, const unsigned long) –> void

corresponding_residue_in_current(self: pyrosetta.rosetta.core.pose.Pose, ref_residue_index: int, ref_pose_name: str) → int¶

Returns the index of a residue in this pose corresponding to a residue in a reference pose.

Throws an error if the reference pose with the given name doesn’t exist, or the residue number doesn’t exist in that reference pose. Returns zero if no corresponding residue exists in this pose (e.g. if the residue in question has been deleted.

C++: core::pose::Pose::corresponding_residue_in_current(const unsigned long, const std::string &) const –> unsigned long

data(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.basic.datacache.BasicDataCache¶

BasicDataCache indexed by enum in core/pose/datacache/CacheableDataType.hh

C++: core::pose::Pose::data() –> class basic::datacache::BasicDataCache &

decrement_reference_pose_mapping_after_seqpos(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶

Find all mappings in the new pose after seqpos in all ReferencePose objects, and decrement them by 1.

If there is no ReferencePose object, do nothing.

C++: core::pose::Pose::decrement_reference_pose_mapping_after_seqpos(const unsigned long) –> void

delete_polymer_residue(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶

Delete a residue in the pose.: Update Observers. Update any Reference Poses

C++: core::pose::Pose::delete_polymer_residue(const unsigned long) –> void

delete_residue_range_slow(self: pyrosetta.rosetta.core.pose.Pose, start: int, end: int) → None¶

Delete a range of residues in the pose.

Calls confromation::delete_residue_range_slow().
Update Observers. Update any Reference Poses

C++: core::pose::Pose::delete_residue_range_slow(const unsigned long, const unsigned long) –> void

delete_residue_slow(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶

Slow method that relies on FoldTree::delete_seqpos, rebuilds atomtree, can handle jumps/root residue.: Update Observers. Update any Reference Poses

C++: core::pose::Pose::delete_residue_slow(const unsigned long) –> void

delta(self: pyrosetta.rosetta.core.pose.Pose, pos: int) → float¶

Returns the delta torsion angle of residue <seqpos>

assumes the residue is an nucleic acid

example(s):
pose.delta(4)

See also:
Pose Pose.residue Pose.set_delta Residue

C++: core::pose::Pose::delta(const unsigned long) const –> double

detached_copy(self: pyrosetta.rosetta.core.pose.Pose, src: pyrosetta.rosetta.core.pose.Pose) → None¶

Performs a deep copy of the src Pose into this Pose in a way: that guarantees that no non-bitwise-constant data is shared between them (such as the AtomTree’s observer system) – this Pose will be effectively detached from any data that lives in other objects.

C++: core::pose::Pose::detached_copy(const class core::pose::Pose &) –> void

display_secstruct(space=8, page=80)¶

Use DSSP to assign secondary structure codes to each residue in a Pose, store the result in the Pose, and display the result.

Args:

space (int): Spacing of residue number labels in display.: Defaults to 8.
page (int): Number of characters per line in dispaly.: Defaults to 80.

dof(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.DOF_ID) → float¶

Returns the value of the AtomTree DOF <id>

See also:
Pose DOF_ID

C++: core::pose::Pose::dof(const class core::id::DOF_ID &) const –> double

dump_cif(self: pyrosetta.rosetta.core.pose.Pose, file_name: str) → None¶

Export pose data to the mmCIF file <file_name>

example(s):
pose.dump_cif(‘new_01.cif’)

See also:
Pose pose_from_cif dump_file

C++: core::pose::Pose::dump_cif(const std::string &) const –> void

dump_file(self: pyrosetta.rosetta.core.pose.Pose, file_name: str) → None¶

Export pose data to a file, <file_name>, determining which type of file format to write based on the file extension

example(s):
pose.dump_file(‘new_01.pdb’) pose.dump_file(‘new_01.cif’)

See also:
Pose dump_cif dump_mmtf dump_file

C++: core::pose::Pose::dump_file(const std::string &) const –> void

dump_mmtf(self: pyrosetta.rosetta.core.pose.Pose, file_name: str) → None¶

Export pose data to the mmtf file <file_name>

example(s):
pose.dump_mmtf(‘new_01.mmtf’)

See also:
Pose pose_from_mmtf dump_file

C++: core::pose::Pose::dump_mmtf(const std::string &) const –> void

dump_pdb(*args, **kwargs)¶

Overloaded function.

dump_pdb(self: pyrosetta.rosetta.core.pose.Pose, file_name: str) -> bool

Export pose data to the PDB file <file_name>

example(s):
pose.dump_pdb(‘new_01.pdb’)

See also:
Pose pose_from_pdb dump_cif dump_file

C++: core::pose::Pose::dump_pdb(const std::string &) const –> bool

dump_pdb(self: pyrosetta.rosetta.core.pose.Pose, out: pyrosetta.rosetta.std.ostream) -> None

C++: core::pose::Pose::dump_pdb(std::ostream &) const –> void

dump_pdb(self: pyrosetta.rosetta.core.pose.Pose, out: pyrosetta.rosetta.std.ostream, residue_indices: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

for writing a specified subset of residues in pdb format

C++: core::pose::Pose::dump_pdb(std::ostream &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> void

dump_scored_pdb(self: pyrosetta.rosetta.core.pose.Pose, file_name: str, scorefxn: core::scoring::ScoreFunction) → None¶

Export pose data to the PDB file <file_name>,: add some score output

C++: core::pose::Pose::dump_scored_pdb(const std::string &, const class core::scoring::ScoreFunction &) –> void

empty(self: pyrosetta.rosetta.core.pose.Pose) → bool¶

Returns true if there are no residues in the conformation

example(s):
pose.empty()

See also:
Pose Pose.clear

Pose.sequence
Pose.size

C++: core::pose::Pose::empty() const –> bool

energies(self: pyrosetta.rosetta.core.pose.Pose) → core::scoring::Energies¶

Returns the pose Energies (non-const access)

C++: core::pose::Pose::energies() –> class core::scoring::Energies &

epsilon(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the epsilon torsion angle of residue <seqpos>

assumes the residue is an nucleic acid

example(s):
pose.epsilon(5)

See also:
Pose Pose.residue Pose.set_epsilon Residue

C++: core::pose::Pose::epsilon(const unsigned long) const –> double

fold_tree(*args, **kwargs)¶

Overloaded function.

fold_tree(self: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.kinematics.FoldTree

Returns the pose FoldTree

example(s):
pose.fold_tree()

See also:
Pose FoldTree

C++: core::pose::Pose::fold_tree() const –> const class core::kinematics::FoldTree &

fold_tree(self: pyrosetta.rosetta.core.pose.Pose, fold_tree_in: pyrosetta.rosetta.core.kinematics.FoldTree) -> None

Sets the pose FoldTree to <fold_tree_in>

example(s):
pose.fold_tree( foldtree )

See also:
Pose pose.fold_tree FoldTree

C++: core::pose::Pose::fold_tree(const class core::kinematics::FoldTree &) –> void

gamma(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the gamma torsion angle of residue <seqpos>

assumes the residue is an nucleic acid

example(s):
pose.gamma(3)

See also:
Pose Pose.residue Pose.set_gamma Residue

C++: core::pose::Pose::gamma(const unsigned long) const –> double

get_hbonds(calculate_derivative=False, exclude_bb=False, exclude_bsc=False, exclude_scb=False, exclude_sc=False)¶

Return the HBondSet for all hydrogen bonds in the Pose.

Args:

caclulate_derivative (bool): Defaults to False. exclube_bb (bool): Exclude backbone hydrogen bonds from the returned HBondSet.

Defaults to False.

exclube_bsc (bool): Exclude backbone–side-chain hydrogen bonds from the returned HBondSet.: Defaults to False.
exclube_scb (bool): Exclude side-chain–backbone hydrogen bonds from the returned HBondSet.: Defaults to False.
exclube_sc (bool): Exclude side-chain hydrogen bonds from the returned HBondSet.: Defaults to False.

Returns:

pyrosetta.rosetta.core.scoring.hbonds.HBondSet: THe selected hydrogen bonds in the Pose.

get_self_ptr(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pose.Pose¶: C++: core::pose::Pose::get_self_ptr() –> class std::shared_ptr<class core::pose::Pose>

get_self_weak_ptr(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.weak_ptr_core_pose_Pose_t¶: C++: core::pose::Pose::get_self_weak_ptr() –> class std::weak_ptr<class core::pose::Pose>

glycan_tree_branch_sequence(self: pyrosetta.rosetta.core.pose.Pose, start_residue: int) → str¶

Return the IUPAC sequence of a single branch of a glycan tree,: Beginning with residue number <start_residue>.

C++: core::pose::Pose::glycan_tree_branch_sequence(const unsigned long) const –> std::string

glycan_tree_sequence(self: pyrosetta.rosetta.core.pose.Pose, residue_in_tree: int) → str¶

Return the IUPAC sequence of the entire glycan tree encompassing residue number <residue_in_tree>.

C++: core::pose::Pose::glycan_tree_sequence(const unsigned long) const –> std::string

glycan_tree_set(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.conformation.carbohydrates.GlycanTreeSet¶

Get information on any glycan trees within this pose.

If this is not setup, will return a nullptr due to the const nature of the function.

The GlycanTreeSet holds information on the connectivity of the glycan residues and if: they are free or attached to a pose.
example(s):: pose.glycan_tree_set() conformation.glycan_tree_set()
See also:: pose.residue(3).is_carbohydrate() pose.residue(3).carbohydrate_info()

C++: core::pose::Pose::glycan_tree_set() const –> class std::shared_ptr<const class core::conformation::carbohydrates::GlycanTreeSet>

has_dof(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.DOF_ID) → bool¶

Returns true if pose has DOF <id>

See also:
Pose DOF_ID

C++: core::pose::Pose::has_dof(const class core::id::DOF_ID &) const –> bool

has_reference_pose(self: pyrosetta.rosetta.core.pose.Pose) → bool¶

Returns true if a pose has at least one reference pose, false otherwise.

C++: core::pose::Pose::has_reference_pose() const –> bool

increment_reference_pose_mapping_after_seqpos(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶

Find all mappings in the new pose after seqpos in all ReferencePose objects, and increment them by 1.

If there is no ReferencePose object, do nothing.

C++: core::pose::Pose::increment_reference_pose_mapping_after_seqpos(const unsigned long) –> void

insert_residue_by_atoms(*args, **kwargs)¶

Overloaded function.

insert_residue_by_atoms(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, build_ideal_geometry: bool, connect_atom: str, anchor_rsd_seqpos: int) -> None
insert_residue_by_atoms(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, build_ideal_geometry: bool, connect_atom: str, anchor_rsd_seqpos: int, anchor_connect_atom: str) -> None
insert_residue_by_atoms(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, build_ideal_geometry: bool, connect_atom: str, anchor_rsd_seqpos: int, anchor_connect_atom: str, start_new_chain: bool) -> None
insert_residue_by_atoms(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, build_ideal_geometry: bool, connect_atom: str, anchor_rsd_seqpos: int, anchor_connect_atom: str, start_new_chain: bool, lookup_bond_length: bool) -> None

C++: core::pose::Pose::insert_residue_by_atoms(const class core::conformation::Residue &, const unsigned long, const bool, const std::string &, const unsigned long, const std::string &, const bool, const bool) –> void

insert_residue_by_bond(*args, **kwargs)¶

Overloaded function.

insert_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int) -> None
insert_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int, build_ideal_geometry: bool) -> None
insert_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int, build_ideal_geometry: bool, anchor_atom: str) -> None
insert_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int, build_ideal_geometry: bool, anchor_atom: str, root_atom: str) -> None
insert_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int, build_ideal_geometry: bool, anchor_atom: str, root_atom: str, new_chain: bool) -> None
insert_residue_by_bond(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int, build_ideal_geometry: bool, anchor_atom: str, root_atom: str, new_chain: bool, lookup_bond_length: bool) -> None

This code sorely belongs in Pose.cc

Adds <new_rsd_in> to pose at <seqpos>

C++: core::pose::Pose::insert_residue_by_bond(const class core::conformation::Residue &, const unsigned long, unsigned long, const bool, const std::string &, const std::string &, bool, const bool) –> void

insert_residue_by_jump(*args, **kwargs)¶

Overloaded function.

insert_residue_by_jump(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int) -> None
insert_residue_by_jump(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int, anchor_atomno: str) -> None
insert_residue_by_jump(self: pyrosetta.rosetta.core.pose.Pose, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, anchor_pos: int, anchor_atomno: str, root_atomno: str) -> None

This code sorely belongs in Pose.cc

Adds <new_rsd_in> to pose at <seqpos>

C++: core::pose::Pose::insert_residue_by_jump(const class core::conformation::Residue &, const unsigned long, unsigned long, const std::string &, const std::string &) –> void

is_centroid(self: pyrosetta.rosetta.core.pose.Pose) → bool¶

Returns true if pose is ResidueType centroid

convenience test for residue_type_set

example(s):
pose.is_centroid()

See also:
Pose Pose.is_fullatom Residue ResidueType

C++: core::pose::Pose::is_centroid() const –> bool

is_fullatom(self: pyrosetta.rosetta.core.pose.Pose) → bool¶

Returns true if pose is ResidueType fullatom

convenience test for residue_type_set

example(s):
pose.is_fullatom()

See also:
Pose Pose.is_centroid Residue ResidueType

C++: core::pose::Pose::is_fullatom() const –> bool

jump(*args, **kwargs)¶

Overloaded function.

jump(self: pyrosetta.rosetta.core.pose.Pose, jump_number: int) -> core::kinematics::Jump

Returns the pose FoldTree Jump <jump_number>

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):
pose.jump(1)

See also:
Pose Pose.fold_tree Pose.set_jump FoldTree FoldTree.jump_edge Jump

C++: core::pose::Pose::jump(const int) const –> const class core::kinematics::Jump &

jump(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.AtomID) -> core::kinematics::Jump

Returns the pose FoldTree Jump <id>

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):
pose.set_jump(R5N)

See also:
Pose Pose.fold_tree Pose.set_jump FoldTree FoldTree.jump_edge AtomID

C++: core::pose::Pose::jump(const class core::id::AtomID &) const –> const class core::kinematics::Jump &

membrane_info(self: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.conformation.membrane.MembraneInfo¶

Get information about the membrane orientaiton, geometry, and

lipid composition within this pose

MembraneInfo contains all information pertaining to the conformation and composition of a membrane enviornment

example(s):: pose.membrane_info() conformation.membrane_info()

C++: core::pose::Pose::membrane_info() –> class std::shared_ptr<class core::conformation::membrane::MembraneInfo>

metric(self: pyrosetta.rosetta.core.pose.Pose, calculator_name: str, key: str, val: pyrosetta.rosetta.basic.MetricValueBase) → None¶: C++: core::pose::Pose::metric(const std::string &, const std::string &, class basic::MetricValueBase &) const –> void

mu(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the mu torsion angle of oligourea residue <seqpos>.

Mu is defined as CM(n)-NU(n)-C(n)-N(n+1) for an oligourea.

Assumes residue is an oligourea.

example(s):
pose.mu(21)

See also:
Pose Pose.set_mu Pose.residue Residue

Vikram K. Mulligan (vmullig.edu)

C++: core::pose::Pose::mu(const unsigned long) const –> double

num_chains(self: pyrosetta.rosetta.core.pose.Pose) → int¶

example(s):

pose.num_chains()

see also:: pose pose.chain pose.annotated_sequence
pose.chain_sequence: pose.fold_tree pose.sequence foldtree

C++: core::pose::Pose::num_chains() const –> unsigned long

num_jump(self: pyrosetta.rosetta.core.pose.Pose) → int¶

Returns the number of jumps in the pose FoldTree

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):
pose.num_jump()

See also:
Pose Pose.jump Pose.set_jump FoldTree Jump

C++: core::pose::Pose::num_jump() const –> unsigned long

observer_cache(self: pyrosetta.rosetta.core.pose.Pose) → core::pose::datacache::ObserverCache¶

ObserverCache indexed by enum in core/pose/datacache/CacheableObserverType.hh

C++: core::pose::Pose::observer_cache() –> class core::pose::datacache::ObserverCache &

omega(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the omega torsion angle of residue <seqpos> in degrees

assumes the residue is an amino acid or monosaccharide

example(s):
pose.omega(3)

See also:
Pose Pose.residue Pose.set_omega Residue

C++: core::pose::Pose::omega(const unsigned long) const –> double

pdb_info(*args, **kwargs)¶

Overloaded function.

pdb_info(self: pyrosetta.rosetta.core.pose.Pose) -> core::pose::PDBInfo

Returns the pose PDBInfo

NULL if no PDBInfo instance exists, the PDBInfo instance otherwise

C++: core::pose::Pose::pdb_info() –> class std::shared_ptr<class core::pose::PDBInfo>

pdb_info(self: pyrosetta.rosetta.core.pose.Pose, new_info: core::pose::PDBInfo) -> core::pose::PDBInfo

Sets pose PDBInfo to <new_info>

the new PDBInfo to copy, pass NULL

if you want to zero the existence of PDBInfo inside this Pose

the prior PDBInfo instance

C++: core::pose::Pose::pdb_info(class std::shared_ptr<class core::pose::PDBInfo>) –> class std::shared_ptr<class core::pose::PDBInfo>

pdb_rsd(chain_and_resNo)¶

Look up a specific PDB-numbered residue and return it.

Args:

chain_and_resNo (tuple): a tuple representing the PDB description of the residue: in the format (chainID, resNo). For example, residue 1 on chain A would be (“A”, 1).

Returns:

pyrosetta.core.conformation.Residue or None: the Residue instance in the Pose. returns None if the PDB residue identifier is invalid.

phi(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the phi torsion angle of residue <seqpos> in degrees

assumes the residue is an amino acid or monosaccharide

example(s):
pose.phi(1)

See also:
Pose Pose.residue Pose.set_phi Residue

C++: core::pose::Pose::phi(const unsigned long) const –> double

prepend_polymer_residue_before_seqpos(self: pyrosetta.rosetta.core.pose.Pose, new_rsd: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, build_ideal_geometry: bool) → None¶

glues to seqpos and perhaps also seqpos-1

C++: core::pose::Pose::prepend_polymer_residue_before_seqpos(const class core::conformation::Residue &, const unsigned long, const bool) –> void

print_metric(self: pyrosetta.rosetta.core.pose.Pose, calculator_name: str, key: str) → str¶: C++: core::pose::Pose::print_metric(const std::string &, const std::string &) const –> std::string

psi(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the psi torsion angle of residue <seqpos> in degrees

Note: assumes the residue is an amino acid or monosaccharide

example(s):: pose.psi(2)
See also:: Pose Pose.residue Pose.set_psi Residue

C++: core::pose::Pose::psi(const unsigned long) const –> double

real_to_virtual(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶

Switch residues to VIRTUAL

VIRTUAL residues are the same except not SCORED or DUMPED.

example(s):
pose.real_to_virtual(3)

See also:
Pose ResidueType

C++: core::pose::Pose::real_to_virtual(unsigned long) –> void

reference_pose_from_current(*args, **kwargs)¶

Overloaded function.

reference_pose_from_current(self: pyrosetta.rosetta.core.pose.Pose, ref_pose_name: str) -> None
reference_pose_from_current(self: pyrosetta.rosetta.core.pose.Pose, ref_pose_name: str, override_current: bool) -> None

Create a new reference pose from the current state of the pose.

If a ReferencePoseSet object does not exist, this function will create it.
If override_current is set to true, will override any currently set reference pose with the ref_pose_name.

C++: core::pose::Pose::reference_pose_from_current(const std::string &, bool) –> void

reference_pose_set(self: pyrosetta.rosetta.core.pose.Pose) → core::pose::reference_pose::ReferencePoseSet¶

Access the ReferencePoseSet object (non-const).

If a ReferencePoseSet object does not exist, this function will create it.

C++: core::pose::Pose::reference_pose_set() –> class std::shared_ptr<class core::pose::reference_pose::ReferencePoseSet>

reference_pose_set_cop(self: pyrosetta.rosetta.core.pose.Pose) → core::pose::reference_pose::ReferencePoseSet¶

Const-access the ReferencePoseSet object.

If a ReferencePoseSet object does not exist, this function will throw an error.

C++: core::pose::Pose::reference_pose_set_cop() const –> class std::shared_ptr<const class core::pose::reference_pose::ReferencePoseSet>

remove_constraint(*args, **kwargs)¶

Overloaded function.

remove_constraint(self: pyrosetta.rosetta.core.pose.Pose, cst: core::scoring::constraints::Constraint) -> bool
remove_constraint(self: pyrosetta.rosetta.core.pose.Pose, cst: core::scoring::constraints::Constraint, object_comparison: bool) -> bool

re object_comparison see comment for ConstraintSet::remove_constraint function

C++: core::pose::Pose::remove_constraint(class std::shared_ptr<const class core::scoring::constraints::Constraint>, bool) –> bool

remove_constraints(*args, **kwargs)¶

Overloaded function.

remove_constraints(self: pyrosetta.rosetta.core.pose.Pose, csts: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> bool
remove_constraints(self: pyrosetta.rosetta.core.pose.Pose, csts: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, object_comparison: bool) -> bool

re object_comparison see comment for ConstraintSet::remove_constraint function

C++: core::pose::Pose::remove_constraints(class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > >, bool) –> bool

remove_constraints(self: pyrosetta.rosetta.core.pose.Pose) -> bool

C++: core::pose::Pose::remove_constraints() –> bool

replace_residue(*args, **kwargs)¶

Overloaded function.

replace_residue(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, orient_backbone: bool) -> None

Replaces the residue at <seqpos> with <new_rsd_in>

C++: core::pose::Pose::replace_residue(const unsigned long, const class core::conformation::Residue &, const bool) –> void

replace_residue(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, new_rsd_in: pyrosetta.rosetta.core.conformation.Residue, atom_pairs: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_string_t) -> None

Replaces the residue at <seqpos> with <new_rsd>: based on superposition on the specified input atom pairs NOTE: at the moment, only superposition on 3 atoms works This code sorely belongs in Pose.cc

C++: core::pose::Pose::replace_residue(const int, const class core::conformation::Residue &, const class utility::vector1<struct std::pair<std::string, std::string >, class std::allocator<struct std::pair<std::string, std::string > > > &) –> void

residue(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → pyrosetta.rosetta.core.conformation.Residue¶

Returns the Residue at position <seqpos> (read access)

Note: this method will trigger a refold if either the torsions or the coordinates are out-of-date

example(s):: pose.residue(4)
See also:: Pose Pose.sequence Pose.size Residue ResidueType

C++: core::pose::Pose::residue(const unsigned long) const –> const class core::conformation::Residue &

residue_data(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → pyrosetta.rosetta.basic.datacache.BasicDataCache¶

Returns the DataCache held by Residue at position <seqpos> (read/write access)

Note: this method will trigger a refold if either the torsions or the coordinates are out-of-date

example(s):: pose.residue_data(4)
See also:: Pose Pose.residue Pose.sequence Pose.size Residue ResidueType

C++: core::pose::Pose::residue_data(const unsigned long) –> class basic::datacache::BasicDataCache &

residue_pairs(primary_residue_selector=<pyrosetta.rosetta.core.select.residue_selector.TrueResidueSelector object>, secondary_residue_selector=<pyrosetta.rosetta.core.select.residue_selector.TrueResidueSelector object>, neighborhood_distance_maximum=None, sequence_distance_minimum=None)¶

Iterate the permutations of residue pairs from two selections which are within a cartesian and/or outside a sequence distance cutoff.

The method uses the PrimarySequenceNeighborhoodSelector and NeighborhoodResidueSelector under the hood. Note that all _permutations_ of residues are yielded, not _combinations_. If you prefer combinations simply check if residue_pair[0].sequence_position() > residue_pair[1].sequence_position():.

primary_residue_selector - ResidueSelector secondary_residue_selector - ResidueSelector neighborhood_distance - float sequence_distance - int

return - iterator(tuple(Residue, Residue))

residue_type(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → pyrosetta.rosetta.core.chemical.ResidueType¶

Returns the ResidueType at position <seqpos> (read access)

Note: this method NOT will trigger a refold if either the torsions or the coordinates are out-of-date

example(s):: pose.residue_type(5)
See also:: Pose Pose.residue Pose.residue_type_ptr Pose.sequence Pose.size Residue ResidueType

C++: core::pose::Pose::residue_type(const unsigned long) const –> const class core::chemical::ResidueType &

residue_type_ptr(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → pyrosetta.rosetta.core.chemical.ResidueType¶

Returns the ResidueTypeCOP for position <seqpos> (read access)

Note: this method NOT will trigger a refold if either the torsions or the coordinates are out-of-date

example(s):: pose.residue_type_ptr(5)
See also:: Pose Pose.residue Pose.residue_type Pose.sequence Pose.size Residue ResidueType

C++: core::pose::Pose::residue_type_ptr(const unsigned long) const –> class std::shared_ptr<const class core::chemical::ResidueType>

residue_type_set_for_pose(*args, **kwargs)¶

Overloaded function.

residue_type_set_for_pose(self: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.chemical.ResidueTypeSet
residue_type_set_for_pose(self: pyrosetta.rosetta.core.pose.Pose, mode: pyrosetta.rosetta.core.chemical.TypeSetMode) -> pyrosetta.rosetta.core.chemical.ResidueTypeSet

Return the custom ResidueTypeSet for the Pose, if any.

Otherwise will return the appropriate global ResidueTypeSet

If mode is INVALID_t (the default), the returned ResidueTypeSet is the one corresponding to the majority of the residues in the Pose. i.e. FULL_ATOM if pose.is_fullatom(); CENTROID if pose.is_centriod()

examples(s):: pose.residue_type_set_for_pose() pose.residue_type_set_for_pose( core::chemical::CENTROID_t )
See also:: Pose Pose.is_fullatom Pose.is_centroid ResidueTypeSet

C++: core::pose::Pose::residue_type_set_for_pose(enum core::chemical::TypeSetMode) const –> class std::shared_ptr<const class core::chemical::ResidueTypeSet>

property residues¶

property reslabels¶

rotate(R)¶

Apply a rotation matrix to all of the coordinates in a Pose.

Args:: p (Pose): The Pose instance to manipulate R (np.mat): A rotation matrix to apply to the Pose coordinates

property scores¶

scoring_begin(self: pyrosetta.rosetta.core.pose.Pose, info: core::scoring::ScoreFunction) → None¶

Called by ScoreFunction at the beginning of scoring

C++: core::pose::Pose::scoring_begin(const class core::scoring::ScoreFunction &) –> void

scoring_end(self: pyrosetta.rosetta.core.pose.Pose, scorefxn: core::scoring::ScoreFunction) → None¶

Called by ScoreFunction at the end of scoring

C++: core::pose::Pose::scoring_end(const class core::scoring::ScoreFunction &) –> void

secstruct(*args, **kwargs)¶

Overloaded function.

secstruct(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) -> str

Returns the secondary structure of residue <seqpos>

this usually comes from fragments. The conformation object will not invoke DSSP to determine the secondary structure if e.g. it has not been made from fragments. ‘H’ = helical ‘E’ = strand or sheet ‘L’ = loop

example(s):: pose.secstruct(3)
See also:: Pose Pose.residue Pose.set_secstruct Residue

C++: core::pose::Pose::secstruct(const unsigned long) const –> char

secstruct(self: pyrosetta.rosetta.core.pose.Pose) -> str

Returns a string representing pose secondary structure

example(s):
pose.secstruct()

See also:
Pose Pose.residue Pose.set_secstruct Residue

C++: core::pose::Pose::secstruct() const –> std::string

sequence(*args, **kwargs)¶

Overloaded function.

sequence(self: pyrosetta.rosetta.core.pose.Pose) -> str

Returns a string representing the 1-letter-coded sequence of the pose conformation.

example(s):
pose.sequence()

See also:
Pose Pose.annotated_sequence Pose.chain Pose.chain_sequence Pose.residue Pose.size

C++: core::pose::Pose::sequence() const –> std::string

sequence(self: pyrosetta.rosetta.core.pose.Pose, resnum_start: int, resnum_end: int) -> str

Returns a string representing the 1-letter-coded sequence of the pose conformation. From start to end.

example(s):
pose.sequence()

See also:
Pose Pose.annotated_sequence Pose.chain Pose.chain_sequence Pose.residue Pose.size

C++: core::pose::Pose::sequence(unsigned long, unsigned long) const –> std::string

set_alpha(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the alpha torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an nucleic acid

example(s):
pose.set_alpha(1)

See also:
Pose Pose.alpha Pose.residue Residue

C++: core::pose::Pose::set_alpha(const unsigned long, const double) –> void

set_beta(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the beta torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an nucleic acid

example(s):
pose.set_beta(2)

See also:
Pose Pose.beta Pose.residue Residue

C++: core::pose::Pose::set_beta(const unsigned long, const double) –> void

set_chi(*args, **kwargs)¶

Overloaded function.

set_chi(self: pyrosetta.rosetta.core.pose.Pose, chino: int, seqpos: int, setting: float) -> None

Sets the <chino> chi torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an amino acid or monosaccharide

example(s):
pose.set_chi(1,7,120)

See also:
Pose Pose.chi Pose.residue Residue

C++: core::pose::Pose::set_chi(const int, const unsigned long, const double) –> void

set_chi(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) -> None

Sets the chi torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an nucleic acid

example(s):
pose.set_chi(7)

See also:
Pose Pose.chi Pose.residue Residue

C++: core::pose::Pose::set_chi(const unsigned long, const double) –> void

set_const_data(self: pyrosetta.rosetta.core.pose.Pose, category: str, name: str, original: pyrosetta.rosetta.core.pose.Pose) → None¶

template specialization for when storing a Pose inside a Pose. For the sake of: thread safety, the Pose that should be stored must represent a deep copy – one that does not contain pointers to any outside objects through which it might “communicate” behind the scenes or which might try to communicate with the starting pose. Therefore, a “detached_copy” of the original pose is created.

C++: core::pose::Pose::set_const_data(const std::string &, const std::string &, const class core::pose::Pose &) –> void

set_delta(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the delta torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an nucleic acid

example(s):
pose.set_delta(4)

See also:
Pose Pose.delta Pose.residue Residue

C++: core::pose::Pose::set_delta(const unsigned long, const double) –> void

set_dof(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.DOF_ID, setting: float) → None¶

Sets the value of the AtomTree DOF <id>

See also:
Pose DOF_ID

C++: core::pose::Pose::set_dof(const class core::id::DOF_ID &, const double) –> void

set_epsilon(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the epsilon torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an nucleic acid

example(s):
pose.set_epsilon(5)

See also:
Pose Pose.epsilon Pose.residue Residue

C++: core::pose::Pose::set_epsilon(const unsigned long, const double) –> void

set_gamma(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the gamma torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an nucleic acid

example(s):
pose.set_gamma(3)

See also:
Pose Pose.gamma Pose.residue Residue

C++: core::pose::Pose::set_gamma(const unsigned long, const double) –> void

set_jump(*args, **kwargs)¶

Overloaded function.

set_jump(self: pyrosetta.rosetta.core.pose.Pose, jump_number: int, new_jump: core::kinematics::Jump) -> None

Sets the pose FoldTree Jump <jump_number> to <new_jump>

example(s):
pose.set_jump(1,jump1)

See also:
Pose Pose.fold_tree Pose.jump FoldTree FoldTree.jump_edge Jump

C++: core::pose::Pose::set_jump(const int, const class core::kinematics::Jump &) –> void

set_jump(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.AtomID, new_jump: core::kinematics::Jump) -> None

Sets the pose FoldTree Jump <id> to <new_jump>

example(s):
pose.set_jump(1,jump1)

See also:
Pose Pose.fold_tree Pose.jump FoldTree FoldTree.jump_edge AtomID

C++: core::pose::Pose::set_jump(const class core::id::AtomID &, const class core::kinematics::Jump &) –> void

set_mu(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the mu torsion angle of oligourea residue <seqpos> to <setting>.

Mu is defined as CM(n)-NU(n)-C(n)-N(n+1) for an oligourea.

<setting> must be in degrees. Assumes residue is an oligourea.

example(s):
pose.set_mu(21, 58.9)

See also:
Pose Pose.mu Pose.residue Residue

Vikram K. Mulligan (vmullig.edu)

C++: core::pose::Pose::set_mu(const unsigned long, const double) –> void

set_new_conformation(self: pyrosetta.rosetta.core.pose.Pose, new_conformation: pyrosetta.rosetta.core.conformation.Conformation) → None¶

Now that the conformation_ member data is an owning pointer,: and we have derived classes of Conformation.

C++: core::pose::Pose::set_new_conformation(class std::shared_ptr<const class core::conformation::Conformation>) –> void

set_new_energies_object(self: pyrosetta.rosetta.core.pose.Pose, energies: core::scoring::Energies) → None¶

Now that the energies_ member data is an owning pointer,: and we have derived classes of Energies.

C++: core::pose::Pose::set_new_energies_object(class std::shared_ptr<class core::scoring::Energies>) –> void

set_omega(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the omega torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an amino acid or monosaccharide

example(s):
pose.set_omega(3, 180.0)

See also:
Pose Pose.omega Pose.residue Residue

C++: core::pose::Pose::set_omega(const unsigned long, const double) –> void

set_phi(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the phi torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an amino acid or monosaccharide

example(s):
pose.set_phi(1, -23.7)

See also:
Pose Pose.phi Pose.residue Residue

C++: core::pose::Pose::set_phi(const unsigned long, const double) –> void

set_psi(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the psi torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an amino acid or monosaccharide

example(s):
pose.set_psi(2, 45.3)

See also:
Pose Pose.psi Pose.residue Residue

C++: core::pose::Pose::set_psi(const unsigned long, const double) –> void

set_ring_conformation(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, ring_num: int, conformer: pyrosetta.rosetta.core.chemical.rings.RingConformer) → None¶

Set the given residue and ring’s ring conformation, if appropriate.

C++: core::pose::Pose::set_ring_conformation(const unsigned long, const unsigned long, const struct core::chemical::rings::RingConformer &) –> void

set_secstruct(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: str) → None¶

Assign the secondary structure of residue <seqpos> to <setting>

example(s):
pose.set_secstruct(3,’H’)

See also:
Pose Pose.residue Pose.secstruct Residue

C++: core::pose::Pose::set_secstruct(const unsigned long, const char) –> void

set_theta(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the theta torsion angle of beta-amino acid residue or oligourea residue <seqpos> to <setting>.

Theta is defined as N(n)-CA(n)-CM(n)-C(n) for a beta-amino acid, and N(n)-CA(n)-CM(n)-NU(n) for an oligourea.

<setting> must be in degrees. Assumes residue is a beta-amino acid or oligourea.

example(s):
pose.set_theta(21, 58.9)

See also:
Pose Pose.theta Pose.residue Residue

Vikram K. Mulligan (vmullig.edu)

C++: core::pose::Pose::set_theta(const unsigned long, const double) –> void

set_torsion(self: pyrosetta.rosetta.core.pose.Pose, id: core::id::TorsionID, setting: float) → None¶

Sets the Conformation torsion angle identified

by <id> to <setting>

See also:: Pose TorsionID

C++: core::pose::Pose::set_torsion(const class core::id::TorsionID &, const double) –> void

set_xyz(*args, **kwargs)¶

Overloaded function.

set_xyz(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.AtomID, point: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Sets the location (xyz) of pose AtomID <id> to

the PointPosition <point>

See also:: Pose Pose.residue Pose.xyz Residue

C++: core::pose::Pose::set_xyz(const class core::id::AtomID &, const class numeric::xyzVector<double> &) –> void

set_xyz(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.NamedAtomID, point: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Sets the location (xyz) of pose NamedAtomID <id>

to the PointPosition <point>

See also:: Pose Pose.residue Pose.xyz Residue

C++: core::pose::Pose::set_xyz(const class core::id::NamedAtomID &, const class numeric::xyzVector<double> &) –> void

set_zeta(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int, setting: float) → None¶

Sets the zeta torsion angle of residue <seqpos> to <setting>

<setting> must be in degrees, assumes residue is an nucleic acid

example(s):
pose.set_zeta(6)

See also:
Pose Pose.zeta Pose.residue Residue

C++: core::pose::Pose::set_zeta(const unsigned long, const double) –> void

size(self: pyrosetta.rosetta.core.pose.Pose) → int¶

Returns the number of residues in the pose conformation.

example(s):
pose.size()

See also:
Pose Pose.size Pose.sequence

C++: core::pose::Pose::size() const –> unsigned long

split_by_chain(*args, **kwargs)¶

Overloaded function.

split_by_chain(self: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t

Returns a vector of poses with one element per (chain number) chain of the original pose

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::Pose::split_by_chain() const –> class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > >

split_by_chain(self: pyrosetta.rosetta.core.pose.Pose, chain_id: int) -> pyrosetta.rosetta.core.pose.Pose

Return a new pose with just the residues from the specified (chain number) chain.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::Pose::split_by_chain(unsigned long) const –> class std::shared_ptr<class core::pose::Pose>

stub_from_id(self: pyrosetta.rosetta.core.pose.Pose, id: core::id::NamedStubID) → core::kinematics::Stub¶: C++: core::pose::Pose::stub_from_id(const class core::id::NamedStubID &) –> class core::kinematics::Stub

theta(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the theta torsion angle of beta-amino acid residue or oligourea residue <seqpos>.

Theta is defined as N(n)-CA(n)-CM(n)-C(n) for a beta-amino acid, and N(n)-CA(n)-CM(n)-NU(n) for an oligourea.

Assumes residue is a beta-amino acid or oligourea.

example(s):
pose.theta(21)

See also:
Pose Pose.set_theta Pose.residue Residue

Vikram K. Mulligan (vmullig.edu)

C++: core::pose::Pose::theta(const unsigned long) const –> double

torsion(self: pyrosetta.rosetta.core.pose.Pose, id: core::id::TorsionID) → float¶

Returns the Conformation torsion angle identified by <id>

See also:
Pose TorsionID

C++: core::pose::Pose::torsion(const class core::id::TorsionID &) const –> double

total_atoms(self: pyrosetta.rosetta.core.pose.Pose) → int¶

Returns the total number of atoms in the pose conformation

example:: pose.total_atoms()

C++: core::pose::Pose::total_atoms() const –> unsigned long

total_residue(self: pyrosetta.rosetta.core.pose.Pose) → int¶

Returns the number of residues in the pose conformation

This wrapper for size() is provided for mostly historical reasons.

example(s):
pose.total_residue()

See also:
Pose Pose.size Pose.sequence

C++: core::pose::Pose::total_residue() const –> unsigned long

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

translate(t)¶

Apply a translation to all of the coordinates in a Pose.

Args:: p (Pose): The Pose instance to manipulate t (np.array): A vector to add to the Pose coordinates

update_actcoord(self: pyrosetta.rosetta.core.pose.Pose, resid: int) → None¶

Updates the action coordinates for pose residue <resid>

C++: core::pose::Pose::update_actcoord(unsigned long) –> void

update_actcoords(self: pyrosetta.rosetta.core.pose.Pose) → None¶

Called by PairEPotential to update the action coordinates for all residues

C++: core::pose::Pose::update_actcoords() –> void

update_orbital_coords(self: pyrosetta.rosetta.core.pose.Pose, resid: int) → None¶: C++: core::pose::Pose::update_orbital_coords(unsigned long) –> void

update_pose_chains_from_pdb_chains(self: pyrosetta.rosetta.core.pose.Pose) → None¶

Updates the pose chain IDs to match the pdb chain letters.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

This does not reorder the pose, it just starts a new (chain number) chain each time the chain letters change.

C++: core::pose::Pose::update_pose_chains_from_pdb_chains() –> void

update_residue_neighbors(self: pyrosetta.rosetta.core.pose.Pose) → None¶

Updates neighbor links in the pose Energies object

C++: core::pose::Pose::update_residue_neighbors() –> void

virtual_to_real(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶

Switch residues from VIRTUAL to a REAL residue

example(s):
pose.virtual_to_real(3)

See also:
Pose ResidueType

C++: core::pose::Pose::virtual_to_real(unsigned long) –> void

xyz(*args, **kwargs)¶

Overloaded function.

xyz(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.AtomID) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Returns the location (xyz) of pose AtomID <id>

example(s):
atom = AtomID(1,1) pose.xyz(atom)

See also:
Pose Pose.residue AtomID Residue Residue.xyz

C++: core::pose::Pose::xyz(const class core::id::AtomID &) const –> const class numeric::xyzVector<double> &

xyz(self: pyrosetta.rosetta.core.pose.Pose, id: pyrosetta.rosetta.core.id.NamedAtomID) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Returns the location (xyz) of pose NamedAtomID <id>

Tutorial soon… See also:

Pose Pose.residue NamedAtomID Residue Residue.xyz

C++: core::pose::Pose::xyz(const class core::id::NamedAtomID &) const –> const class numeric::xyzVector<double> &

zero_reference_pose_mapping_at_seqpos(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶

Find all mappings in the new pose to seqpos in all ReferencePose objects, and set them to point to residue 0 (deletion signal).

If there is no ReferencePose object, do nothing.

C++: core::pose::Pose::zero_reference_pose_mapping_at_seqpos(const unsigned long) –> void

zeta(self: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → float¶

Returns the zeta torsion angle of residue <seqpos>

assumes the residue is an nucleic acid

example(s):
pose.zeta(6)

See also:
Pose Pose.residue Pose.set_zeta Residue

C++: core::pose::Pose::zeta(const unsigned long) const –> double

class pyrosetta.rosetta.core.pose.PoseCoordPickMode¶

Bases: pybind11_object

Members:

PoseCoordPickMode_NBR

PoseCoordPickMode_CA

PoseCoordPickMode_CB

PoseCoordPickMode_CB_else_CA

PoseCoordPickMode_BB

PoseCoordPickMode_N_CA_C

PoseCoordPickMode_N_CA_C_CB

PoseCoordPickMode_N_C_O

PoseCoordPickMode_BNP

PoseCoordPickMode_HVY

PoseCoordPickMode_HVY_IF_NP

PoseCoordPickMode_ALL

PoseCoordPickMode_CBorCA

PoseCoordPickMode_NUL

PoseCoordPickMode_ALL = <PoseCoordPickMode.PoseCoordPickMode_ALL: 11>¶

PoseCoordPickMode_BB = <PoseCoordPickMode.PoseCoordPickMode_BB: 4>¶

PoseCoordPickMode_BNP = <PoseCoordPickMode.PoseCoordPickMode_BNP: 8>¶

PoseCoordPickMode_CA = <PoseCoordPickMode.PoseCoordPickMode_CA: 1>¶

PoseCoordPickMode_CB = <PoseCoordPickMode.PoseCoordPickMode_CB: 2>¶

PoseCoordPickMode_CB_else_CA = <PoseCoordPickMode.PoseCoordPickMode_CB_else_CA: 3>¶

PoseCoordPickMode_CBorCA = <PoseCoordPickMode.PoseCoordPickMode_CBorCA: 12>¶

PoseCoordPickMode_HVY = <PoseCoordPickMode.PoseCoordPickMode_HVY: 9>¶

PoseCoordPickMode_HVY_IF_NP = <PoseCoordPickMode.PoseCoordPickMode_HVY_IF_NP: 10>¶

PoseCoordPickMode_NBR = <PoseCoordPickMode.PoseCoordPickMode_NBR: 0>¶

PoseCoordPickMode_NUL = <PoseCoordPickMode.PoseCoordPickMode_NUL: 13>¶

PoseCoordPickMode_N_CA_C = <PoseCoordPickMode.PoseCoordPickMode_N_CA_C: 5>¶

PoseCoordPickMode_N_CA_C_CB = <PoseCoordPickMode.PoseCoordPickMode_N_CA_C_CB: 6>¶

PoseCoordPickMode_N_C_O = <PoseCoordPickMode.PoseCoordPickMode_N_C_O: 7>¶

property name¶

property value¶

class pyrosetta.rosetta.core.pose.RID_FileSource¶

Bases: RID_Source

Representation of a file input support A class to hold information about where a ResidueIndexDescriptor comes from, to allow for better error messages

assign(self: pyrosetta.rosetta.core.pose.RID_FileSource, : pyrosetta.rosetta.core.pose.RID_FileSource) → pyrosetta.rosetta.core.pose.RID_FileSource¶: C++: core::pose::RID_FileSource::operator=(const class core::pose::RID_FileSource &) –> class core::pose::RID_FileSource &

fname(self: pyrosetta.rosetta.core.pose.RID_FileSource) → str¶: C++: core::pose::RID_FileSource::fname() const –> const std::string &

linenum(self: pyrosetta.rosetta.core.pose.RID_FileSource) → int¶: C++: core::pose::RID_FileSource::linenum() const –> unsigned long

source_string(self: pyrosetta.rosetta.core.pose.RID_FileSource) → str¶: C++: core::pose::RID_FileSource::source_string() const –> std::string

class pyrosetta.rosetta.core.pose.RID_Source¶

Bases: pybind11_object

A class to hold information about where a ResidueIndexDescriptor comes from, to allow for better error messages

assign(self: pyrosetta.rosetta.core.pose.RID_Source, : pyrosetta.rosetta.core.pose.RID_Source) → pyrosetta.rosetta.core.pose.RID_Source¶: C++: core::pose::RID_Source::operator=(const class core::pose::RID_Source &) –> class core::pose::RID_Source &

source_string(self: pyrosetta.rosetta.core.pose.RID_Source) → str¶: C++: core::pose::RID_Source::source_string() const –> std::string

class pyrosetta.rosetta.core.pose.ResidueIndexDescription¶

Bases: pybind11_object

a class which can represent one of many ways in which to describe a particular residue in a pose, and can, when given a pose, find its index. The object should be constructed with all its needed parameters, but, one instance may be copied from another.

assign(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription, : pyrosetta.rosetta.core.pose.ResidueIndexDescription) → pyrosetta.rosetta.core.pose.ResidueIndexDescription¶: C++: core::pose::ResidueIndexDescription::operator=(const class core::pose::ResidueIndexDescription &) –> class core::pose::ResidueIndexDescription &

get_source(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription) → pyrosetta.rosetta.core.pose.RID_Source¶: C++: core::pose::ResidueIndexDescription::get_source() const –> class std::shared_ptr<const class core::pose::RID_Source>

resolve_index(*args, **kwargs)¶

Overloaded function.

resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription, p: pyrosetta.rosetta.core.pose.Pose) -> int
resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription, p: pyrosetta.rosetta.core.pose.Pose, no_error: bool) -> int

Turn the internal data into a pose index (in the range from 1 to total residue): If it can’t be converted, throw an exception, unless no_error is true. If no_error is true, return 0 or a residue number outside the pose range.

C++: core::pose::ResidueIndexDescription::resolve_index(const class core::pose::Pose &, bool) const –> unsigned long

show(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription, : pyrosetta.rosetta.std.ostream) → None¶

Output a description of the residue.

In general will give a form which can be added “in-line” (no line ending)

C++: core::pose::ResidueIndexDescription::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.pose.ResidueIndexDescriptionChainEnd¶

Bases: ResidueIndexDescription

a class which represents the last residue in the Pose

assign(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionChainEnd, : pyrosetta.rosetta.core.pose.ResidueIndexDescriptionChainEnd) → pyrosetta.rosetta.core.pose.ResidueIndexDescriptionChainEnd¶: C++: core::pose::ResidueIndexDescriptionChainEnd::operator=(const class core::pose::ResidueIndexDescriptionChainEnd &) –> class core::pose::ResidueIndexDescriptionChainEnd &

get_source(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription) → pyrosetta.rosetta.core.pose.RID_Source¶: C++: core::pose::ResidueIndexDescription::get_source() const –> class std::shared_ptr<const class core::pose::RID_Source>

resolve_index(*args, **kwargs)¶

Overloaded function.

resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionChainEnd, p: pyrosetta.rosetta.core.pose.Pose) -> int
resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionChainEnd, p: pyrosetta.rosetta.core.pose.Pose, no_error: bool) -> int

C++: core::pose::ResidueIndexDescriptionChainEnd::resolve_index(const class core::pose::Pose &, bool) const –> unsigned long

show(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionChainEnd, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::pose::ResidueIndexDescriptionChainEnd::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.pose.ResidueIndexDescriptionLastResidue¶

Bases: ResidueIndexDescription

a class which represents the last residue in the Pose

assign(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionLastResidue, : pyrosetta.rosetta.core.pose.ResidueIndexDescriptionLastResidue) → pyrosetta.rosetta.core.pose.ResidueIndexDescriptionLastResidue¶: C++: core::pose::ResidueIndexDescriptionLastResidue::operator=(const class core::pose::ResidueIndexDescriptionLastResidue &) –> class core::pose::ResidueIndexDescriptionLastResidue &

get_source(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription) → pyrosetta.rosetta.core.pose.RID_Source¶: C++: core::pose::ResidueIndexDescription::get_source() const –> class std::shared_ptr<const class core::pose::RID_Source>

resolve_index(*args, **kwargs)¶

Overloaded function.

resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionLastResidue, p: pyrosetta.rosetta.core.pose.Pose) -> int
resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionLastResidue, p: pyrosetta.rosetta.core.pose.Pose, no_error: bool) -> int

C++: core::pose::ResidueIndexDescriptionLastResidue::resolve_index(const class core::pose::Pose &, bool) const –> unsigned long

show(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionLastResidue, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::pose::ResidueIndexDescriptionLastResidue::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB¶

Bases: ResidueIndexDescription

a class which represents a residue index as a PDB information (chain, resindex, insertion code)

assign(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB, : pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB) → pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB¶: C++: core::pose::ResidueIndexDescriptionPDB::operator=(const class core::pose::ResidueIndexDescriptionPDB &) –> class core::pose::ResidueIndexDescriptionPDB &

chain(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB) → str¶: C++: core::pose::ResidueIndexDescriptionPDB::chain() const –> char

get_source(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription) → pyrosetta.rosetta.core.pose.RID_Source¶: C++: core::pose::ResidueIndexDescription::get_source() const –> class std::shared_ptr<const class core::pose::RID_Source>

insertion_code(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB) → str¶: C++: core::pose::ResidueIndexDescriptionPDB::insertion_code() const –> char

resindex(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB) → int¶: C++: core::pose::ResidueIndexDescriptionPDB::resindex() const –> int

resolve_index(*args, **kwargs)¶

Overloaded function.

resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB, p: pyrosetta.rosetta.core.pose.Pose) -> int
resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB, p: pyrosetta.rosetta.core.pose.Pose, no_error: bool) -> int

C++: core::pose::ResidueIndexDescriptionPDB::resolve_index(const class core::pose::Pose &, bool) const –> unsigned long

show(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPDB, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::pose::ResidueIndexDescriptionPDB::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPoseNum¶

Bases: ResidueIndexDescription

a class which represents a residue index as a literal, Rosetta/Pose numbered integer

assign(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPoseNum, : pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPoseNum) → pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPoseNum¶: C++: core::pose::ResidueIndexDescriptionPoseNum::operator=(const class core::pose::ResidueIndexDescriptionPoseNum &) –> class core::pose::ResidueIndexDescriptionPoseNum &

get_source(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription) → pyrosetta.rosetta.core.pose.RID_Source¶: C++: core::pose::ResidueIndexDescription::get_source() const –> class std::shared_ptr<const class core::pose::RID_Source>

pose_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPoseNum) → int¶: C++: core::pose::ResidueIndexDescriptionPoseNum::pose_index() const –> unsigned long

resolve_index(*args, **kwargs)¶

Overloaded function.

resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPoseNum, p: pyrosetta.rosetta.core.pose.Pose) -> int
resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPoseNum, p: pyrosetta.rosetta.core.pose.Pose, no_error: bool) -> int

C++: core::pose::ResidueIndexDescriptionPoseNum::resolve_index(const class core::pose::Pose &, bool) const –> unsigned long

show(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionPoseNum, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::pose::ResidueIndexDescriptionPoseNum::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose¶

Bases: ResidueIndexDescription

a class which represents a residue index as a reference-pose enabled information.

assign(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose, : pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose) → pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose¶: C++: core::pose::ResidueIndexDescriptionRefPose::operator=(const class core::pose::ResidueIndexDescriptionRefPose &) –> class core::pose::ResidueIndexDescriptionRefPose &

get_source(self: pyrosetta.rosetta.core.pose.ResidueIndexDescription) → pyrosetta.rosetta.core.pose.RID_Source¶: C++: core::pose::ResidueIndexDescription::get_source() const –> class std::shared_ptr<const class core::pose::RID_Source>

refpose_name(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose) → str¶: C++: core::pose::ResidueIndexDescriptionRefPose::refpose_name() const –> const std::string &

refpose_number(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose) → int¶: C++: core::pose::ResidueIndexDescriptionRefPose::refpose_number() const –> unsigned long

refpose_offset(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose) → int¶: C++: core::pose::ResidueIndexDescriptionRefPose::refpose_offset() const –> long

resolve_index(*args, **kwargs)¶

Overloaded function.

resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose, p: pyrosetta.rosetta.core.pose.Pose) -> int
resolve_index(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose, p: pyrosetta.rosetta.core.pose.Pose, no_error: bool) -> int

C++: core::pose::ResidueIndexDescriptionRefPose::resolve_index(const class core::pose::Pose &, bool) const –> unsigned long

show(self: pyrosetta.rosetta.core.pose.ResidueIndexDescriptionRefPose, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::pose::ResidueIndexDescriptionRefPose::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord¶

Bases: pybind11_object

info about an atom in a unrecognized res (not in pose, but we want to remember it)

assign(self: pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord, : pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord) → pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord¶: C++: core::pose::UnrecognizedAtomRecord::operator=(const class core::pose::UnrecognizedAtomRecord &) –> class core::pose::UnrecognizedAtomRecord &

atom_name(self: pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord) → str¶: C++: core::pose::UnrecognizedAtomRecord::atom_name() const –> const std::string &

coords(self: pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::pose::UnrecognizedAtomRecord::coords() const –> const class numeric::xyzVector<double> &

res_name(self: pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord) → str¶: C++: core::pose::UnrecognizedAtomRecord::res_name() const –> const std::string &

res_num(self: pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord) → int¶: C++: core::pose::UnrecognizedAtomRecord::res_num() const –> const unsigned long &

temp(self: pyrosetta.rosetta.core.pose.UnrecognizedAtomRecord) → float¶: C++: core::pose::UnrecognizedAtomRecord::temp() const –> const double &

pyrosetta.rosetta.core.pose.addVirtualResAsRoot(*args, **kwargs)¶

Overloaded function.

addVirtualResAsRoot(pose: pyrosetta.rosetta.core.pose.Pose) -> None

Adds a VRT res to the end of the pose at the center of mass.: Reroots the structure on this res.

C++: core::pose::addVirtualResAsRoot(class core::pose::Pose &) –> void

addVirtualResAsRoot(xyz: pyrosetta.rosetta.numeric.xyzVector_double_t, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Adds a virtual residue to the end of the pose at the specified location.: Roots the structure on this residue.

C++: core::pose::addVirtualResAsRoot(const class numeric::xyzVector<double> &, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.add_comment(pose: pyrosetta.rosetta.core.pose.Pose, key: str, val: str) → None¶

Adds a key-value pair to the STRING_MAP in the Pose DataCache. If: there is no STRING_MAP in the DataCache, one is created.

C++: core::pose::add_comment(class core::pose::Pose &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.core.pose.add_custom_variant_type_to_pose_residue(pose: pyrosetta.rosetta.core.pose.Pose, variant_type: str, seqpos: int) → None¶: C++: core::pose::add_custom_variant_type_to_pose_residue(class core::pose::Pose &, const std::string &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.add_lower_terminus_type_to_pose_residue(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶: C++: core::pose::add_lower_terminus_type_to_pose_residue(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.add_score_line_string(pose: pyrosetta.rosetta.core.pose.Pose, key: str, val: str) → None¶

Sets a PDB-style REMARK entry in the Pose.

This is different from a comment in its interpretation by the silent-file output machinery. A REMARK is written on its own separate line in the output silent-file, while a comment is written as part of the Pose SCORE: lines.

C++: core::pose::add_score_line_string(class core::pose::Pose &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.core.pose.add_upper_terminus_type_to_pose_residue(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶: C++: core::pose::add_upper_terminus_type_to_pose_residue(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.add_variant_type_to_pose_residue(*args, **kwargs)¶

Overloaded function.

add_variant_type_to_pose_residue(pose: pyrosetta.rosetta.core.pose.Pose, variant_type: pyrosetta.rosetta.core.chemical.VariantType, seqpos: int) -> None

Construct a variant of an existing pose residue.

C++: core::pose::add_variant_type_to_pose_residue(class core::pose::Pose &, const enum core::chemical::VariantType, const unsigned long) –> void

add_variant_type_to_pose_residue(pose: pyrosetta.rosetta.core.pose.Pose, variant_type: str, seqpos: int) -> None

C++: core::pose::add_variant_type_to_pose_residue(class core::pose::Pose &, const std::string &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.add_variant_type_to_residue(old_rsd: pyrosetta.rosetta.core.conformation.Residue, variant_type: pyrosetta.rosetta.core.chemical.VariantType, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.conformation.Residue¶

Construct a variant of an existing residue.

C++: core::pose::add_variant_type_to_residue(const class core::conformation::Residue &, const enum core::chemical::VariantType, const class core::pose::Pose &) –> class std::shared_ptr<class core::conformation::Residue>

pyrosetta.rosetta.core.pose.all_atom_center(pose: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

Get the center of the indicated residues

This computes an equally-weighted, all-atom (including virtuals and hydrogens) center

C++: core::pose::all_atom_center(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.core.pose.annotated_to_oneletter_sequence(annotated_seq: str) → str¶

Returns the oneletter_sequence that corresponds to the given: annotated sequence.

C++: core::pose::annotated_to_oneletter_sequence(const std::string &) –> std::string

pyrosetta.rosetta.core.pose.append_pose_to_pose(*args, **kwargs)¶

Overloaded function.

append_pose_to_pose(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> None
append_pose_to_pose(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, new_chain: bool) -> None

Append residues of pose2 to pose1.

C++: core::pose::append_pose_to_pose(class core::pose::Pose &, const class core::pose::Pose &, bool) –> void

pyrosetta.rosetta.core.pose.append_pose_with_glycan_residues(*args, **kwargs)¶

Overloaded function.

append_pose_with_glycan_residues(pose: pyrosetta.rosetta.core.pose.Pose, residue_types: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t) -> None
append_pose_with_glycan_residues(pose: pyrosetta.rosetta.core.pose.Pose, residue_types: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t, resnum_to_be_appended: int) -> None

Append an empty or current Pose with saccharide residues, building branches as necessary.

C++: core::pose::append_pose_with_glycan_residues(class core::pose::Pose &, class utility::vector1<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > >, unsigned long) –> void

pyrosetta.rosetta.core.pose.append_subpose_to_pose(*args, **kwargs)¶

Overloaded function.

append_subpose_to_pose(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start_res: int, end_res: int) -> None
append_subpose_to_pose(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start_res: int, end_res: int, new_chain: bool) -> None

Append specified residues of pose2 to pose1.

C++: core::pose::append_subpose_to_pose(class core::pose::Pose &, const class core::pose::Pose &, unsigned long, unsigned long, bool) –> void

pyrosetta.rosetta.core.pose.atom_id_to_named_atom_id(atom_id: pyrosetta.rosetta.core.id.AtomID, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.id.NamedAtomID¶: C++: core::pose::atom_id_to_named_atom_id(const class core::id::AtomID &, const class core::pose::Pose &) –> class core::id::NamedAtomID

pyrosetta.rosetta.core.pose.attributes_for_get_resnum_selector(*args, **kwargs)¶

Overloaded function.

attributes_for_get_resnum_selector(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, xsd: utility::tag::XMLSchemaDefinition) -> None
attributes_for_get_resnum_selector(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, xsd: utility::tag::XMLSchemaDefinition, tag: str) -> None
attributes_for_get_resnum_selector(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, xsd: utility::tag::XMLSchemaDefinition, tag: str, description: str) -> None

Companion function for get_resnum_selector

Appends relevant XMLSchemaAttributes to the AttributeList; needs the xsd because it adds restricted types

C++: core::pose::attributes_for_get_resnum_selector(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, class utility::tag::XMLSchemaDefinition &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.core.pose.attributes_for_get_resnum_string(*args, **kwargs)¶

Overloaded function.

attributes_for_get_resnum_string(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None
attributes_for_get_resnum_string(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, prefix: str) -> None

Companion function for get_resnum_string

Appends relevant XMLSchemaAttributes to the AttributeList

C++: core::pose::attributes_for_get_resnum_string(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> void

pyrosetta.rosetta.core.pose.attributes_for_parse_resnum(*args, **kwargs)¶

Overloaded function.

attributes_for_parse_resnum(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, att_name: str) -> None
attributes_for_parse_resnum(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, att_name: str, description: str) -> None

Companion function for parse_resnum

Appends relevant XMLSchemaAttributes to the AttributeList

C++: core::pose::attributes_for_parse_resnum(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.core.pose.attributes_for_saved_reference_pose(*args, **kwargs)¶

Overloaded function.

attributes_for_saved_reference_pose(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None
attributes_for_saved_reference_pose(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, attribute_name: str) -> None

convenience function to access pointers to poses that will be stored: in the data map at an arbitrary point during an RS protocol Will look for tag in in_tag variable

C++: core::pose::attributes_for_saved_reference_pose(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &) –> void

pyrosetta.rosetta.core.pose.attributes_for_saved_reference_pose_w_description(*args, **kwargs)¶

Overloaded function.

attributes_for_saved_reference_pose_w_description(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str) -> None
attributes_for_saved_reference_pose_w_description(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str, attribute_name: str) -> None

convenience function to access pointers to poses that will be stored: in the data map at an arbitrary point during an RS protocol Will look for tag in in_tag variable

C++: core::pose::attributes_for_saved_reference_pose_w_description(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.core.pose.canonical_atom_count(pose: pyrosetta.rosetta.core.pose.Pose) → int¶

count the number of canonical amino acid atoms in the pose

C++: core::pose::canonical_atom_count(const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.canonical_residue_count(pose: pyrosetta.rosetta.core.pose.Pose) → int¶

count the number of canonical residues in the pose

C++: core::pose::canonical_residue_count(const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.center_of_mass(*args, **kwargs)¶

Overloaded function.

center_of_mass(pose: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Get the center of the indicated residues

WARNING: Despite the name, this function only calculates with a single coordinate per residue (the Calpha/neighbor atom)

C++: core::pose::center_of_mass(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) –> class numeric::xyzVector<double>

center_of_mass(pose: pyrosetta.rosetta.core.pose.Pose, start: int, stop: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Get the center of the indicated residues

WARNING: Despite the name, this function only calculates with a single coordinate per residue (the Calpha/neighbor atom)

C++: core::pose::center_of_mass(const class core::pose::Pose &, const int, const int) –> class numeric::xyzVector<double>

pyrosetta.rosetta.core.pose.chain_end_res(*args, **kwargs)¶

Overloaded function.

chain_end_res(pose: pyrosetta.rosetta.core.pose.Pose, chain: int) -> int

compute last residue number of a chain

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

/: This is mostly indirection to Conformation::chain_end(), but with better error checking

C++: core::pose::chain_end_res(const class core::pose::Pose &, const unsigned long) –> unsigned long

chain_end_res(pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_unsigned_long

compute last residue numbers of all chains

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

/: This is mostly an indirection to Conformation::chain_endings(), though with better handling of the last residue

C++: core::pose::chain_end_res(const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.clearPoseExtraScore(pose: pyrosetta.rosetta.core.pose.Pose, name: str) → None¶

Clear a specific data type from the arbitrary data cache in the pose.

C++: core::pose::clearPoseExtraScore(class core::pose::Pose &, const std::string &) –> void

pyrosetta.rosetta.core.pose.clearPoseExtraScores(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Clear ALL PoseExtraScores

C++: core::pose::clearPoseExtraScores(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.compare_atom_coordinates(*args, **kwargs)¶

Overloaded function.

compare_atom_coordinates(lhs: pyrosetta.rosetta.core.pose.Pose, rhs: pyrosetta.rosetta.core.pose.Pose) -> bool
compare_atom_coordinates(lhs: pyrosetta.rosetta.core.pose.Pose, rhs: pyrosetta.rosetta.core.pose.Pose, n_dec_places: int) -> bool

this function compares pose atom coordinates for equality; it is not the == operator because it does not compare all pose data.

Steven Lewis smlewi.com

one pose to compare

one pose to compare

number of decimal places to compare for the coordinates (remember == doesn’t work for float); defaults to 3 which is PDB accuracy

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

pyrosetta.rosetta.core.pose.compare_binary_protein_silent_struct(lhs: pyrosetta.rosetta.core.pose.Pose, rhs: pyrosetta.rosetta.core.pose.Pose) → bool¶

this function compares poses for equality up to the information stored in the binary protein silent struct format.

C++: core::pose::compare_binary_protein_silent_struct(const class core::pose::Pose &, const class core::pose::Pose &) –> bool

pyrosetta.rosetta.core.pose.compute_unique_chains(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_bool¶

Compute uniq chains in a complex, based on sequence identity

Returns a vector of pose length with true/false of uniq chain
true is unique, false is not

C++: core::pose::compute_unique_chains(class core::pose::Pose &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.core.pose.conf2pdb_chain(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_unsigned_long_char¶

get Conformation chain number -> PDBInfo chain mapping

Any chains whose PDBInfo chain records are marked entirely as
PDBInfo::empty_record() will be mapped to that character.

the mapping if PDBInfo available and chains appear consistent,
otherwise prints a warning and returns a default mapping (1=A, 2=B_

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::conf2pdb_chain(const class core::pose::Pose &) –> class std::map<unsigned long, char, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, char> > >

pyrosetta.rosetta.core.pose.convert_from_std_map(atom_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t¶: C++: core::pose::convert_from_std_map(const class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &, const class core::pose::Pose &) –> class core::id::AtomID_Map<class core::id::AtomID>

pyrosetta.rosetta.core.pose.correctly_add_2prime_connection_variants(pose: pyrosetta.rosetta.core.pose.Pose, twoprime_res: int, next_res: int) → None¶: C++: core::pose::correctly_add_2prime_connection_variants(class core::pose::Pose &, const unsigned long, const unsigned long) –> void

pyrosetta.rosetta.core.pose.correctly_add_cutpoint_variants(*args, **kwargs)¶

Overloaded function.

correctly_add_cutpoint_variants(pose: pyrosetta.rosetta.core.pose.Pose) -> None

Add cutpoint variants to all residues annotated as cutpoints in the FoldTree in the Pose.

C++: core::pose::correctly_add_cutpoint_variants(class core::pose::Pose &) –> void

correctly_add_cutpoint_variants(pose: pyrosetta.rosetta.core.pose.Pose, cutpoint_res: int) -> None
correctly_add_cutpoint_variants(pose: pyrosetta.rosetta.core.pose.Pose, cutpoint_res: int, check_fold_tree: bool) -> None
correctly_add_cutpoint_variants(pose: pyrosetta.rosetta.core.pose.Pose, cutpoint_res: int, check_fold_tree: bool, next_res_in: int) -> None

Add CUTPOINT_LOWER and CUTPOINT_UPPER types to two residues, remove incompatible types, and declare

a chemical bond between them.

The pose to modify.

The index of the CUTPOINT_LOWER residue.

If true, a check is performed to confirm that the residues in question represent a cutpoint in the foldtree in the pose.

The index of the CUTPOINT_UPPER residue. If not provided, or if set to 0, this defaults to the cutpoint_res + 1 residue. Must be specified for cyclic geometry.

C++: core::pose::correctly_add_cutpoint_variants(class core::pose::Pose &, const unsigned long, const bool, const unsigned long) –> void

pyrosetta.rosetta.core.pose.correctly_remove_variants_incompatible_with_lower_cutpoint_variant(pose: pyrosetta.rosetta.core.pose.Pose, res_index: int) → None¶

Remove variant types incompatible with CUTPOINT_LOWER from a position in a pose.

Vikram K. Mulligan (vmullig.edu).

The pose on which to operate.

The index of the residue on which to operate.

C++: core::pose::correctly_remove_variants_incompatible_with_lower_cutpoint_variant(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.correctly_remove_variants_incompatible_with_upper_cutpoint_variant(pose: pyrosetta.rosetta.core.pose.Pose, res_index: int) → None¶

Remove variant types incompatible with CUTPOINT_UPPER from a position in a pose.

Vikram K. Mulligan (vmullig.edu).

The pose on which to operate.

The index of the residue on which to operate.

C++: core::pose::correctly_remove_variants_incompatible_with_upper_cutpoint_variant(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.create_subpose(src: pyrosetta.rosetta.core.pose.Pose, positions: pyrosetta.rosetta.utility.vector1_unsigned_long, f: pyrosetta.rosetta.core.kinematics.FoldTree, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Create a subpose of the src pose. PDBInfo is set as NULL.

C++: core::pose::create_subpose(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class core::kinematics::FoldTree &, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.declare_cutpoint_chemical_bond(*args, **kwargs)¶

Overloaded function.

declare_cutpoint_chemical_bond(pose: pyrosetta.rosetta.core.pose.Pose, cutpoint_res: int) -> None
declare_cutpoint_chemical_bond(pose: pyrosetta.rosetta.core.pose.Pose, cutpoint_res: int, next_res_in: int) -> None

Create a chemical bond from lower to upper residue across CUTPOINT_LOWER/CUTPOINT_UPPER.

This will prevent steric repulsion.

The pose to modify.

The index of the CUTPOINT_LOWER residue.

The index of the CUTPOINT_UPPER residue. If not provided, or if set to 0, this defaults to the cutpoint_res + 1 residue. Must be specified for cyclic geometry.

C++: core::pose::declare_cutpoint_chemical_bond(class core::pose::Pose &, const unsigned long, const unsigned long) –> void

pyrosetta.rosetta.core.pose.deep_copy(source: core::pose::Pose) → core::pose::Pose¶

Note that this does a clone(), which isn’t actually a full deep copy (which would be detached_copy()): This may or may not have implications for multithreaded use.

C++: core::pose::deep_copy(const class core::pose::Pose &) –> class std::shared_ptr<class core::pose::Pose>

pyrosetta.rosetta.core.pose.definite_terminal_root(*args, **kwargs)¶

Overloaded function.

definite_terminal_root(cutpoint_open_in_full_model: pyrosetta.rosetta.utility.vector1_unsigned_long, working_res: pyrosetta.rosetta.utility.vector1_unsigned_long, res_list: pyrosetta.rosetta.utility.vector1_unsigned_long, nres: int, i: int) -> bool

C++: core::pose::definite_terminal_root(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const unsigned long, const unsigned long) –> bool

definite_terminal_root(pose: pyrosetta.rosetta.core.pose.Pose, i: int) -> bool

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

pyrosetta.rosetta.core.pose.delete_comment(pose: pyrosetta.rosetta.core.pose.Pose, key: str) → None¶

Deletes the entry in the STRING_MAP associated with the: given key.

C++: core::pose::delete_comment(class core::pose::Pose &, const std::string &) –> void

pyrosetta.rosetta.core.pose.disulfide_pairs_from_sfr(pose: pyrosetta.rosetta.core.pose.Pose, fd: pyrosetta.rosetta.core.io.StructFileRep) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t¶

extract disulfide pairing from SFR

C++: core::pose::disulfide_pairs_from_sfr(const class core::pose::Pose &, const class core::io::StructFileRep &) –> class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

pyrosetta.rosetta.core.pose.dump_comment_pdb(file_name: str, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

dumps pose+ comments to pdb file

C++: core::pose::dump_comment_pdb(const std::string &, const class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.effective_lower_terminus_based_on_working_res(i: int, working_res: pyrosetta.rosetta.utility.vector1_unsigned_long, res_list: pyrosetta.rosetta.utility.vector1_unsigned_long, cutpoint_open_in_full_model: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool¶: C++: core::pose::effective_lower_terminus_based_on_working_res(const unsigned long, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> bool

pyrosetta.rosetta.core.pose.effective_upper_terminus_based_on_working_res(i: int, working_res: pyrosetta.rosetta.utility.vector1_unsigned_long, res_list: pyrosetta.rosetta.utility.vector1_unsigned_long, cutpoint_open_in_full_model: pyrosetta.rosetta.utility.vector1_unsigned_long, nres_full: int) → bool¶: C++: core::pose::effective_upper_terminus_based_on_working_res(const unsigned long, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const unsigned long) –> bool

pyrosetta.rosetta.core.pose.energy_from_pose(*args, **kwargs)¶

Overloaded function.

energy_from_pose(pose: pyrosetta.rosetta.core.pose.Pose, sc_type: pyrosetta.rosetta.core.scoring.ScoreType) -> float

C++: core::pose::energy_from_pose(const class core::pose::Pose &, const enum core::scoring::ScoreType &) –> double

energy_from_pose(pose: pyrosetta.rosetta.core.pose.Pose, sc_type: str) -> float

C++: core::pose::energy_from_pose(const class core::pose::Pose &, const std::string &) –> double

pyrosetta.rosetta.core.pose.extract_tag_from_pose(pose: pyrosetta.rosetta.core.pose.Pose) → str¶

Returns a string giving the pose’s tag if there is such a thing or “UnknownTag” otherwise.

C++: core::pose::extract_tag_from_pose(class core::pose::Pose &) –> std::string

pyrosetta.rosetta.core.pose.fix_pdbinfo_damaged_by_insertion(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Repair pdbinfo of inserted residues that may have blank chain and zero: seqpos. Assumes insertions only occur _after_ a residue.

C++: core::pose::fix_pdbinfo_damaged_by_insertion(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.fix_up_residue_type_variants(pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::pose::fix_up_residue_type_variants(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.fix_up_residue_type_variants_at_strand_beginning(pose: pyrosetta.rosetta.core.pose.Pose, res: int) → None¶: C++: core::pose::fix_up_residue_type_variants_at_strand_beginning(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.fix_up_residue_type_variants_at_strand_end(pose: pyrosetta.rosetta.core.pose.Pose, res: int) → None¶: C++: core::pose::fix_up_residue_type_variants_at_strand_end(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.getPoseExtraFloatScores(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_std_string_float¶: C++: core::pose::getPoseExtraFloatScores(const class core::pose::Pose &) –> class std::map<std::string, float, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, float> > >

pyrosetta.rosetta.core.pose.getPoseExtraScore(*args, **kwargs)¶

Overloaded function.

getPoseExtraScore(pose: pyrosetta.rosetta.core.pose.Pose, name: str) -> float

return value is ExtraScore if exist, runtime_assert if it doesn’t exist

C++: core::pose::getPoseExtraScore(const class core::pose::Pose &, const std::string &) –> double

getPoseExtraScore(pose: pyrosetta.rosetta.core.pose.Pose, name: str, value: float) -> bool

return bool is T/F for whether the requested datum exists. “value” is the data, pass-by-ref.

C++: core::pose::getPoseExtraScore(const class core::pose::Pose &, const std::string &, double &) –> bool

getPoseExtraScore(pose: pyrosetta.rosetta.core.pose.Pose, name: str, value: str) -> bool

return bool is T/F for whether the requested datum exists. “value” is the data, pass-by-ref.

C++: core::pose::getPoseExtraScore(const class core::pose::Pose &, const std::string &, std::string &) –> bool

pyrosetta.rosetta.core.pose.getPoseExtraStringScores(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_std_string_std_string¶: C++: core::pose::getPoseExtraStringScores(const class core::pose::Pose &) –> class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > >

pyrosetta.rosetta.core.pose.get_all_comments(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_std_string_std_string¶

Gets a map< string, string > representing comments about the Pose in: the form of key-value pairs.

C++: core::pose::get_all_comments(const class core::pose::Pose &) –> class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > >

pyrosetta.rosetta.core.pose.get_all_score_line_strings(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_std_string_std_string¶

Gets a map< string, string > representing score_line_strings about the Pose in: the form of key-value pairs.

C++: core::pose::get_all_score_line_strings(const class core::pose::Pose &) –> class std::map<std::string, std::string, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, std::string > > >

pyrosetta.rosetta.core.pose.get_bb_torsion(torsion_id: int, pose: pyrosetta.rosetta.core.pose.Pose, sequence_position: int) → float¶

Get a particular backbone torsion, phi, psi, omega (see core::types): Works with carbohydrates. Think about moving this to pose itself.

C++: core::pose::get_bb_torsion(unsigned long, const class core::pose::Pose &, unsigned long) –> double

pyrosetta.rosetta.core.pose.get_center_of_mass(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

Get center of mass of a pose.

This computes an equally-weighted, all-(non-virtual)-heavy atom center.

C++: core::pose::get_center_of_mass(const class core::pose::Pose &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.core.pose.get_chain_from_chain_id(chain_id: int, pose: pyrosetta.rosetta.core.pose.Pose) → str¶

Get the chain letter for the first residue in a given chain number

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

Keep in mind that not all residues with the given chain number will necessarily have the returned chain letter

C++: core::pose::get_chain_from_chain_id(const unsigned long &, const class core::pose::Pose &) –> char

pyrosetta.rosetta.core.pose.get_chain_from_jump_id(jump_id: int, pose: pyrosetta.rosetta.core.pose.Pose) → str¶

Get the chain letter of the chain built by the given jump.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

Keep in mind that not every residue with the returned chain ID will be downstream of this jump.

C++: core::pose::get_chain_from_jump_id(const unsigned long &, const class core::pose::Pose &) –> char

pyrosetta.rosetta.core.pose.get_chain_id_from_chain(*args, **kwargs)¶

Overloaded function.

get_chain_id_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> int

Attempt to get the chain number which correspond to the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

If the chain letter corresponds to more than one chain letter, raise an error

C++: core::pose::get_chain_id_from_chain(const std::string &, const class core::pose::Pose &) –> unsigned long

get_chain_id_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> int

Attempt to get the chain number which correspond to the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

If the chain letter corresponds to more than one chain letter, raise an error

C++: core::pose::get_chain_id_from_chain(const char &, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.get_chain_id_from_jump_id(jump_id: int, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

Get the chain ID of the residue directly built by the given jump.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

Keep in mind that not every residue with the returned chain ID will be downstream of this jump.

C++: core::pose::get_chain_id_from_jump_id(const unsigned long &, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.get_chain_ids_from_chain(*args, **kwargs)¶

Overloaded function.

get_chain_ids_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Get all chain numbers for the residues with the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The returned chain numbers are in sorted order

C++: core::pose::get_chain_ids_from_chain(const std::string &, const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_chain_ids_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Get all chain numbers for the residues with the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The returned chain numbers are in sorted order

C++: core::pose::get_chain_ids_from_chain(const char &, const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_chain_ids_from_chains(*args, **kwargs)¶

Overloaded function.

get_chain_ids_from_chains(chains: pyrosetta.rosetta.utility.vector1_std_string, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Get all chain numbers for the residues with the given chain letters

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The returned chain numbers are in sorted order

C++: core::pose::get_chain_ids_from_chains(const class utility::vector1<std::string, class std::allocator<std::string > > &, const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_chain_ids_from_chains(chains: pyrosetta.rosetta.utility.vector1_char, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Get all chain numbers for the residues with the given chain letters

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The returned chain numbers are in sorted order

C++: core::pose::get_chain_ids_from_chains(const class utility::vector1<char, class std::allocator<char> > &, const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_chain_residues(pose: pyrosetta.rosetta.core.pose.Pose, chain_id: int) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t¶

Get all residues which correspond to the given chain number

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_chain_residues(const class core::pose::Pose &, unsigned long) –> class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > >

pyrosetta.rosetta.core.pose.get_chains(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Get all the chain numbers from conformation

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

This is a rather silly function, as it will just return a vector with entries from 1 to pose->num_chains() (as chains numbers are sequential starting from 1

C++: core::pose::get_chains(const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_comment(pose: pyrosetta.rosetta.core.pose.Pose, key: str, val: str) → bool¶

Attempts to access the entry in the STRING_MAP associated with the: given key. If an entry for the key exists, the value associated with the key is put into val, and this function returns true. Otherwise, this function returns false and val left unmodified.

C++: core::pose::get_comment(const class core::pose::Pose &, const std::string &, std::string &) –> bool

pyrosetta.rosetta.core.pose.get_constraints_from_link_records(pose: pyrosetta.rosetta.core.pose.Pose, sfr: pyrosetta.rosetta.core.io.StructFileRep) → None¶: C++: core::pose::get_constraints_from_link_records(class core::pose::Pose &, const class core::io::StructFileRep &) –> void

pyrosetta.rosetta.core.pose.get_definite_terminal_root(*args, **kwargs)¶

Overloaded function.

get_definite_terminal_root(pose: pyrosetta.rosetta.core.pose.Pose, partition_res: pyrosetta.rosetta.utility.vector1_unsigned_long, res_list: pyrosetta.rosetta.utility.vector1_unsigned_long, fixed_domain_map: pyrosetta.rosetta.utility.vector1_unsigned_long, cutpoint_open_in_full_model: pyrosetta.rosetta.utility.vector1_unsigned_long, working_res: pyrosetta.rosetta.utility.vector1_unsigned_long) -> int
get_definite_terminal_root(pose: pyrosetta.rosetta.core.pose.Pose, partition_res: pyrosetta.rosetta.utility.vector1_unsigned_long, res_list: pyrosetta.rosetta.utility.vector1_unsigned_long, fixed_domain_map: pyrosetta.rosetta.utility.vector1_unsigned_long, cutpoint_open_in_full_model: pyrosetta.rosetta.utility.vector1_unsigned_long, working_res: pyrosetta.rosetta.utility.vector1_unsigned_long, disallow_cutpoint_closed_upper: bool) -> int

C++: core::pose::get_definite_terminal_root(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const bool) –> unsigned long

get_definite_terminal_root(pose: pyrosetta.rosetta.core.pose.Pose, partition_res: pyrosetta.rosetta.utility.vector1_unsigned_long) -> int
get_definite_terminal_root(pose: pyrosetta.rosetta.core.pose.Pose, partition_res: pyrosetta.rosetta.utility.vector1_unsigned_long, disallow_cutpoint_closed_upper: bool) -> int

C++: core::pose::get_definite_terminal_root(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const bool) –> unsigned long

pyrosetta.rosetta.core.pose.get_hash_excluding_chain(*args, **kwargs)¶

Overloaded function.

get_hash_excluding_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> int
get_hash_excluding_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose, extra_label: str) -> int

Get a value representing the position of all the atoms for residues which don’t have the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_hash_excluding_chain(const char &, const class core::pose::Pose &, const std::string &) –> unsigned long

pyrosetta.rosetta.core.pose.get_hash_from_chain(*args, **kwargs)¶

Overloaded function.

get_hash_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> int
get_hash_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose, extra_label: str) -> int

Get a value representing the position of all the atoms for residues with the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_hash_from_chain(const char &, const class core::pose::Pose &, const std::string &) –> unsigned long

pyrosetta.rosetta.core.pose.get_hash_from_pos(pos: pyrosetta.rosetta.numeric.xyzVector_double_t) → int¶

Utility function for get_hash_from_chain() - get hash for an isolated position.

C++: core::pose::get_hash_from_pos(const class numeric::xyzVector<double> &) –> unsigned long

pyrosetta.rosetta.core.pose.get_jump_id_from_chain(*args, **kwargs)¶

Overloaded function.

get_jump_id_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> int

Get the jump number for the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The jump here is the jumps which is directly upstream of a residue with a given chain letter, (i.e. a residue with the given chain letter is built directly from the jump) rather than logically upstream. If there’s more than one jump which builds residues with the given chain letter, return the smallest numbered jump (even if it’s not the jump which best partions the chain on the FoldTree). If no jump directly builds the chain, hard exit.

C++: core::pose::get_jump_id_from_chain(const std::string &, const class core::pose::Pose &) –> unsigned long

get_jump_id_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> int

Get the jump number for the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The jump here is the jumps which is directly upstream of a residue with a given chain letter, (i.e. a residue with the given chain letter is built directly from the jump) rather than logically upstream. If there’s more than one jump which builds residues with the given chain letter, return the smallest numbered jump (even if it’s not the jump which best partions the chain on the FoldTree). If no jump directly builds the chain, hard exit.

C++: core::pose::get_jump_id_from_chain(const char &, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.get_jump_id_from_chain_id(chain_id: int, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

Attempt to get the jump number which correspond to the given chain number

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The jump here is the jump which is directly upstream of a residue in the given chain, (i.e. a residue on the given chain number is built directly from the jump) rather than logically upstream. If there’s more than one jump which builds the given chain, return the smallest numbered jump (even if it’s not the jump which best partions the chain on the FoldTree). If no jump directly builds the chain (unlikely), hard exit.

C++: core::pose::get_jump_id_from_chain_id(const unsigned long &, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.get_jump_ids_from_chain(*args, **kwargs)¶

Overloaded function.

get_jump_ids_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Get all the jump numbers for the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The jumps here are the jumps which are directly upstream of a residue with a given chain letter, (i.e. a residue with the given chain letter is built directly from the jump) rather than logically upstream. Return all jumps which build residues with the given chain letter. If no jumps directly builds residues with the given chain letters, return an empty vector.

The returned jump numbers are in sorted order

C++: core::pose::get_jump_ids_from_chain(const char &, const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_jump_ids_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Get all the jump numbers for the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The jumps here are the jumps which are directly upstream of a residue with a given chain letter, (i.e. a residue with the given chain letter is built directly from the jump) rather than logically upstream. Return all jumps which build residues with the given chain letter. If no jumps directly builds residues with the given chain letters, return an empty vector.

The returned jump numbers are in sorted order

C++: core::pose::get_jump_ids_from_chain(const std::string &, const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_jump_ids_from_chain_ids(chain_ids: pyrosetta.rosetta.std.set_unsigned_long_t, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.set_unsigned_long_t¶

Attempt to get jump IDs which correspond to the given chain number

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The jumps here are the jumps which are directly upstream of a residue in the given chains, (i.e. a residue on the given chain number is built directly from the jump) rather than logically upstream. Return all jumps which build a given chain. If no jumps directly builds the given chains (unlikely), return an empty set.

C++: core::pose::get_jump_ids_from_chain_ids(const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, const class core::pose::Pose &) –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_pdb2pose_numbering_as_stdmap(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_std_string_unsigned_long¶

Create std::map from PDBPoseMap

C++: core::pose::get_pdb2pose_numbering_as_stdmap(const class core::pose::Pose &) –> class std::map<std::string, unsigned long, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, unsigned long> > >

pyrosetta.rosetta.core.pose.get_residues_from_chains(pose: pyrosetta.rosetta.core.pose.Pose, chain_ids: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t¶

Get all residues which correspond to the given chain numbers

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_residues_from_chains(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > >

pyrosetta.rosetta.core.pose.get_resnum_list(str: str, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.set_unsigned_long_t¶

returns a resnum list directly from a string

C++: core::pose::get_resnum_list(const std::string &, const class core::pose::Pose &) –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_resnum_list_ordered(str: str, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

returns a resnum list directly from a string, preserving order

C++: core::pose::get_resnum_list_ordered(const std::string &, const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_resnum_selector(tag_ptr: pyrosetta.rosetta.utility.tag.Tag, tag: str) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

//: Extracts a list of residue numbers from a tag

//

The tag should contain a comma-separated list of numbers, in either

// pdb or rosetta format (

parse_resnum for details)

C++: core::pose::get_resnum_selector(class std::shared_ptr<const class utility::tag::Tag>, const std::string &) –> class std::shared_ptr<class core::select::residue_selector::ResidueSelector>

pyrosetta.rosetta.core.pose.get_resnum_string(*args, **kwargs)¶

Overloaded function.

get_resnum_string(tag_ptr: pyrosetta.rosetta.utility.tag.Tag) -> str
get_resnum_string(tag_ptr: pyrosetta.rosetta.utility.tag.Tag, prefix: str) -> str

DEPRECATED - provided for legacy usage only. Don’t use for new code.

Instead, just use a single option which uses the parse_resnum syntax to specify.

Checks for either/both of pdb_num/res_num in the tag, and pulls out the appropriate string

C++: core::pose::get_resnum_string(class std::shared_ptr<const class utility::tag::Tag>, const std::string &) –> std::string

get_resnum_string(tag_ptr: pyrosetta.rosetta.utility.tag.Tag, prefix: str, default_value: str) -> str

DEPRECATED - provided for legacy usage only. Don’t use for new code.

Instead, just use a single option which uses parse_resnum syntax to specify

Checks for either/both of pdb_num/res_num in the tag, and pulls out the appropriate string

C++: core::pose::get_resnum_string(class std::shared_ptr<const class utility::tag::Tag>, const std::string &, const std::string &) –> std::string

pyrosetta.rosetta.core.pose.get_resnumber_from_reference_pose(refpose_name: str, refpose_number: int, refpose_offset: int, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

Given the name of a ReferencePose object in the pose, a residue number in that reference pose, and a residue offset,

this function returns the Rosetta number of the corresponding residue in the pose. Should throw an error if the ReferencePose doesn’t exist in the pose, or 0 if no corresponding residue exists in the pose.

Vikram K. Mulligan, Baker laboratory (vmullig.edu)

C++: core::pose::get_resnumber_from_reference_pose(const std::string &, const unsigned long, const long, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.get_resnums_for_chain(pose: pyrosetta.rosetta.core.pose.Pose, chain: str) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Get a vector of all residues numbers which are represented by this chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The returned residue numbers are in sorted order

C++: core::pose::get_resnums_for_chain(const class core::pose::Pose &, char) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_resnums_for_chain_id(pose: pyrosetta.rosetta.core.pose.Pose, chain_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Get a vector of all residues numbers which are represented by this chain number

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The returned residue numbers are in sorted order

C++: core::pose::get_resnums_for_chain_id(const class core::pose::Pose &, unsigned long) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.get_restype_for_pose(*args, **kwargs)¶

Overloaded function.

get_restype_for_pose(pose: pyrosetta.rosetta.core.pose.Pose, name: str) -> pyrosetta.rosetta.core.chemical.ResidueType

Return the residue type in the correct: “mode” (fullatom, centroid …) the pose is in.

C++: core::pose::get_restype_for_pose(const class core::pose::Pose &, const std::string &) –> class std::shared_ptr<const class core::chemical::ResidueType>

get_restype_for_pose(pose: pyrosetta.rosetta.core.pose.Pose, name: str, mode: pyrosetta.rosetta.core.chemical.TypeSetMode) -> pyrosetta.rosetta.core.chemical.ResidueType

Return the residue type in the passed mode,: respecting any modification that pose may make.

C++: core::pose::get_restype_for_pose(const class core::pose::Pose &, const std::string &, enum core::chemical::TypeSetMode) –> class std::shared_ptr<const class core::chemical::ResidueType>

pyrosetta.rosetta.core.pose.get_rsd_type_from_aa(*args, **kwargs)¶

Overloaded function.

get_rsd_type_from_aa(residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, my_aa: pyrosetta.rosetta.core.chemical.AA, is_lower_terminus: bool, is_upper_terminus: bool) -> pyrosetta.rosetta.core.chemical.ResidueType
get_rsd_type_from_aa(residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, my_aa: pyrosetta.rosetta.core.chemical.AA, is_lower_terminus: bool, is_upper_terminus: bool, metapatches: bool) -> pyrosetta.rosetta.core.chemical.ResidueType

use efficient residue type finder to find simplest residue type with this AA & requested termini.

C++: core::pose::get_rsd_type_from_aa(const class core::chemical::ResidueTypeSet &, const enum core::chemical::AA &, const bool &, const bool &, const bool) –> class std::shared_ptr<const class core::chemical::ResidueType>

pyrosetta.rosetta.core.pose.get_score_line_string(pose: pyrosetta.rosetta.core.pose.Pose, key: str, val: str) → bool¶: C++: core::pose::get_score_line_string(const class core::pose::Pose &, const std::string &, std::string &) –> bool

pyrosetta.rosetta.core.pose.get_sequence_len(sequence_in: str) → int¶

Get the real length of a annotated sequence

C++: core::pose::get_sequence_len(const std::string &) –> unsigned long

pyrosetta.rosetta.core.pose.get_sha1_hash_excluding_chain(*args, **kwargs)¶

Overloaded function.

get_sha1_hash_excluding_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> str
get_sha1_hash_excluding_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose, extra_label: str) -> str

Get a value representing the position of all the atoms for residues which don’t have the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_sha1_hash_excluding_chain(const char &, const class core::pose::Pose &, const std::string &) –> std::string

get_sha1_hash_excluding_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> str
get_sha1_hash_excluding_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose, extra_label: str) -> str

Get a value representing the position of all the atoms for residues which don’t have the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_sha1_hash_excluding_chain(const std::string &, const class core::pose::Pose &, const std::string &) –> std::string

pyrosetta.rosetta.core.pose.get_sha1_hash_excluding_chains(*args, **kwargs)¶

Overloaded function.

get_sha1_hash_excluding_chains(chains: pyrosetta.rosetta.utility.vector1_std_string, pose: pyrosetta.rosetta.core.pose.Pose) -> str
get_sha1_hash_excluding_chains(chains: pyrosetta.rosetta.utility.vector1_std_string, pose: pyrosetta.rosetta.core.pose.Pose, extra_label: str) -> str

Get a value representing the position of all the atoms for residues which don’t have the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_sha1_hash_excluding_chains(const class utility::vector1<std::string, class std::allocator<std::string > > &, const class core::pose::Pose &, const std::string &) –> std::string

pyrosetta.rosetta.core.pose.get_sha1_hash_from_chain(*args, **kwargs)¶

Overloaded function.

get_sha1_hash_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> str
get_sha1_hash_from_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose, extra_label: str) -> str

Get a value representing the position of all the atoms for residues with the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_sha1_hash_from_chain(const char &, const class core::pose::Pose &, const std::string &) –> std::string

pyrosetta.rosetta.core.pose.get_sha1_hash_from_chains(*args, **kwargs)¶

Overloaded function.

get_sha1_hash_from_chains(chains: pyrosetta.rosetta.utility.vector1_std_string, pose: pyrosetta.rosetta.core.pose.Pose) -> str
get_sha1_hash_from_chains(chains: pyrosetta.rosetta.utility.vector1_std_string, pose: pyrosetta.rosetta.core.pose.Pose, extra_label: str) -> str

Get a value representing the position of all the atoms for residues with the given chain letters

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::get_sha1_hash_from_chains(const class utility::vector1<std::string, class std::allocator<std::string > > &, const class core::pose::Pose &, const std::string &) –> std::string

pyrosetta.rosetta.core.pose.hasPoseExtraScore(pose: pyrosetta.rosetta.core.pose.Pose, name: str) → bool¶

does this ExtraScore exist?

C++: core::pose::hasPoseExtraScore(const class core::pose::Pose &, const std::string &) –> bool

pyrosetta.rosetta.core.pose.hasPoseExtraScore_str(pose: pyrosetta.rosetta.core.pose.Pose, name: str) → bool¶

does this (string) ExtraScore exist?

C++: core::pose::hasPoseExtraScore_str(const class core::pose::Pose &, const std::string &) –> bool

pyrosetta.rosetta.core.pose.has_chain(*args, **kwargs)¶

Overloaded function.

has_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> bool

Does the pose have a residue with the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::has_chain(const std::string &, const class core::pose::Pose &) –> bool

has_chain(chain: str, pose: pyrosetta.rosetta.core.pose.Pose) -> bool

Does the pose have a residue with the given chain letter

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::has_chain(const char &, const class core::pose::Pose &) –> bool

has_chain(chain_id: int, pose: pyrosetta.rosetta.core.pose.Pose) -> bool

Does the pose have a residue with the given chain number

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

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

pyrosetta.rosetta.core.pose.initialize_atomid_map(*args, **kwargs)¶

Overloaded function.

initialize_atomid_map(atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: core::pose::initialize_atomid_map(class core::id::AtomID_Map<class core::id::AtomID> &, const class core::pose::Pose &) –> void

initialize_atomid_map(atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, pose: pyrosetta.rosetta.core.pose.Pose, value: pyrosetta.rosetta.core.id.AtomID) -> None

C++: core::pose::initialize_atomid_map(class core::id::AtomID_Map<class core::id::AtomID> &, const class core::pose::Pose &, const class core::id::AtomID &) –> void

initialize_atomid_map(atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, conformation: pyrosetta.rosetta.core.conformation.Conformation) -> None

C++: core::pose::initialize_atomid_map(class core::id::AtomID_Map<class core::id::AtomID> &, const class core::conformation::Conformation &) –> void

initialize_atomid_map(atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, conformation: pyrosetta.rosetta.core.conformation.Conformation, value: pyrosetta.rosetta.core.id.AtomID) -> None

C++: core::pose::initialize_atomid_map(class core::id::AtomID_Map<class core::id::AtomID> &, const class core::conformation::Conformation &, const class core::id::AtomID &) –> void

pyrosetta.rosetta.core.pose.initialize_atomid_map_AtomID(*args, **kwargs)¶

Overloaded function.

initialize_atomid_map_AtomID(atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: core::pose::initialize_atomid_map_AtomID(class core::id::AtomID_Map<class core::id::AtomID> &, const class core::pose::Pose &) –> void

initialize_atomid_map_AtomID(atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, pose: pyrosetta.rosetta.core.pose.Pose, value: pyrosetta.rosetta.core.id.AtomID) -> None

C++: core::pose::initialize_atomid_map_AtomID(class core::id::AtomID_Map<class core::id::AtomID> &, const class core::pose::Pose &, const class core::id::AtomID &) –> void

initialize_atomid_map_AtomID(atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, conformation: pyrosetta.rosetta.core.conformation.Conformation) -> None

C++: core::pose::initialize_atomid_map_AtomID(class core::id::AtomID_Map<class core::id::AtomID> &, const class core::conformation::Conformation &) –> void

initialize_atomid_map_AtomID(atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, conformation: pyrosetta.rosetta.core.conformation.Conformation, value: pyrosetta.rosetta.core.id.AtomID) -> None

C++: core::pose::initialize_atomid_map_AtomID(class core::id::AtomID_Map<class core::id::AtomID> &, const class core::conformation::Conformation &, const class core::id::AtomID &) –> void

pyrosetta.rosetta.core.pose.initialize_disulfide_bonds(*args, **kwargs)¶

Overloaded function.

initialize_disulfide_bonds(pose: pyrosetta.rosetta.core.pose.Pose) -> None

detect and fix disulfide bonds

C++: core::pose::initialize_disulfide_bonds(class core::pose::Pose &) –> void

initialize_disulfide_bonds(pose: pyrosetta.rosetta.core.pose.Pose, fd: pyrosetta.rosetta.core.io.StructFileRep) -> None

detect and fix disulfide bonds

C++: core::pose::initialize_disulfide_bonds(class core::pose::Pose &, const class core::io::StructFileRep &) –> void

pyrosetta.rosetta.core.pose.is_atom_axial_or_equatorial_to_ring(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int, query_atom: int, ring_atoms: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.core.chemical.rings.AxEqDesignation¶

Is the query atom in this pose residue axial or equatorial to the given ring or neither?

C++: core::pose::is_atom_axial_or_equatorial_to_ring(const class core::pose::Pose &, unsigned long, unsigned long, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> enum core::chemical::rings::AxEqDesignation

pyrosetta.rosetta.core.pose.is_ideal_pose(pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

Returns true if the <pose> geometry is ideal

The Pose to check.

true if all pose positions have ideal bond lengths and angles
up to some very small epsilon

C++: core::pose::is_ideal_pose(const class core::pose::Pose &) –> bool

pyrosetta.rosetta.core.pose.is_ideal_position(seqpos: int, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

Returns true if the <pose> geometry is ideal in position <seqpos>

The Pose to check.

true if position seqpos has ideal bond lengths and angles
up to some very small epsilon

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

pyrosetta.rosetta.core.pose.is_lower_terminus(pose: pyrosetta.rosetta.core.pose.Pose, resid: int) → bool¶

checks to see if this is a lower chain ending more intelligently than just checking residue variants

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

pyrosetta.rosetta.core.pose.is_position_conserved_residue(pose: pyrosetta.rosetta.core.pose.Pose, residue: int) → bool¶

Returns true if <residue> is positionally conserved, false otherwise: Based on the POSITION_CONSERVED_RESIDUES annotation stored in the Pose DataCache

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

pyrosetta.rosetta.core.pose.is_referencepose_number(str: str, refpose_string: str, refpose_resnumber: int, refpose_offset: int) → bool¶

Is a string of the format “refpose(<refposename>,<refposenumber>)” or “refpose(<refposename>,<refposenumber>)+/-<number>”?

If this successfully determines that this is a string of this format, it populates the refpose_string, refpose_resnumber,

and refpose_offset variables with the name of the ReferencePose, the number of the residue in the reference pose, and the +/- offset number parsed from this string.

Vikram K. Mulligan, Baker laboratory (vmullig.edu)

C++: core::pose::is_referencepose_number(const std::string &, std::string &, unsigned long &, long &) –> bool

pyrosetta.rosetta.core.pose.is_upper_terminus(pose: pyrosetta.rosetta.core.pose.Pose, resid: int) → bool¶

checks to see if this is a lower chain ending more intelligently than just checking residue variants

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

pyrosetta.rosetta.core.pose.jumps_from_pose(pose: pyrosetta.rosetta.core.pose.Pose, jumps: pyrosetta.rosetta.std.set_int_t) → None¶

Retrieves jump information from <pose>, storing the result in <jumps>.

Jumps are keyed by their jump id.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::jumps_from_pose(const class core::pose::Pose &, class std::set<int, struct std::less<int>, class std::allocator<int> > &) –> void

pyrosetta.rosetta.core.pose.just_modeling_RNA(sequence: str) → bool¶: C++: core::pose::just_modeling_RNA(const std::string &) –> bool

pyrosetta.rosetta.core.pose.make_atom_map(p: pyrosetta.rosetta.core.pose.Pose, m: pyrosetta.rosetta.core.pose.PoseCoordPickMode) → pyrosetta.rosetta.core.id.AtomID_Map_double_t¶: C++: core::pose::make_atom_map(const class core::pose::Pose &, enum core::pose::PoseCoordPickMode) –> class core::id::AtomID_Map<double>

pyrosetta.rosetta.core.pose.make_pose_from_saccharide_sequence(*args, **kwargs)¶

Overloaded function.

make_pose_from_saccharide_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet) -> None
make_pose_from_saccharide_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, auto_termini: bool) -> None
make_pose_from_saccharide_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, auto_termini: bool, idealize_linkages: bool) -> None

Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with ResidueTypeSet: <residue_set> and store it in <pose>.

C++: core::pose::make_pose_from_saccharide_sequence(class core::pose::Pose &, const std::string &, const class core::chemical::ResidueTypeSet &, const bool, const bool) –> void

make_pose_from_saccharide_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str) -> None
make_pose_from_saccharide_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, type_set_name: str) -> None
make_pose_from_saccharide_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, type_set_name: str, auto_termini: bool) -> None
make_pose_from_saccharide_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, type_set_name: str, auto_termini: bool, idealize_linkages: bool) -> None

Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name: <type_set_name> and store it in <pose>.

C++: core::pose::make_pose_from_saccharide_sequence(class core::pose::Pose &, const std::string &, const std::string &, const bool, const bool) –> void

pyrosetta.rosetta.core.pose.make_pose_from_sequence(*args, **kwargs)¶

Overloaded function.

make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, requested_types: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t) -> None
make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, requested_types: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t, auto_termini: bool) -> None

Creates a Pose from the annotated protein sequence <sequence>

with ResidueTypeSet <residue_set> and stores it in <pose>

: any existing data in <pose> is cleared, auto_termini

mark position 1, last_residue with lower, upper termini; default true

example(s):: make_pose_from_sequence(pose,”THANKSEVAN”,core::chemical::FA_STANDARD)
See also:: Pose PDBInfo pose_from_pdb pose_from_rcsb pose_from_sequence

C++: core::pose::make_pose_from_sequence(class core::pose::Pose &, class utility::vector1<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > >, const bool) –> void

make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet) -> None
make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, auto_termini: bool) -> None
make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, auto_termini: bool, metapatches: bool) -> None

C++: core::pose::make_pose_from_sequence(class core::pose::Pose &, const std::string &, const class core::chemical::ResidueTypeSet &, const bool, const bool) –> void

make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet) -> None
make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, auto_termini: bool) -> None
make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, auto_termini: bool, metapatches: bool) -> None

C++: core::pose::make_pose_from_sequence(class core::pose::Pose &, const std::string &, class std::shared_ptr<const class core::chemical::ResidueTypeSet>, const bool, const bool) –> void

make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, type_set_name: str) -> None
make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, type_set_name: str, auto_termini: bool) -> None
make_pose_from_sequence(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, type_set_name: str, auto_termini: bool, metapatches: bool) -> None

Creates a Pose from the annotated protein sequence <sequence>: with the desired <type_set_name> and stores it in <pose>
: any existing data in <pose> is cleared, auto_termini: mark position 1, last_residue with lower, upper termini; default true

C++: core::pose::make_pose_from_sequence(class core::pose::Pose &, const std::string &, const std::string &, const bool, const bool) –> void

pyrosetta.rosetta.core.pose.make_rid_posenum(resnum: int) → pyrosetta.rosetta.core.pose.ResidueIndexDescription¶

Convenience function for converting a Size (Pose numbered) into a ResidueIndexDescription

C++: core::pose::make_rid_posenum(unsigned long) –> class std::shared_ptr<const class core::pose::ResidueIndexDescription>

pyrosetta.rosetta.core.pose.mass(begin: int, end: int, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: core::pose::mass(unsigned long, const unsigned long, const class core::pose::Pose &) –> double

pyrosetta.rosetta.core.pose.named_atom_id_to_atom_id(*args, **kwargs)¶

Overloaded function.

named_atom_id_to_atom_id(named_atom_id: pyrosetta.rosetta.core.id.NamedAtomID, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.id.AtomID
named_atom_id_to_atom_id(named_atom_id: pyrosetta.rosetta.core.id.NamedAtomID, pose: pyrosetta.rosetta.core.pose.Pose, raise_exception: bool) -> pyrosetta.rosetta.core.id.AtomID

C++: core::pose::named_atom_id_to_atom_id(const class core::id::NamedAtomID &, const class core::pose::Pose &, bool) –> class core::id::AtomID

pyrosetta.rosetta.core.pose.named_stub_id_to_stub_id(named_stub_id: pyrosetta.rosetta.core.id.NamedStubID, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.id.StubID¶: C++: core::pose::named_stub_id_to_stub_id(const class core::id::NamedStubID &, const class core::pose::Pose &) –> class core::id::StubID

pyrosetta.rosetta.core.pose.noncanonical_atom_count(pose: pyrosetta.rosetta.core.pose.Pose) → int¶

count the number of non-canonical amino acids in thepose

C++: core::pose::noncanonical_atom_count(const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.noncanonical_chi_count(pose: pyrosetta.rosetta.core.pose.Pose) → int¶

count the number of non-canonical chi angles in the pose

C++: core::pose::noncanonical_chi_count(const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.noncanonical_residue_count(pose: pyrosetta.rosetta.core.pose.Pose) → int¶

count the number of non-canonical residues in the pose

C++: core::pose::noncanonical_residue_count(const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.nres_protein(pose: pyrosetta.rosetta.core.pose.Pose) → int¶

Number of protein residues in the pose

No virtuals, membrane residues or embedding residues counted

C++: core::pose::nres_protein(const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.num_atoms(begin: int, end: int, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: core::pose::num_atoms(unsigned long, const unsigned long, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.num_chi_angles(begin: int, end: int, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: core::pose::num_chi_angles(unsigned long, const unsigned long, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.num_hbond_acceptors(begin: int, end: int, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: core::pose::num_hbond_acceptors(unsigned long, const unsigned long, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.num_hbond_donors(begin: int, end: int, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: core::pose::num_hbond_donors(unsigned long, const unsigned long, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.num_heavy_atoms(begin: int, end: int, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: core::pose::num_heavy_atoms(unsigned long, const unsigned long, const class core::pose::Pose &) –> unsigned long

pyrosetta.rosetta.core.pose.parse_PDBnum_icode(token: str, fname: str, lineno: int, PDBnum: int, icode: str) → None¶

Take the string “token” and try to interpret it as a PDB identifier in the form of an: integer as well as an optional insertion code. For example the string “25A” would be interpretted as the residue 25 with the insertion code “A.” Throws an exception if the input string is misformatted.

C++: core::pose::parse_PDBnum_icode(const std::string &, const std::string &, const unsigned long, int &, char &) –> void

pyrosetta.rosetta.core.pose.parse_resnum(*args, **kwargs)¶

Overloaded function.

parse_resnum(resnum: str) -> pyrosetta.rosetta.core.pose.ResidueIndexDescription
parse_resnum(resnum: str, check_for_refpose: bool) -> pyrosetta.rosetta.core.pose.ResidueIndexDescription

Creates a ResidueIndexDescription from a string

Recognizes three forms of numbering:

Rosetta residue numbers (numbered sequentially from 1 to the last residue in the pose). These have the form [0-9]+

PDB numbers. These have the form [0-9]+[A-Z], where the trailing letter is the chain ID. IMPORTANT: This does not currently handle insertion codes.

Reference pose numbers. These have the form refpose([refpose name], [refpose number]).

In addition, relative numbers are permitted (of the form +[number] or -[number]) in conjunction with reference pose numbering. For example, one might say “refpose(state1,17)+3”, which means three residues past the residue correpsonding to residue 17 in the reference pose called “state1”.

a ResidueIndexDescription that will yield a residue number when applied to pose.
Returns a nullptr if there’s an error with parsing the string

C++: core::pose::parse_resnum(const std::string &, const bool) –> class std::shared_ptr<const class core::pose::ResidueIndexDescription>

parse_resnum(resnum: str, pose: pyrosetta.rosetta.core.pose.Pose) -> int
parse_resnum(resnum: str, pose: pyrosetta.rosetta.core.pose.Pose, check_for_refpose: bool) -> int

Extracts a residue number from a string.

Recognizes three forms of numbering:

Rosetta residue numbers (numbered sequentially from 1 to the last residue in the pose). These have the form [0-9]+

PDB numbers. These have the form [0-9]+[A-Z], where the trailing letter is the chain ID. IMPORTANT: This does not currently handle insertion codes.

Reference pose numbers. These have the form refpose([refpose name], [refpose number]).

In addition, relative numbers are permitted (of the form +[number] or -[number]) in conjunction with reference pose numbering. For example, one might say “refpose(state1,17)+3”, which means three residues past the residue correpsonding to residue 17 in the reference pose called “state1”.

the rosetta residue number for the string, or 0 upon an error

C++: core::pose::parse_resnum(const std::string &, const class core::pose::Pose &, const bool) –> unsigned long

pyrosetta.rosetta.core.pose.parse_sequence(sequence_in: str, fullname_list: pyrosetta.rosetta.utility.vector1_std_string, oneletter_to_fullname_index: pyrosetta.rosetta.std.vector_unsigned_long, one_letter_sequence: str) → None¶

Parse the input annotated sequence

C++: core::pose::parse_sequence(const std::string &, class utility::vector1<std::string, class std::allocator<std::string > > &, class std::vector<unsigned long, class std::allocator<unsigned long> > &, std::string &) –> void

pyrosetta.rosetta.core.pose.partition_pose_by_jump(src: pyrosetta.rosetta.core.pose.Pose, jump_number: int, partner1: pyrosetta.rosetta.core.pose.Pose, partner2: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_int¶: C++: core::pose::partition_pose_by_jump(const class core::pose::Pose &, const int, class core::pose::Pose &, class core::pose::Pose &) –> class utility::vector1<int, class std::allocator<int> >

pyrosetta.rosetta.core.pose.pdb_to_pose(*args, **kwargs)¶

Overloaded function.

pdb_to_pose(pose: pyrosetta.rosetta.core.pose.Pose, pdb_res: pyrosetta.rosetta.utility.vector1_int) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Convert PDB numbering to pose numbering. Must exist somewhere else, but I couldn’t find it. – rhiju

C++: core::pose::pdb_to_pose(const class core::pose::Pose &, const class utility::vector1<int, class std::allocator<int> > &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pdb_to_pose(pose: pyrosetta.rosetta.core.pose.Pose, pdb_res: Tuple[pyrosetta.rosetta.utility.vector1_int, pyrosetta.rosetta.utility.vector1_char, pyrosetta.rosetta.utility.vector1_std_string]) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Convert PDB numbering/chain to pose numbering. Must exist somewhere else, but I couldn’t find it. – rhiju

C++: core::pose::pdb_to_pose(const class core::pose::Pose &, const class std::tuple<class utility::vector1<int, class std::allocator<int> >, class utility::vector1<char, class std::allocator<char> >, class utility::vector1<std::string, class std::allocator<std::string > > > &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pdb_to_pose(pose: pyrosetta.rosetta.core.pose.Pose, res_num: int) -> int
pdb_to_pose(pose: pyrosetta.rosetta.core.pose.Pose, res_num: int, chain: str) -> int

Convert PDB numbering to pose numbering. Must exist somewhere else, but I couldn’t find it. – rhiju

C++: core::pose::pdb_to_pose(const class core::pose::Pose &, const int, const char) –> unsigned long

pyrosetta.rosetta.core.pose.pdbslice(*args, **kwargs)¶

Overloaded function.

pdbslice(new_pose: pyrosetta.rosetta.core.pose.Pose, pose: pyrosetta.rosetta.core.pose.Pose, slice_res: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

Create a subpose of the src pose – figures out a reasonable fold tree.

C++: core::pose::pdbslice(class core::pose::Pose &, const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

pdbslice(pose: pyrosetta.rosetta.core.pose.Pose, slice_res: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

Create a subpose of the src pose – figures out a reasonable fold tree.

C++: core::pose::pdbslice(class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

pyrosetta.rosetta.core.pose.pose_from_saccharide_sequence(*args, **kwargs)¶

Overloaded function.

pose_from_saccharide_sequence(sequence: str) -> pyrosetta.rosetta.core.pose.Pose
pose_from_saccharide_sequence(sequence: str, type_set_name: str) -> pyrosetta.rosetta.core.pose.Pose
pose_from_saccharide_sequence(sequence: str, type_set_name: str, auto_termini: bool) -> pyrosetta.rosetta.core.pose.Pose
pose_from_saccharide_sequence(sequence: str, type_set_name: str, auto_termini: bool, idealize_linkages: bool) -> pyrosetta.rosetta.core.pose.Pose

Return a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name: <type_set_name>.

C++: core::pose::pose_from_saccharide_sequence(const std::string &, const std::string &, const bool, const bool) –> class std::shared_ptr<class core::pose::Pose>

pyrosetta.rosetta.core.pose.pose_max_nbr_radius(pose: pyrosetta.rosetta.core.pose.Pose) → float¶

returns a Distance

C++: core::pose::pose_max_nbr_radius(const class core::pose::Pose &) –> double

pyrosetta.rosetta.core.pose.pose_residue_is_terminal(pose: pyrosetta.rosetta.core.pose.Pose, resid: int) → bool¶

returns true if the given residue in the pose is a chain ending or has upper/lower terminal variants

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

pyrosetta.rosetta.core.pose.pose_to_pdb(pose: pyrosetta.rosetta.core.pose.Pose, pose_res: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Convert pose numbering to pdb numbering. Must exist somewhere else, but I couldn’t find it. – rhiju

C++: core::pose::pose_to_pdb(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.radius_of_gyration(pose: pyrosetta.rosetta.core.pose.Pose, center_of_mass: pyrosetta.rosetta.numeric.xyzVector_double_t, residues: pyrosetta.rosetta.utility.vector1_bool) → float¶

Get the radius of gyration of the selected residues

WARNING: Despite the name, this function only calculates with a single coordinate per residue (the Calpha/neighbor atom)

Requires the center_of_mass as an input because often people will want
both com and rg and this ensures that we only calculate com once.

C++: core::pose::radius_of_gyration(const class core::pose::Pose &, const class numeric::xyzVector<double> &, const class utility::vector1<bool, class std::allocator<bool> > &) –> double

pyrosetta.rosetta.core.pose.read_comment_pdb(file_name: str, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Reads the comments from the pdb file and adds it into comments

C++: core::pose::read_comment_pdb(const std::string &, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.read_psipred_ss2_file(*args, **kwargs)¶

Overloaded function.

read_psipred_ss2_file(pose: pyrosetta.rosetta.core.pose.Pose, filename: str) -> pyrosetta.rosetta.utility.vector1_char

C++: core::pose::read_psipred_ss2_file(const class core::pose::Pose &, const std::string &) –> class utility::vector1<char, class std::allocator<char> >

read_psipred_ss2_file(pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_char

C++: core::pose::read_psipred_ss2_file(const class core::pose::Pose &) –> class utility::vector1<char, class std::allocator<char> >

pyrosetta.rosetta.core.pose.remove_ligand_canonical_residues(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

this function removes all residues with both UPPER and LOWER terminus types. This is intended for removing ligands that are canonical residues.

C++: core::pose::remove_ligand_canonical_residues(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.remove_lower_terminus_type_from_pose_residue(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶: C++: core::pose::remove_lower_terminus_type_from_pose_residue(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.remove_nonprotein_residues(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

this function removes all residues from the pose which are not protein residues. This removal includes, but is not limited to, metals, DNA, RNA, and ligands. It will NOT remove ligands which are canonical residues (for example, if a protein binds an alanine monomer, the monomer will be untouched).

C++: core::pose::remove_nonprotein_residues(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.remove_upper_terminus_type_from_pose_residue(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶: C++: core::pose::remove_upper_terminus_type_from_pose_residue(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.remove_variant_type_from_pose_residue(pose: pyrosetta.rosetta.core.pose.Pose, variant_type: pyrosetta.rosetta.core.chemical.VariantType, seqpos: int) → None¶

Construct a non-variant of an existing pose residue.

C++: core::pose::remove_variant_type_from_pose_residue(class core::pose::Pose &, const enum core::chemical::VariantType, const unsigned long) –> void

pyrosetta.rosetta.core.pose.remove_variant_type_from_residue(old_rsd: pyrosetta.rosetta.core.conformation.Residue, variant_type: pyrosetta.rosetta.core.chemical.VariantType, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.conformation.Residue¶

Remove variant from an existing residue.

C++: core::pose::remove_variant_type_from_residue(const class core::conformation::Residue &, const enum core::chemical::VariantType, const class core::pose::Pose &) –> class std::shared_ptr<class core::conformation::Residue>

pyrosetta.rosetta.core.pose.remove_virtual_residues(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Removes all virtual residues from <pose>

C++: core::pose::remove_virtual_residues(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.renumber_pdbinfo_based_on_conf_chains(*args, **kwargs)¶

Overloaded function.

renumber_pdbinfo_based_on_conf_chains(pose: pyrosetta.rosetta.core.pose.Pose) -> bool
renumber_pdbinfo_based_on_conf_chains(pose: pyrosetta.rosetta.core.pose.Pose, fix_chains: bool) -> bool
renumber_pdbinfo_based_on_conf_chains(pose: pyrosetta.rosetta.core.pose.Pose, fix_chains: bool, start_from_existing_numbering: bool) -> bool
renumber_pdbinfo_based_on_conf_chains(pose: pyrosetta.rosetta.core.pose.Pose, fix_chains: bool, start_from_existing_numbering: bool, keep_insertion_codes: bool) -> bool
renumber_pdbinfo_based_on_conf_chains(pose: pyrosetta.rosetta.core.pose.Pose, fix_chains: bool, start_from_existing_numbering: bool, keep_insertion_codes: bool, rotate_chain_ids: bool) -> bool

renumber PDBInfo based on Conformation chains; each chain starts from 1

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

The Pose to modify.

If true, the procedure will attempt to fix any empty record
characters it finds in the PDBInfo. (default true)

If true, will attempt to start each
chain from the existing numbering in the PDBInfo. E.g. if the first residue of chain 2 in the Conformation is 27, then the renumbering of the chain in PDBInfo will start from 27. (default true)

If true, will maintain insertion codes and
will not increment the pdb residue numbering for those residues. This means new numbering with insertion codes will only reflect properly if the old numbering included the base numbering of the insertion code residues, i.e. 100 100A 100B and not just 100A 100B (with 100 never appearing). (default false)

If true, allows support for more than 26 pdb chains
by rotating [A,Z] continuously. WARNING: This will break the assumption made by the PDBPoseMap that each pdb chain id is unique, so make sure you are not using the PDBPoseMap feature downstream in your code path without corrections! (default false)

If fixing chains and there is only one chain and the PDBInfo exists
but all records are marked as empty, will renumber and set the PDBInfo chain to ‘A’.

true if renumbering successful, false otherwise

C++: core::pose::renumber_pdbinfo_based_on_conf_chains(class core::pose::Pose &, bool, const bool, const bool, const bool) –> bool

pyrosetta.rosetta.core.pose.reorder_root_partition_res(root_partition_res: pyrosetta.rosetta.utility.vector1_unsigned_long, res_list: pyrosetta.rosetta.utility.vector1_unsigned_long, fixed_domain_map: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: core::pose::reorder_root_partition_res(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.pose.replace_pose_residue_copying_existing_coordinates(*args, **kwargs)¶

Overloaded function.

replace_pose_residue_copying_existing_coordinates(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int, new_rsd_type: pyrosetta.rosetta.core.chemical.ResidueType) -> None

C++: core::pose::replace_pose_residue_copying_existing_coordinates(class core::pose::Pose &, const unsigned long, const class core::chemical::ResidueType &) –> void

replace_pose_residue_copying_existing_coordinates(pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int, new_rsd_type: pyrosetta.rosetta.core.chemical.ResidueType, mapping: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: core::pose::replace_pose_residue_copying_existing_coordinates(class core::pose::Pose &, const unsigned long, const class core::chemical::ResidueType &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

pyrosetta.rosetta.core.pose.reroot(pose: pyrosetta.rosetta.core.pose.Pose, root_partition_res: pyrosetta.rosetta.utility.vector1_unsigned_long, res_list: pyrosetta.rosetta.utility.vector1_unsigned_long, preferred_root_res: pyrosetta.rosetta.utility.vector1_unsigned_long, fixed_domain_map: pyrosetta.rosetta.utility.vector1_unsigned_long, cutpoint_open_in_full_model: pyrosetta.rosetta.utility.vector1_unsigned_long, working_res: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶: C++: core::pose::reroot(class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

pyrosetta.rosetta.core.pose.res_in_chain(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, chain: str) → bool¶

Does this residue number have this chain letter?

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::pose::res_in_chain(const class core::pose::Pose &, unsigned long, const std::string &) –> bool

pyrosetta.rosetta.core.pose.residue_center_of_mass(*args, **kwargs)¶

Overloaded function.

residue_center_of_mass(pose: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.utility.vector1_bool) -> int

C++: core::pose::residue_center_of_mass(const class core::pose::Pose &, class utility::vector1<bool, class std::allocator<bool> >) –> int

residue_center_of_mass(pose: pyrosetta.rosetta.core.pose.Pose, start: int, stop: int) -> int

C++: core::pose::residue_center_of_mass(const class core::pose::Pose &, const int, const int) –> int

pyrosetta.rosetta.core.pose.residue_types_from_saccharide_sequence(sequence: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t¶

Return a list of carbohydrate ResidueTypes corresponding to an annotated, linear, IUPAC polysaccharide sequence.

an annotated IUPAC polysaccharide sequence, e.g., “alpha-D-Glcp-(1->4)-alpha-D-Glcp-(1->4)-D-Glcp”

the desired residue set

a 1-indexed vector of ResidueType owning pointers, in Rosetta order.

That is, the first residue will be the reducing end (the last residue in the sequence), and all branches will be consecutive, with earlier branches earlier in set of residue types.

Format for <sequence>:

Prefixes apply to the residue to which they are attached, below indicated by residue n. Residues are listed from N to 1, where N is the total number of residues in the saccharide. The sequence is parsed by reading to the next hyphen, so hyphens are crucial. Linkage indication: “(a->x)-” specifies the linkage of residue n, where a is the anomeric carbon number of residue (n+1) and x is the oxygen number of residue n. The first residue listed in the annotated sequence (residue N) need not have the linkage prefix. A ->4) ResidueType will automatically be assigned by default if not specified. Anomer indication: The strings “alpha-” or “beta-” are supplied next, which determines the stereochemistry of the anomeric carbon of the residue to which it is prefixed. An alpha ResidueType will automatically be assigned by default. Stereochemical indication: “L-” or “D-” specifies whether residue n is an L- or D-sugar. The default is “D-“. 3-Letter code: A three letter code (in sentence case) MUST be supplied next. This specifies the “base sugar name”, e.g., Glc is for glucose. (A list of all recognized 3-letter codes for sugars can be found in the database.) 1-Letter suffix: If no suffix follows, residue n will be linear. If a letter is present, it indicates the ring size, where “f” is furanose, “p” is pyranose, and “s” is septanose. Branches are indicated using nested brackets and are best explained by example: beta-D-Galp-(1->4)-[alpha-L-Fucp-(1->3)]-D-GlcpNAc is: beta-D-Galp-(1->4)-D-GlcpNAc

alpha-L-Fucp-(1->3)

make_pose_from_saccharide_sequence() will generate a pose with a proper lower terminus. glycosylate_pose() will append the fragment by bond.

C++: core::pose::residue_types_from_saccharide_sequence(const std::string &, const class core::chemical::ResidueTypeSet &) –> class utility::vector1<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > >

pyrosetta.rosetta.core.pose.residue_types_from_sequence(*args, **kwargs)¶

Overloaded function.

residue_types_from_sequence(sequence_in: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t
residue_types_from_sequence(sequence_in: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, auto_termini: bool) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t
residue_types_from_sequence(sequence_in: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet, auto_termini: bool, metapatches: bool) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t

return a list of ResidueTypes corresponding to an annotated protein sequence

an annotated sequence

the desired residue set

mark position 1, last_residue with lower, upper termini; default true

C++: core::pose::residue_types_from_sequence(const std::string &, const class core::chemical::ResidueTypeSet &, const bool, const bool) –> class utility::vector1<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > >

pyrosetta.rosetta.core.pose.return_nearest_residue(*args, **kwargs)¶

Overloaded function.

return_nearest_residue(pose: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.utility.vector1_bool, center: pyrosetta.rosetta.numeric.xyzVector_double_t) -> int

C++: core::pose::return_nearest_residue(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class numeric::xyzVector<double>) –> int

return_nearest_residue(pose: pyrosetta.rosetta.core.pose.Pose, begin: int, end: int, center: pyrosetta.rosetta.numeric.xyzVector_double_t) -> int

C++: core::pose::return_nearest_residue(const class core::pose::Pose &, const int, const int, class numeric::xyzVector<double>) –> int

pyrosetta.rosetta.core.pose.saved_native_pose(*args, **kwargs)¶

Overloaded function.

saved_native_pose(data_map: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.pose.Pose
saved_native_pose(data_map: pyrosetta.rosetta.basic.datacache.DataMap, resource_str: str) -> pyrosetta.rosetta.core.pose.Pose

Retrieve the native pose from the DataMap which is added through the OptionsCollection

during RosettaScript parsing as a resource.

If the resource is not present, will return a nullptr.

C++: core::pose::saved_native_pose(class basic::datacache::DataMap &, const std::string &) –> class std::shared_ptr<const class core::pose::Pose>

pyrosetta.rosetta.core.pose.saved_reference_pose(*args, **kwargs)¶

Overloaded function.

saved_reference_pose(in_tag: pyrosetta.rosetta.utility.tag.Tag, data_map: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.pose.Pose
saved_reference_pose(in_tag: pyrosetta.rosetta.utility.tag.Tag, data_map: pyrosetta.rosetta.basic.datacache.DataMap, tag_str: str) -> pyrosetta.rosetta.core.pose.Pose

C++: core::pose::saved_reference_pose(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const std::string &) –> class std::shared_ptr<class core::pose::Pose>

pyrosetta.rosetta.core.pose.sequence_map_from_pdbinfo(first: pyrosetta.rosetta.core.pose.Pose, second: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.id.SequenceMapping¶

Create a sequence map of first pose onto the second, matching the PDBInfo: If the PDBInfo of either Pose is missing or invalid, do a simple sequence alignment matching.

C++: core::pose::sequence_map_from_pdbinfo(const class core::pose::Pose &, const class core::pose::Pose &) –> class core::id::SequenceMapping

pyrosetta.rosetta.core.pose.setPoseExtraScore(*args, **kwargs)¶

Overloaded function.

setPoseExtraScore(pose: pyrosetta.rosetta.core.pose.Pose, name: str, value: float) -> None

Set a core::Real in the pose datacache, that will be output as a score in the scorefile.

C++: core::pose::setPoseExtraScore(class core::pose::Pose &, const std::string &, double) –> void

setPoseExtraScore(pose: pyrosetta.rosetta.core.pose.Pose, name: str, value: str) -> None

Set a string in the pose datacache, that will be output as a score in the scorefile.

C++: core::pose::setPoseExtraScore(class core::pose::Pose &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.core.pose.set_bb_torsion(torsion_id: int, pose: pyrosetta.rosetta.core.pose.Pose, sequence_position: int, new_angle: float) → None¶

Set the BB torsion, phi, psi, omega (see core::types).: Works with carbohydrates. Think about moving this to pose itself.

C++: core::pose::set_bb_torsion(unsigned long, class core::pose::Pose &, unsigned long, double) –> void

pyrosetta.rosetta.core.pose.set_bfactors_from_atom_id_map(pose: pyrosetta.rosetta.core.pose.Pose, bfactors: pyrosetta.rosetta.core.id.AtomID_Map_double_t) → None¶

Set bfactors in a pose PDBInfo

C++: core::pose::set_bfactors_from_atom_id_map(class core::pose::Pose &, const class core::id::AtomID_Map<double> &) –> void

pyrosetta.rosetta.core.pose.set_output_res_and_chain(extended_pose: pyrosetta.rosetta.core.pose.Pose, output_resnum_and_chain_and_segid: Tuple[pyrosetta.rosetta.utility.vector1_int, pyrosetta.rosetta.utility.vector1_char, pyrosetta.rosetta.utility.vector1_std_string]) → None¶: C++: core::pose::set_output_res_and_chain(class core::pose::Pose &, const class std::tuple<class utility::vector1<int, class std::allocator<int> >, class utility::vector1<char, class std::allocator<char> >, class utility::vector1<std::string, class std::allocator<std::string > > > &) –> void

pyrosetta.rosetta.core.pose.set_reasonable_fold_tree(pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::pose::set_reasonable_fold_tree(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.set_ss_from_phipsi(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Analyzes <pose> residue phi/psi sets and guesses the secondary: structure, ideally dssp should be used for that

C++: core::pose::set_ss_from_phipsi(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.setup_dof_mask_from_move_map(mm: core::kinematics::MoveMap, pose: pyrosetta.rosetta.core.pose.Pose, dof_mask: pyrosetta.rosetta.core.id.DOF_ID_Map_bool_t) → None¶

convert from allow-bb/allow-chi MoveMap to simple DOF_ID boolean mask needed by the minimizer

C++: core::pose::setup_dof_mask_from_move_map(const class core::kinematics::MoveMap &, const class core::pose::Pose &, class core::id::DOF_ID_Map<bool> &) –> void

pyrosetta.rosetta.core.pose.setup_dof_to_torsion_map(pose: pyrosetta.rosetta.core.pose.Pose, dof_map: pyrosetta.rosetta.core.id.DOF_ID_Map_core_id_TorsionID_t) → None¶

set up a map to look up TORSION_ID by DOF_ID (Map[DOF_ID] = TORISION_ID)

C++: core::pose::setup_dof_to_torsion_map(const class core::pose::Pose &, class core::id::DOF_ID_Map<class core::id::TorsionID> &) –> void

pyrosetta.rosetta.core.pose.show_adjacent_nt_connections(pose: pyrosetta.rosetta.core.pose.Pose, res: int) → None¶: C++: core::pose::show_adjacent_nt_connections(const class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.core.pose.sort_pose_by_score(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: core::pose::sort_pose_by_score(const class std::shared_ptr<class core::pose::Pose> &, const class std::shared_ptr<class core::pose::Pose> &) –> bool

pyrosetta.rosetta.core.pose.stepwise_addable_pose_residue(n: int, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: core::pose::stepwise_addable_pose_residue(const unsigned long, const class core::pose::Pose &) –> bool

pyrosetta.rosetta.core.pose.stepwise_addable_residue(n: int, non_standard_residue_map: pyrosetta.rosetta.std.map_unsigned_long_std_string) → bool¶: C++: core::pose::stepwise_addable_residue(const unsigned long, const class std::map<unsigned long, std::string, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, std::string > > > &) –> bool

pyrosetta.rosetta.core.pose.stub_id_to_named_stub_id(stub_id: pyrosetta.rosetta.core.id.StubID, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.id.NamedStubID¶: C++: core::pose::stub_id_to_named_stub_id(const class core::id::StubID &, const class core::pose::Pose &) –> class core::id::NamedStubID

pyrosetta.rosetta.core.pose.swap_transform(jump_num: int, xform: pyrosetta.rosetta.core.kinematics.RT, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Updates the rigid-body transform of the specified jump in <pose>

C++: core::pose::swap_transform(unsigned long, const class core::kinematics::RT &, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.tag_from_pose(pose: pyrosetta.rosetta.core.pose.Pose) → str¶: C++: core::pose::tag_from_pose(const class core::pose::Pose &) –> std::string

pyrosetta.rosetta.core.pose.tag_into_pose(pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None¶: C++: core::pose::tag_into_pose(class core::pose::Pose &, const std::string &) –> void

pyrosetta.rosetta.core.pose.total_energy_from_pose(pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: core::pose::total_energy_from_pose(const class core::pose::Pose &) –> double

pyrosetta.rosetta.core.pose.transfer_jumps(srcpose: pyrosetta.rosetta.core.pose.Pose, tgtpose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::pose::transfer_jumps(const class core::pose::Pose &, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.transfer_phi_psi(*args, **kwargs)¶

Overloaded function.

transfer_phi_psi(srcpose: pyrosetta.rosetta.core.pose.Pose, tgtpose: pyrosetta.rosetta.core.pose.Pose, ir: int, jr: int) -> None

C++: core::pose::transfer_phi_psi(const class core::pose::Pose &, class core::pose::Pose &, unsigned long, unsigned long) –> void

transfer_phi_psi(srcpose: pyrosetta.rosetta.core.pose.Pose, tgtpose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: core::pose::transfer_phi_psi(const class core::pose::Pose &, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.pose.update_cutpoint_virtual_atoms_if_connected(*args, **kwargs)¶

Overloaded function.

update_cutpoint_virtual_atoms_if_connected(pose: pyrosetta.rosetta.core.pose.Pose, cutpoint_res: int) -> None
update_cutpoint_virtual_atoms_if_connected(pose: pyrosetta.rosetta.core.pose.Pose, cutpoint_res: int, recurse: bool) -> None

Given a pose and a position that may or may not be CUTPOINT_UPPER or CUTPOINT_LOWER, determine whether this

position has either of these variant types, and if it does, determine whether it’s connected to anything. If it is, update the C-OVL1-OVL2 bond lengths and bond angle (for CUTPOINT_LOWER) or OVU1-N bond length (for CUTPOINT_UPPER) to match any potentially non-ideal geometry in the residue to which it’s bonded.

Requires a little bit of special-casing for gamma-amino acids. Throws an exception if the residue to which a CUTPOINT_LOWER is bonded does not have an “N” and a “CA” or “C4”. Safe to call repeatedly, or if cutpoint variant types are absent; in these cases, the function does nothing.

By default, this function calls itself again once on residues to which this residue is connected, to update their geometry. Set recurse=false to disable this.

Vikram K. Mulligan (vmullig.edu).

C++: core::pose::update_cutpoint_virtual_atoms_if_connected(class core::pose::Pose &, const unsigned long, bool) –> void

pyrosetta.rosetta.core.pose.virtual_type_for_pose(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.chemical.ResidueType¶

Return the appropritate ResidueType for the virtual residue for the i: “mode” (fullatom, centroid …) the pose is in.

C++: core::pose::virtual_type_for_pose(const class core::pose::Pose &) –> class std::shared_ptr<const class core::chemical::ResidueType>

class pyrosetta.rosetta.core.pose.xyzStripeHashPose¶

Bases: xyzStripeHash

add_pose(*args, **kwargs)¶

Overloaded function.

add_pose(self: pyrosetta.rosetta.core.pose.xyzStripeHashPose, p: pyrosetta.rosetta.core.pose.Pose, amap: pyrosetta.rosetta.core.id.AtomID_Map_double_t) -> None

C++: core::pose::xyzStripeHashPose::add_pose(const class core::pose::Pose &, const class core::id::AtomID_Map<double> &) –> void

add_pose(self: pyrosetta.rosetta.core.pose.xyzStripeHashPose, p: pyrosetta.rosetta.core.pose.Pose) -> None
add_pose(self: pyrosetta.rosetta.core.pose.xyzStripeHashPose, p: pyrosetta.rosetta.core.pose.Pose, m: pyrosetta.rosetta.core.pose.PoseCoordPickMode) -> None

C++: core::pose::xyzStripeHashPose::add_pose(const class core::pose::Pose &, enum core::pose::PoseCoordPickMode) –> void

assign(self: pyrosetta.rosetta.core.pose.xyzStripeHashPose, : pyrosetta.rosetta.core.pose.xyzStripeHashPose) → pyrosetta.rosetta.core.pose.xyzStripeHashPose¶: C++: core::pose::xyzStripeHashPose::operator=(const class core::pose::xyzStripeHashPose &) –> class core::pose::xyzStripeHashPose &

ball(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, ib: int) → pyrosetta.rosetta.numeric.geometry.hashing.Ball¶: C++: numeric::geometry::hashing::xyzStripeHash::ball(const unsigned long &) const –> const struct numeric::geometry::hashing::Ball &

clash(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v_in: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::geometry::hashing::xyzStripeHash::clash(const class numeric::xyzVector<float> &) const –> bool

clash_amount(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v_in: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::geometry::hashing::xyzStripeHash::clash_amount(const class numeric::xyzVector<float> &) const –> float

clash_check_ball(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, b: pyrosetta.rosetta.numeric.geometry.hashing.Ball) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::clash_check_ball(const struct numeric::geometry::hashing::Ball &) const –> int

clash_check_residue_pairs(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, test_balls: pyrosetta.rosetta.utility.vector1_numeric_geometry_hashing_Ball, residue_pairs: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) → bool¶: C++: numeric::geometry::hashing::xyzStripeHash::clash_check_residue_pairs(const class utility::vector1<struct numeric::geometry::hashing::Ball, class std::allocator<struct numeric::geometry::hashing::Ball> > &, class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) const –> bool

clash_not_resid(*args, **kwargs)¶

Overloaded function.

clash_not_resid(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v_in: pyrosetta.rosetta.numeric.xyzVector_float_t, resid: int) -> bool
clash_not_resid(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v_in: pyrosetta.rosetta.numeric.xyzVector_float_t, resid: int, resid2: int) -> bool

C++: numeric::geometry::hashing::xyzStripeHash::clash_not_resid(const class numeric::xyzVector<float> &, const int &, const int &) const –> bool

clash_raw(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::geometry::hashing::xyzStripeHash::clash_raw(const class numeric::xyzVector<float> &) const –> bool

class const_iterator¶

Bases: pybind11_object

arrow(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash.const_iterator) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::geometry::hashing::xyzStripeHash::const_iterator::operator->() –> const class numeric::xyzVector<float> *

dereference(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash.const_iterator) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::geometry::hashing::xyzStripeHash::const_iterator::operator*() –> const class numeric::xyzVector<float> &

radius(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash.const_iterator) → float¶: C++: numeric::geometry::hashing::xyzStripeHash::const_iterator::radius() –> float

debug_pdb(*args, **kwargs)¶

Overloaded function.

debug_pdb(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) -> str
debug_pdb(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, x: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> str

C++: numeric::geometry::hashing::xyzStripeHash::debug_pdb(const class numeric::xyzTransform<double> &) const –> std::string

static extract_pose_balls(*args, **kwargs)¶

Overloaded function.

extract_pose_balls(p: pyrosetta.rosetta.core.pose.Pose, balls: pyrosetta.rosetta.utility.vector1_numeric_geometry_hashing_Ball) -> None
extract_pose_balls(p: pyrosetta.rosetta.core.pose.Pose, balls: pyrosetta.rosetta.utility.vector1_numeric_geometry_hashing_Ball, m: pyrosetta.rosetta.core.pose.PoseCoordPickMode) -> None

C++: core::pose::xyzStripeHashPose::extract_pose_balls(const class core::pose::Pose &, class utility::vector1<struct numeric::geometry::hashing::Ball, class std::allocator<struct numeric::geometry::hashing::Ball> > &, enum core::pose::PoseCoordPickMode) –> void

extract_pose_balls(p: pyrosetta.rosetta.core.pose.Pose, balls: pyrosetta.rosetta.utility.vector1_numeric_geometry_hashing_Ball, amap: pyrosetta.rosetta.core.id.AtomID_Map_double_t) -> None

C++: core::pose::xyzStripeHashPose::extract_pose_balls(const class core::pose::Pose &, class utility::vector1<struct numeric::geometry::hashing::Ball, class std::allocator<struct numeric::geometry::hashing::Ball> > &, const class core::id::AtomID_Map<double> &) –> void

fill_pairs(*args, **kwargs)¶

Overloaded function.

fill_pairs(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v: pyrosetta.rosetta.numeric.xyzVector_float_t, ir: int, pairs: pyrosetta.rosetta.utility.vector1_std_pair_int_int_t) -> None
fill_pairs(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v: pyrosetta.rosetta.numeric.xyzVector_float_t, ir: int, pairs: pyrosetta.rosetta.utility.vector1_std_pair_int_int_t, maxd2: float) -> None

C++: numeric::geometry::hashing::xyzStripeHash::fill_pairs(const class numeric::xyzVector<float> &, const int &, class utility::vector1<struct std::pair<int, int>, class std::allocator<struct std::pair<int, int> > > &, float) const –> void

grid_atoms(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → pyrosetta.rosetta.numeric.geometry.hashing.Ball¶: C++: numeric::geometry::hashing::xyzStripeHash::grid_atoms() const –> const struct numeric::geometry::hashing::Ball *

grid_size(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → float¶: C++: numeric::geometry::hashing::xyzStripeHash::grid_size() const –> float

grid_size2(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → float¶: C++: numeric::geometry::hashing::xyzStripeHash::grid_size2() const –> float

init(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, balls: pyrosetta.rosetta.utility.vector1_numeric_geometry_hashing_Ball) → None¶: C++: numeric::geometry::hashing::xyzStripeHash::init(const class utility::vector1<struct numeric::geometry::hashing::Ball, class std::allocator<struct numeric::geometry::hashing::Ball> > &) –> void

init_posehash(self: pyrosetta.rosetta.core.pose.xyzStripeHashPose) → None¶: C++: core::pose::xyzStripeHashPose::init_posehash() –> void

class iter_base_numeric_geometry_hashing_xyzStripeHash_const_iterator_t¶: Bases: pybind11_object

natom(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::natom() const –> int

nbcount(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v_in: pyrosetta.rosetta.numeric.xyzVector_float_t) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::nbcount(const class numeric::xyzVector<float> &) const –> int

nbcount_raw(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::nbcount_raw(const class numeric::xyzVector<float> &) const –> int

resi(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, ib: int) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::resi(const unsigned long &) const –> unsigned long

sanity_check(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → bool¶: C++: numeric::geometry::hashing::xyzStripeHash::sanity_check() const –> bool

size(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::size() const –> unsigned long

translation(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::geometry::hashing::xyzStripeHash::translation() const –> const class numeric::xyzVector<float> &

translation_real(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::geometry::hashing::xyzStripeHash::translation_real() const –> class numeric::xyzVector<double>

xdim(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::xdim() const –> int

xyz(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash, ib: int) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::geometry::hashing::xyzStripeHash::xyz(const unsigned long &) const –> class numeric::xyzVector<float>

ydim(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::ydim() const –> int

zdim(self: pyrosetta.rosetta.numeric.geometry.hashing.xyzStripeHash) → int¶: C++: numeric::geometry::hashing::xyzStripeHash::zdim() const –> int