rosetta.core.pose._core_pose_ API documentation

var PoseCoordPickMode_ALL

var PoseCoordPickMode_BB

var PoseCoordPickMode_BNP

var PoseCoordPickMode_CA

var PoseCoordPickMode_CB

var PoseCoordPickMode_CB_else_CA

var PoseCoordPickMode_CBorCA

var PoseCoordPickMode_HVY

var PoseCoordPickMode_HVY_IF_NP

var PoseCoordPickMode_NBR

var PoseCoordPickMode_NUL

var PoseCoordPickMode_N_CA_C

var PoseCoordPickMode_N_CA_C_CB

var PoseCoordPickMode_N_C_O

def QQQ_PosePyObserverTesterFunction(

...)

QQQ_PosePyObserverTesterFunction() -> None :

C++ signature : void QQQ_PosePyObserverTesterFunction()

def addVirtualResAsRoot(

...)

addVirtualResAsRoot( (xyzVector_Real)xyz, (Pose)pose) -> None : Adds a virtual residue to the end of the pose at the specified location. Roots the structure on this residue.

C++ signature :
    void addVirtualResAsRoot(numeric::xyzVector<double>,core::pose::Pose {lvalue})

addVirtualResAsRoot( (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++ signature :
    void addVirtualResAsRoot(core::pose::Pose {lvalue})

def add_comment(

...)

add_comment( (Pose)pose, (str)key, (str)val) -> 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++ signature : void add_comment(core::pose::Pose {lvalue},std::string,std::string)

def add_lower_terminus_type_to_pose_residue(

...)

add_lower_terminus_type_to_pose_residue( (Pose)pose, (int)seqpos) -> None : core/pose/util.hh:436

C++ signature : void add_lower_terminus_type_to_pose_residue(core::pose::Pose {lvalue},unsigned long)

def add_score_line_string(

...)

add_score_line_string( (Pose)pose, (str)key, (str)val) -> None : Dumps a pdb with comments at end of file 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++ signature : void add_score_line_string(core::pose::Pose {lvalue},std::string,std::string)

def add_upper_terminus_type_to_pose_residue(

...)

add_upper_terminus_type_to_pose_residue( (Pose)pose, (int)seqpos) -> None : core/pose/util.hh:443

C++ signature : void add_upper_terminus_type_to_pose_residue(core::pose::Pose {lvalue},unsigned long)

def add_variant_type_to_pose_residue(

...)

add_variant_type_to_pose_residue( (Pose)pose, (VariantType)variant_type, (int)seqpos) -> None : Construct a variant of an existing pose residue.

C++ signature : void add_variant_type_to_pose_residue(core::pose::Pose {lvalue},core::chemical::VariantType,unsigned long)

def add_variant_type_to_residue(

...)

add_variant_type_to_residue( (Residue)old_rsd, (VariantType)variant_type, (Pose)pose) -> Residue : Construct a variant of an existing residue.

C++ signature : boost::shared_ptr add_variant_type_to_residue(core::conformation::Residue,core::chemical::VariantType,core::pose::Pose)

def annotated_to_oneletter_sequence(

...)

annotated_to_oneletter_sequence( (str)annotated_seq) -> str : Returns the oneletter_sequence that corresponds to the given annotated sequence.

C++ signature : std::string annotated_to_oneletter_sequence(std::string)

def append_pose_to_pose(

...)

append_pose_to_pose( (Pose)pose1, (Pose)pose2 [, (bool)new_chain=True]) -> None : Append residues of pose2 to pose1.

C++ signature : void append_pose_to_pose(core::pose::Pose {lvalue},core::pose::Pose [,bool=True])

def append_subpose_to_pose(

...)

append_subpose_to_pose( (Pose)pose1, (Pose)pose2, (int)start_res, (int)end_res [, (bool)new_chain=True]) -> None : Append specified residues of pose2 to pose1.

C++ signature : void append_subpose_to_pose(core::pose::Pose {lvalue},core::pose::Pose,unsigned long,unsigned long [,bool=True])

def atom_id_to_named_atom_id(

...)

atom_id_to_named_atom_id( (AtomID)atom_id, (Pose)pose) -> NamedAtomID : core/pose/util.hh:353

C++ signature : core::id::NamedAtomID atom_id_to_named_atom_id(core::id::AtomID,core::pose::Pose)

def canonical_atom_count(

...)

canonical_atom_count( (Pose)pose) -> int : count the number of canonical amino acid atoms in the pose

C++ signature : unsigned long canonical_atom_count(core::pose::Pose)

def canonical_residue_count(

...)

canonical_residue_count( (Pose)pose) -> int : count the number of canonical residues in the pose

C++ signature : unsigned long canonical_residue_count(core::pose::Pose)

def center_of_mass(

...)

center_of_mass( (Pose)pose, (int)start, (int)stop) -> xyzVector_Real : core/pose/util.hh:669

C++ signature : numeric::xyzVector center_of_mass(core::pose::Pose,int,int)

def clearPoseExtraScore(

...)

clearPoseExtraScore( (Pose)pose, (str)name) -> None : core/pose/util.hh:170

C++ signature : void clearPoseExtraScore(core::pose::Pose {lvalue},std::string)

def clearPoseExtraScores(

...)

clearPoseExtraScores( (Pose)pose) -> None : core/pose/util.hh:174

C++ signature : void clearPoseExtraScores(core::pose::Pose {lvalue})

def compare_atom_coordinates(

...)

compare_atom_coordinates( (Pose)lhs, (Pose)rhs [, (int)n_dec_places=3]) -> 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@gmail.com [in] lhs one pose to compare [in] rhs one pose to compare [in] n_dec_places number of decimal places to compare for the coordinates (remember == doesn't work for float); defaults to 3 which is PDB accuracy

C++ signature : bool compare_atom_coordinates(core::pose::Pose,core::pose::Pose [,unsigned long=3])

def compare_binary_protein_silent_struct(

...)

compare_binary_protein_silent_struct( (Pose)lhs, (Pose)rhs) -> bool : this function compares poses for equality up to the information stored in the binary protein silent struct format.

C++ signature : bool compare_binary_protein_silent_struct(core::pose::Pose,core::pose::Pose)

def conf2pdb_chain(

...)

conf2pdb_chain( (Pose)pose) -> object : get Conformation chain -> PDBInfo chain mapping @remarks Any chains whose PDBInfo chain records are marked entirely as PDBInfo::empty_record() will be mapped to that character. Note that Conformation -> PDBInfo is always unique, but the reverse may not be true. the mapping if PDBInfo available and chains appear consistent, otherwise returns an empty mapping

C++ signature : std::map, std::allocator > > conf2pdb_chain(core::pose::Pose)

def convert_from_std_map(

...)

convert_from_std_map( (object)atom_map, (Pose)pose) -> AtomID_Map_T_core_id_AtomID_T : core/pose/util.hh:687

C++ signature : core::id::AtomID_Map convert_from_std_map(std::map, std::allocator > >,core::pose::Pose)

def correctly_add_cutpoint_variants(

...)

correctly_add_cutpoint_variants( (Pose)pose, (int)cutpoint_res [, (bool)check_fold_tree=True]) -> None : core/pose/util.hh:696

C++ signature :
    void correctly_add_cutpoint_variants(core::pose::Pose {lvalue},unsigned long [,bool=True])

correctly_add_cutpoint_variants( (Pose)pose) -> None : Add cutpoint variants to all residues annotated as cutpoints in the pose.

C++ signature :
    void correctly_add_cutpoint_variants(core::pose::Pose {lvalue})

def create_subpose(

...)

create_subpose( (Pose)src, (vector1_Size)positions, (FoldTree)f, (Pose)pose) -> None : Create a subpose of the src pose. PDBInfo is set as NULL.

C++ signature : void create_subpose(core::pose::Pose,utility::vector1 >,core::kinematics::FoldTree,core::pose::Pose {lvalue})

def delete_comment(

...)

delete_comment( (Pose)pose, (str)key) -> None : Deletes the entry in the STRING_MAP associated with the given key.

C++ signature : void delete_comment(core::pose::Pose {lvalue},std::string)

def dump_comment_pdb(

...)

dump_comment_pdb( (str)file_name, (Pose)pose) -> None : dumps pose+ comments to pdb file

C++ signature : void dump_comment_pdb(std::string,core::pose::Pose)

def energy_from_pose(

...)

energy_from_pose( (Pose)pose, (str)sc_type) -> float : core/pose/util.hh:387

C++ signature :
    double energy_from_pose(core::pose::Pose,std::string)

energy_from_pose( (Pose)pose, (ScoreType)sc_type) -> float : core/pose/util.hh:383

C++ signature :
    double energy_from_pose(core::pose::Pose,core::scoring::ScoreType)

def extract_tag_from_pose(

...)

extract_tag_from_pose( (Pose)pose) -> str : Returns a string giving the pose's tag if there is such a thing or "UnknownTag" otherwise.

C++ signature : std::string extract_tag_from_pose(core::pose::Pose {lvalue})

def getPoseExtraScore(

...)

getPoseExtraScore( (Pose)pose, (str)name, (str)value) -> bool : core/pose/util.hh:181

C++ signature :
    bool getPoseExtraScore(core::pose::Pose,std::string,std::string {lvalue})

getPoseExtraScore( (Pose)pose, (str)name) -> float : core/pose/util.hh:154

C++ signature :
    double getPoseExtraScore(core::pose::Pose,std::string)

getPoseExtraScore( (Pose)pose, (str)name, (float)value) -> bool : getters/setters for things in the Pose DataCache

C++ signature :
    bool getPoseExtraScore(core::pose::Pose,std::string,double {lvalue})

def get_all_comments(

...)

get_all_comments( (Pose)pose) -> map_string_string : Gets a map< string, string > representing comments about the Pose in the form of key-value pairs.

C++ signature : std::map, std::allocator > > get_all_comments(core::pose::Pose)

def get_all_score_line_strings(

...)

get_all_score_line_strings( (Pose)pose) -> map_string_string : Gets a map< string, string > representing score_line_strings about the Pose in the form of key-value pairs.

C++ signature : std::map, std::allocator > > get_all_score_line_strings(core::pose::Pose)

def get_center_of_mass(

...)

get_center_of_mass( (Pose)pose) -> xyzVector_Real : Get center of mass of a pose.

C++ signature : numeric::xyzVector get_center_of_mass(core::pose::Pose)

def get_chain_from_chain_id(

...)

get_chain_from_chain_id( (int)chain_id, (Pose)pose) -> str : core/pose/util.hh:508

C++ signature : char get_chain_from_chain_id(unsigned long,core::pose::Pose)

def get_chain_from_jump_id(

...)

get_chain_from_jump_id( (int)jump_id, (Pose)pose) -> str : core/pose/util.hh:526

C++ signature : char get_chain_from_jump_id(unsigned long,core::pose::Pose)

def get_chain_id_from_chain(

...)

get_chain_id_from_chain( (str)chain, (Pose)pose) -> int : core/pose/util.hh:496

C++ signature :
    unsigned long get_chain_id_from_chain(char,core::pose::Pose)

get_chain_id_from_chain( (str)chain, (Pose)pose) -> int : core/pose/util.hh:493

C++ signature :
    unsigned long get_chain_id_from_chain(std::string,core::pose::Pose)

def get_chain_id_from_jump_id(

...)

get_chain_id_from_jump_id( (int)jump_id, (Pose)pose) -> int : core/pose/util.hh:523

C++ signature : unsigned long get_chain_id_from_jump_id(unsigned long,core::pose::Pose)

def get_chain_ids_from_chain(

...)

get_chain_ids_from_chain( (str)chain, (Pose)pose) -> vector1_Size : core/pose/util.hh:502

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > get_chain_ids_from_chain(char,core::pose::Pose)

get_chain_ids_from_chain( (str)chain, (Pose)pose) -> vector1_Size : core/pose/util.hh:499

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > get_chain_ids_from_chain(std::string,core::pose::Pose)

def get_chain_ids_from_chains(

...)

get_chain_ids_from_chains( (vector1_string)chains, (Pose)pose) -> vector1_Size : core/pose/util.hh:505

C++ signature : utility::vector1 > get_chain_ids_from_chains(utility::vector1 >,core::pose::Pose)

def get_chain_residues(

...)

get_chain_residues( (Pose)pose, (int)chain_id) -> object : core/pose/util.hh:529

C++ signature : utility::vector1, std::allocator > > get_chain_residues(core::pose::Pose,unsigned long)

def get_comment(

...)

get_comment( (Pose)pose, (str)key, (str)val) -> 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++ signature : bool get_comment(core::pose::Pose,std::string,std::string {lvalue})

def get_hash_excluding_chain(

...)

get_hash_excluding_chain( (str)chain, (Pose)pose) -> int : core/pose/util.hh:572

C++ signature : unsigned long get_hash_excluding_chain(char,core::pose::Pose)

def get_hash_from_chain(

...)

get_hash_from_chain( (str)chain, (Pose)pose) -> int : core/pose/util.hh:569

C++ signature : unsigned long get_hash_from_chain(char,core::pose::Pose)

def get_jump_id_from_chain(

...)

get_jump_id_from_chain( (str)chain, (Pose)pose) -> int : core/pose/util.hh:514

C++ signature :
    unsigned long get_jump_id_from_chain(char,core::pose::Pose)

get_jump_id_from_chain( (str)chain, (Pose)pose) -> int : core/pose/util.hh:511

C++ signature :
    unsigned long get_jump_id_from_chain(std::string,core::pose::Pose)

def get_jump_id_from_chain_id(

...)

get_jump_id_from_chain_id( (int)chain_id, (Pose)pose) -> int : core/pose/util.hh:488

C++ signature : unsigned long get_jump_id_from_chain_id(unsigned long,core::pose::Pose)

def get_jump_ids_from_chain(

...)

get_jump_ids_from_chain( (str)chain, (Pose)pose) -> vector1_Size : core/pose/util.hh:520

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > get_jump_ids_from_chain(std::string,core::pose::Pose)

get_jump_ids_from_chain( (str)chain, (Pose)pose) -> vector1_Size : core/pose/util.hh:517

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > get_jump_ids_from_chain(char,core::pose::Pose)

def get_jump_ids_from_chain_ids(

...)

get_jump_ids_from_chain_ids( (set_Size)chain_ids, (Pose)pose) -> set_Size : core/pose/util.hh:485

C++ signature : std::set, std::allocator > get_jump_ids_from_chain_ids(std::set, std::allocator >,core::pose::Pose)

def get_resnum(

...)

get_resnum( (Tag)tag_ptr, (Pose)pose [, (str)prefix='']) -> int : core/pose/selection.hh:37

C++ signature : unsigned long get_resnum(boost::shared_ptr,core::pose::Pose [,std::string=''])

def get_resnum_list(

...)

get_resnum_list( (str)str, (Pose)pose) -> set_Size : returns a resnum list directly from a string

C++ signature :
    std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long> > get_resnum_list(std::string,core::pose::Pose)

get_resnum_list( (Tag)tag_ptr, (str)tag, (Pose)pose) -> vector1_Size : 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 (@see parse_resnum for details)

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > get_resnum_list(boost::shared_ptr<utility::tag::Tag const>,std::string,core::pose::Pose)

def get_resnum_list_ordered(

...)

get_resnum_list_ordered( (str)str, (Pose)pose) -> vector1_Size : returns a resnum list directly from a string, preserving order

C++ signature : utility::vector1 > get_resnum_list_ordered(std::string,core::pose::Pose)

def get_score_line_string(

...)

get_score_line_string( (Pose)pose, (str)key, (str)val) -> bool : core/pose/util.hh:250

C++ signature : bool get_score_line_string(core::pose::Pose,std::string,std::string {lvalue})

def get_sequence_len(

...)

get_sequence_len( (str)sequence_in) -> int : Get the real length of a annotated sequence

C++ signature : unsigned long get_sequence_len(std::string)

def get_sha1_hash_excluding_chain(

...)

get_sha1_hash_excluding_chain( (str)chain, (Pose)pose) -> str : core/pose/util.hh:574

C++ signature : std::string get_sha1_hash_excluding_chain(char,core::pose::Pose)

def hasPoseExtraScore(

...)

hasPoseExtraScore( (Pose)pose, (str)name) -> bool : core/pose/util.hh:159

C++ signature : bool hasPoseExtraScore(core::pose::Pose,std::string)

def has_chain(

...)

has_chain( (int)chain_id, (Pose)pose) -> bool : core/pose/util.hh:482

C++ signature :
    bool has_chain(unsigned long,core::pose::Pose)

has_chain( (str)chain, (Pose)pose) -> bool : core/pose/util.hh:479

C++ signature :
    bool has_chain(char,core::pose::Pose)

has_chain( (str)chain, (Pose)pose) -> bool : core/pose/util.hh:476

C++ signature :
    bool has_chain(std::string,core::pose::Pose)

def initialize_atomid_map(

...)

initialize_atomid_map( (AtomID_Map_T_core_id_AtomID_T)atom_map, (Conformation)conformation, (AtomID)value) -> None : Initialize an AtomID_Map for a given Conformation using a specified fill value

C++ signature :
    void initialize_atomid_map(core::id::AtomID_Map<core::id::AtomID> {lvalue},core::conformation::Conformation,core::id::AtomID)

initialize_atomid_map( (AtomID_Map_T_core_id_AtomID_T)atom_map, (Conformation)conformation) -> None : Initialize an AtomID_Map for a given Conformation using the AtomID_Map's current default fill values

C++ signature :
    void initialize_atomid_map(core::id::AtomID_Map<core::id::AtomID> {lvalue},core::conformation::Conformation)

initialize_atomid_map( (AtomID_Map_T_core_id_AtomID_T)atom_map, (Pose)pose, (AtomID)value) -> None : Initialize an AtomID_Map for a given Pose using a specified fill value

C++ signature :
    void initialize_atomid_map(core::id::AtomID_Map<core::id::AtomID> {lvalue},core::pose::Pose,core::id::AtomID)

initialize_atomid_map( (AtomID_Map_T_core_id_AtomID_T)atom_map, (Pose)pose) -> None : Initialize an AtomID_Map for a given Pose using the AtomID_Map's current default fill values

C++ signature :
    void initialize_atomid_map(core::id::AtomID_Map<core::id::AtomID> {lvalue},core::pose::Pose)

def initialize_atomid_map_AtomID(

...)

initialize_atomid_map_AtomID( (AtomID_Map_T_core_id_AtomID_T)atom_map, (Conformation)conformation, (AtomID)value) -> None : core/pose/util.tmpl.hh:379

C++ signature :
    void initialize_atomid_map_AtomID(core::id::AtomID_Map<core::id::AtomID> {lvalue},core::conformation::Conformation,core::id::AtomID)

initialize_atomid_map_AtomID( (AtomID_Map_T_core_id_AtomID_T)atom_map, (Conformation)conformation) -> None : core/pose/util.tmpl.hh:376

C++ signature :
    void initialize_atomid_map_AtomID(core::id::AtomID_Map<core::id::AtomID> {lvalue},core::conformation::Conformation)

initialize_atomid_map_AtomID( (AtomID_Map_T_core_id_AtomID_T)atom_map, (Pose)pose, (AtomID)value) -> None : core/pose/util.tmpl.hh:372

C++ signature :
    void initialize_atomid_map_AtomID(core::id::AtomID_Map<core::id::AtomID> {lvalue},core::pose::Pose,core::id::AtomID)

initialize_atomid_map_AtomID( (AtomID_Map_T_core_id_AtomID_T)atom_map, (Pose)pose) -> None : core/pose/util.tmpl.hh:369

C++ signature :
    void initialize_atomid_map_AtomID(core::id::AtomID_Map<core::id::AtomID> {lvalue},core::pose::Pose)

def initialize_disulfide_bonds(

...)

initialize_disulfide_bonds( (Pose)pose) -> None : detect and fix disulfide bonds

C++ signature : void initialize_disulfide_bonds(core::pose::Pose {lvalue})

def is_ideal_pose(

...)

is_ideal_pose( (Pose)pose) -> bool : Returns true if the geometry is ideal [in] pose The Pose to check. true if all pose positions have ideal bond lengths and angles up to some very small epsilon

C++ signature : bool is_ideal_pose(core::pose::Pose)

def is_ideal_position(

...)

is_ideal_position( (int)seqpos, (Pose)pose) -> bool : Returns true if the geometry is ideal in position [in] pose The Pose to check. true if position seqpos has ideal bond lengths and angles up to some very small epsilon

C++ signature : bool is_ideal_position(unsigned long,core::pose::Pose)

def is_lower_terminus(

...)

is_lower_terminus( (Pose)pose, (int)resid) -> bool : checks to see if this is a lower chain ending more intelligently than just checking residue variants

C++ signature : bool is_lower_terminus(core::pose::Pose,unsigned long)

def is_position_conserved_residue(

...)

is_position_conserved_residue( (Pose)pose, (int)residue) -> bool : Returns true if is positionally conserved, false otherwise

C++ signature : bool is_position_conserved_residue(core::pose::Pose,unsigned long)

def is_upper_terminus(

...)

is_upper_terminus( (Pose)pose, (int)resid) -> bool : checks to see if this is a lower chain ending more intelligently than just checking residue variants

C++ signature : bool is_upper_terminus(core::pose::Pose,unsigned long)

def jumps_from_pose(

...)

jumps_from_pose( (Pose)pose, (set_int)jumps) -> None : Retrieves jump information from , storing the result in . Jumps are keyed by their jump id.

C++ signature : void jumps_from_pose(core::pose::Pose,std::set, std::allocator >*)

def make_atom_map(

...)

make_atom_map( (Pose)p, (PoseCoordPickMode)m) -> AtomID_Map_T_double_T : core/pose/xyzStripeHashPose.hh:29

C++ signature : core::id::AtomID_Map make_atom_map(core::pose::Pose,core::pose::PoseCoordPickMode)

def make_pose_from_saccharide_sequence(

...)

make_pose_from_saccharide_sequence( (Pose)pose, (str)sequence [, (str)type_set_name='fa_standard' [, (bool)auto_termini=True]]) -> None : Create a Pose from an annotated, linear, IUPAC polysaccharide sequence with residue type set name and store it in .

C++ signature :
    void make_pose_from_saccharide_sequence(core::pose::Pose {lvalue},std::string [,std::string='fa_standard' [,bool=True]])

make_pose_from_saccharide_sequence( (Pose)pose, (str)sequence, (ResidueTypeSet)residue_set [, (bool)auto_termini=True]) -> None : Create a Pose from an annotated, linear, IUPAC polysaccharide sequence with ResidueTypeSet and store it in .

C++ signature :
    void make_pose_from_saccharide_sequence(core::pose::Pose {lvalue},std::string,core::chemical::ResidueTypeSet [,bool=True])

def make_pose_from_sequence(

...)

make_pose_from_sequence( (Pose)pose, (str)sequence, (str)type_set_name [, (bool)auto_termini=True]) -> None : Creates a Pose from the annotated protein sequence with the desired and stores it in : any existing data in is cleared, auto_termini mark position 1, last_residue with lower, upper termini; default true

C++ signature :
    void make_pose_from_sequence(core::pose::Pose {lvalue},std::string,std::string [,bool=True])

make_pose_from_sequence( (Pose)pose, (str)sequence, (ResidueTypeSet)residue_set [, (bool)auto_termini=True]) -> None : core/pose/annotated_sequence.hh:85

C++ signature :
    void make_pose_from_sequence(core::pose::Pose {lvalue},std::string,core::chemical::ResidueTypeSet [,bool=True])

make_pose_from_sequence( (Pose)pose, (object)requested_types [, (bool)auto_termini=True]) -> None : Creates a Pose from the annotated protein sequence with ResidueTypeSet and stores it in : any existing data in is cleared, auto_termini mark position 1, last_residue with lower, upper termini; default true example(s): make_pose_from_sequence(pose,"THANKSEVAN","fa_standard") See also: Pose PDBInfo pose_from_pdb pose_from_rcsb pose_from_sequence

C++ signature :
    void make_pose_from_sequence(core::pose::Pose {lvalue},utility::vector1<boost::shared_ptr<core::chemical::ResidueType const>, std::allocator<boost::shared_ptr<core::chemical::ResidueType const> > > [,bool=True])

def mass(

...)

mass( (int)begin, (int)end, (Pose)pose) -> float : core/pose/util.hh:566

C++ signature : double mass(unsigned long,unsigned long,core::pose::Pose)

def named_atom_id_to_atom_id(

...)

named_atom_id_to_atom_id( (NamedAtomID)named_atom_id, (Pose)pose [, (bool)raise_exception=True]) -> AtomID : core/pose/util.hh:360

C++ signature : core::id::AtomID named_atom_id_to_atom_id(core::id::NamedAtomID,core::pose::Pose [,bool=True])

def named_stub_id_to_stub_id(

...)

named_stub_id_to_stub_id( (NamedStubID)named_stub_id, (Pose)pose) -> StubID : core/pose/util.hh:372

C++ signature : core::id::StubID named_stub_id_to_stub_id(core::id::NamedStubID,core::pose::Pose)

def noncanonical_atom_count(

...)

noncanonical_atom_count( (Pose)pose) -> int : count the number of non-canonical amino acids in thepose

C++ signature : unsigned long noncanonical_atom_count(core::pose::Pose)

def noncanonical_chi_count(

...)

noncanonical_chi_count( (Pose)pose) -> int : count the number of non-canonical chi angles in the pose

C++ signature : unsigned long noncanonical_chi_count(core::pose::Pose)

def noncanonical_residue_count(

...)

noncanonical_residue_count( (Pose)pose) -> int : count the number of non-canonical residues in the pose

C++ signature : unsigned long noncanonical_residue_count(core::pose::Pose)

def nres_protein(

...)

nres_protein( (Pose)pose) -> int : Number of protein residues in the pose No virtuals, membrane residues or embedding residues counted

C++ signature : unsigned long nres_protein(core::pose::Pose)

def num_atoms(

...)

num_atoms( (int)begin, (int)end, (Pose)pose) -> int : core/pose/util.hh:541

C++ signature : unsigned long num_atoms(unsigned long,unsigned long,core::pose::Pose)

def num_chi_angles(

...)

num_chi_angles( (int)begin, (int)end, (Pose)pose) -> int : core/pose/util.hh:559

C++ signature : unsigned long num_chi_angles(unsigned long,unsigned long,core::pose::Pose)

def num_hbond_acceptors(

...)

num_hbond_acceptors( (int)begin, (int)end, (Pose)pose) -> int : core/pose/util.hh:547

C++ signature : unsigned long num_hbond_acceptors(unsigned long,unsigned long,core::pose::Pose)

def num_hbond_donors(

...)

num_hbond_donors( (int)begin, (int)end, (Pose)pose) -> int : core/pose/util.hh:553

C++ signature : unsigned long num_hbond_donors(unsigned long,unsigned long,core::pose::Pose)

def num_heavy_atoms(

...)

num_heavy_atoms( (int)begin, (int)end, (Pose)pose) -> int : core/pose/util.hh:535

C++ signature : unsigned long num_heavy_atoms(unsigned long,unsigned long,core::pose::Pose)

def parse_resnum(

...)

parse_resnum( (str)resnum, (Pose)pose) -> int : Extracts a residue number from a string. @detail Recognizes two 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. the rosetta residue number for the string, or 0 upon an error

C++ signature : unsigned long parse_resnum(std::string,core::pose::Pose)

def parse_sequence(

...)

parse_sequence( (str)sequence_in, (vector1_string)fullname_list, (std_vector_Size)oneletter_to_fullname_index, (str)one_letter_sequence) -> None : Parse the input annotated sequence

C++ signature : void parse_sequence(std::string,utility::vector1 > {lvalue},std::vector > {lvalue},std::string {lvalue})

def partition_pose_by_jump(

...)

partition_pose_by_jump( (Pose)src, (int)jump_number, (Pose)partner1, (Pose)partner2) -> None : core/pose/util.hh:125

C++ signature : void partition_pose_by_jump(core::pose::Pose,int,core::pose::Pose {lvalue},core::pose::Pose {lvalue})

def pdbslice(

...)

pdbslice( (Pose)pose, (vector1_Size)slice_res) -> None : Create a subpose of the src pose -- figures out a reasonable fold tree.

C++ signature :
    void pdbslice(core::pose::Pose {lvalue},utility::vector1<unsigned long, std::allocator<unsigned long> >)

pdbslice( (Pose)new_pose, (Pose)pose, (vector1_Size)slice_res) -> None : Create a subpose of the src pose -- figures out a reasonable fold tree.

C++ signature :
    void pdbslice(core::pose::Pose {lvalue},core::pose::Pose,utility::vector1<unsigned long, std::allocator<unsigned long> >)

def pose_from_saccharide_sequence(

...)

pose_from_saccharide_sequence( (str)sequence [, (str)type_set_name='fa_standard' [, (bool)auto_termini=True]]) -> Pose : Return a Pose from an annotated, linear, IUPAC polysaccharide sequence with residue type set name .

C++ signature : boost::shared_ptr pose_from_saccharide_sequence(std::string [,std::string='fa_standard' [,bool=True]])

def pose_max_nbr_radius(

...)

pose_max_nbr_radius( (Pose)pose) -> float : returns a Distance

C++ signature : double pose_max_nbr_radius(core::pose::Pose)

def pose_residue_is_terminal(

...)

pose_residue_is_terminal( (Pose)pose, (int)resid) -> bool : returns true if the given residue in the pose is a chain ending or has upper/lower terminal variants

C++ signature : bool pose_residue_is_terminal(core::pose::Pose,unsigned long)

def read_comment_pdb(

...)

read_comment_pdb( (str)file_name, (Pose)pose) -> None : Reads the comments from the pdb file and adds it into comments

C++ signature : void read_comment_pdb(std::string,core::pose::Pose {lvalue})

def read_psipred_ss2_file(

...)

read_psipred_ss2_file( (Pose)pose) -> vector1_char : core/pose/util.hh:141

C++ signature : utility::vector1 > read_psipred_ss2_file(core::pose::Pose)

def remove_ligand_canonical_residues(

...)

remove_ligand_canonical_residues( (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++ signature : void remove_ligand_canonical_residues(core::pose::Pose {lvalue})

def remove_lower_terminus_type_from_pose_residue(

...)

remove_lower_terminus_type_from_pose_residue( (Pose)pose, (int)seqpos) -> None : core/pose/util.hh:450

C++ signature : void remove_lower_terminus_type_from_pose_residue(core::pose::Pose {lvalue},unsigned long)

def remove_nonprotein_residues(

...)

remove_nonprotein_residues( (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++ signature : void remove_nonprotein_residues(core::pose::Pose {lvalue})

def remove_upper_terminus_type_from_pose_residue(

...)

remove_upper_terminus_type_from_pose_residue( (Pose)pose, (int)seqpos) -> None : core/pose/util.hh:457

C++ signature : void remove_upper_terminus_type_from_pose_residue(core::pose::Pose {lvalue},unsigned long)

def remove_variant_type_from_pose_residue(

...)

remove_variant_type_from_pose_residue( (Pose)pose, (VariantType)variant_type, (int)seqpos) -> None : Construct a non-variant of an existing pose residue.

C++ signature : void remove_variant_type_from_pose_residue(core::pose::Pose {lvalue},core::chemical::VariantType,unsigned long)

def remove_variant_type_from_residue(

...)

remove_variant_type_from_residue( (Residue)old_rsd, (VariantType)variant_type, (Pose)pose) -> Residue : Remove variant from an existing residue.

C++ signature : boost::shared_ptr remove_variant_type_from_residue(core::conformation::Residue,core::chemical::VariantType,core::pose::Pose)

def remove_virtual_residues(

...)

remove_virtual_residues( (Pose)pose) -> None : Removes all virtual residues from

C++ signature : void remove_virtual_residues(core::pose::Pose*)

def renumber_pdbinfo_based_on_conf_chains(

...)

renumber_pdbinfo_based_on_conf_chains( (Pose)pose [, (bool)fix_chains=True [, (bool)start_from_existing_numbering=True [, (bool)keep_insertion_codes=False [, (bool)rotate_chain_ids=False]]]]) -> bool : renumber PDBInfo based on Conformation chains; each chain starts from 1 [in,out] pose The Pose to modify. [in] fix_chains If true, the procedure will attempt to fix any empty record characters it finds in the PDBInfo. (default true) [in] start_from_existing_numbering 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) [in] keep_insertion_codes 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) [in] rotate_chain_ids 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) @remarks 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++ signature : bool renumber_pdbinfo_based_on_conf_chains(core::pose::Pose {lvalue} [,bool=True [,bool=True [,bool=False [,bool=False]]]])

def replace_pose_residue_copying_existing_coordinates(

...)

replace_pose_residue_copying_existing_coordinates( (Pose)pose, (int)seqpos, (ResidueType)new_rsd_type) -> None : core/pose/util.hh:405

C++ signature : void replace_pose_residue_copying_existing_coordinates(core::pose::Pose {lvalue},unsigned long,core::chemical::ResidueType)

def residue_center_of_mass(

...)

residue_center_of_mass( (Pose)pose, (int)start, (int)stop) -> int : core/pose/util.hh:676

C++ signature : int residue_center_of_mass(core::pose::Pose,int,int)

def residue_types_from_saccharide_sequence(

...)

residue_types_from_saccharide_sequence( (str)sequence, (ResidueTypeSet)residue_set) -> object : Return a list of carbohydrate ResidueTypes corresponding to an annotated, linear, IUPAC polysaccharide sequence.

C++ signature : utility::vector1, std::allocator > > residue_types_from_saccharide_sequence(std::string,core::chemical::ResidueTypeSet)

def residue_types_from_sequence(

...)

residue_types_from_sequence( (str)sequence_in, (ResidueTypeSet)residue_set [, (bool)auto_termini=True]) -> object : return a list of ResidueTypes corresponding to an annotated protein sequence [in] sequence_in an annotated sequence [in] residue_set the desired residue set [in] auto_termini mark position 1, last_residue with lower, upper termini; default true

C++ signature : utility::vector1, std::allocator > > residue_types_from_sequence(std::string,core::chemical::ResidueTypeSet [,bool=True])

def return_nearest_residue(

...)

return_nearest_residue( (Pose)pose, (int)begin, (int)end, (xyzVector_Real)center) -> int : core/pose/util.hh:684

C++ signature : int return_nearest_residue(core::pose::Pose,int,int,numeric::xyzVector)

def sequence_map_from_pdbinfo(

...)

sequence_map_from_pdbinfo( (Pose)first, (Pose)second) -> 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++ signature : core::id::SequenceMapping sequence_map_from_pdbinfo(core::pose::Pose,core::pose::Pose)

def setPoseExtraScore(

...)

setPoseExtraScore( (Pose)pose, (str)name, (str)value) -> None : core/pose/util.hh:187

C++ signature :
    void setPoseExtraScore(core::pose::Pose {lvalue},std::string,std::string)

setPoseExtraScore( (Pose)pose, (str)name, (float)value) -> None : core/pose/util.hh:165

C++ signature :
    void setPoseExtraScore(core::pose::Pose {lvalue},std::string,double)

def set_ss_from_phipsi(

...)

set_ss_from_phipsi( (Pose)pose) -> None : Analyzes residue phi/psi sets and guesses the secondary structure, ideally dssp should be used for that

C++ signature : void set_ss_from_phipsi(core::pose::Pose {lvalue})

def setup_dof_mask_from_move_map(

...)

setup_dof_mask_from_move_map( (MoveMap)mm, (Pose)pose, (object)dof_mask) -> None : convert from allow-bb/allow-chi MoveMap to simple DOF_ID boolean mask needed by the minimizer

C++ signature : void setup_dof_mask_from_move_map(core::kinematics::MoveMap,core::pose::Pose,core::id::DOF_ID_Map {lvalue})

def setup_dof_to_torsion_map(

...)

setup_dof_to_torsion_map( (Pose)pose, (object)dof_map) -> None : set up a map to look up TORSION_ID by DOF_ID (Map[DOF_ID] = TORISION_ID)

C++ signature : void setup_dof_to_torsion_map(core::pose::Pose,core::id::DOF_ID_Map {lvalue})

def sort_pose_by_score(

...)

sort_pose_by_score( (Pose)pose1, (Pose)pose2) -> bool : core/pose/util.hh:379

C++ signature : bool sort_pose_by_score(boost::shared_ptr,boost::shared_ptr)

def stub_id_to_named_stub_id(

...)

stub_id_to_named_stub_id( (StubID)stub_id, (Pose)pose) -> NamedStubID : core/pose/util.hh:366

C++ signature : core::id::NamedStubID stub_id_to_named_stub_id(core::id::StubID,core::pose::Pose)

def swap_transform(

...)

swap_transform( (int)jump_num, (RT)xform, (Pose)pose) -> None : Updates the rigid-body transform of the specified jump in

C++ signature : void swap_transform(unsigned long,core::kinematics::RT,core::pose::Pose*)

def tag_from_pose(

...)

tag_from_pose( (Pose)pose) -> str : ////////////////////////////////////////////////////////////////

C++ signature : std::string tag_from_pose(core::pose::Pose)

def tag_into_pose(

...)

tag_into_pose( (Pose)pose, (str)tag) -> None : core/pose/util.hh:376

C++ signature : void tag_into_pose(core::pose::Pose {lvalue},std::string)

def total_energy_from_pose(

...)

total_energy_from_pose( (Pose)pose) -> float : core/pose/util.hh:389

C++ signature : double total_energy_from_pose(core::pose::Pose)

def transfer_jumps(

...)

transfer_jumps( (Pose)srcpose, (Pose)tgtpose) -> None : core/pose/util.hh:398

C++ signature : void transfer_jumps(core::pose::Pose,core::pose::Pose {lvalue})

def transfer_phi_psi(

...)

transfer_phi_psi( (Pose)srcpose, (Pose)tgtpose) -> None : core/pose/util.hh:395

C++ signature :
    void transfer_phi_psi(core::pose::Pose,core::pose::Pose {lvalue})

transfer_phi_psi( (Pose)srcpose, (Pose)tgtpose, (int)ir, (int)jr) -> None : core/pose/util.hh:392

C++ signature :
    void transfer_phi_psi(core::pose::Pose,core::pose::Pose {lvalue},unsigned long,unsigned long)

class CrystInfo

core/pose/CrystInfo.hh:27

Ancestors (in MRO)

CrystInfo
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (CrystInfo)) -> None : core/pose/CrystInfo.hh:27

C++ signature :
    void __init__(_object*,core::pose::CrystInfo)

def A(

...)

A( (CrystInfo)arg1) -> float : core/pose/CrystInfo.hh:43

C++ signature :
    double A(core::pose::CrystInfo {lvalue})

A( (CrystInfo)arg1, (float)Ain) -> None : core/pose/CrystInfo.hh:44

C++ signature :
    void A(core::pose::CrystInfo {lvalue},double)

def B(

...)

B( (CrystInfo)arg1) -> float : core/pose/CrystInfo.hh:45

C++ signature :
    double B(core::pose::CrystInfo {lvalue})

B( (CrystInfo)arg1, (float)Bin) -> None : core/pose/CrystInfo.hh:46

C++ signature :
    void B(core::pose::CrystInfo {lvalue},double)

def C(

...)

C( (CrystInfo)arg1) -> float : core/pose/CrystInfo.hh:47

C++ signature :
    double C(core::pose::CrystInfo {lvalue})

C( (CrystInfo)arg1, (float)Cin) -> None : core/pose/CrystInfo.hh:48

C++ signature :
    void C(core::pose::CrystInfo {lvalue},double)

def alpha(

...)

alpha( (CrystInfo)arg1) -> float : core/pose/CrystInfo.hh:50

C++ signature :
    double alpha(core::pose::CrystInfo {lvalue})

alpha( (CrystInfo)arg1, (float)alphain) -> None : core/pose/CrystInfo.hh:51

C++ signature :
    void alpha(core::pose::CrystInfo {lvalue},double)

def beta(

...)

beta( (CrystInfo)arg1) -> float : core/pose/CrystInfo.hh:52

C++ signature :
    double beta(core::pose::CrystInfo {lvalue})

beta( (CrystInfo)arg1, (float)betain) -> None : core/pose/CrystInfo.hh:53

C++ signature :
    void beta(core::pose::CrystInfo {lvalue},double)

def gamma(

...)

gamma( (CrystInfo)arg1) -> float : core/pose/CrystInfo.hh:54

C++ signature :
    double gamma(core::pose::CrystInfo {lvalue})

gamma( (CrystInfo)arg1, (float)gammain) -> None : core/pose/CrystInfo.hh:55

C++ signature :
    void gamma(core::pose::CrystInfo {lvalue},double)

def spacegroup(

...)

spacegroup( (CrystInfo)arg1) -> str : core/pose/CrystInfo.hh:57

C++ signature :
    std::string spacegroup(core::pose::CrystInfo {lvalue})

spacegroup( (CrystInfo)arg1, (str)spacegroupin) -> None : core/pose/CrystInfo.hh:58

C++ signature :
    void spacegroup(core::pose::CrystInfo {lvalue},std::string)

class CrystInfoAP

Ancestors (in MRO)

CrystInfoAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CrystInfoAP)arg1) -> CrystInfo :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CrystInfoCAP

Ancestors (in MRO)

CrystInfoCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CrystInfoCAP)arg1) -> CrystInfo :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class MiniPose

lightweight version of the pose with stuff I need. not quite (silent_structs don't necessarily have xyz). Kind of like a Conformation but without the overtree of an atom_tree. @remark 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.

Ancestors (in MRO)

MiniPose
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1, (Pose)pose) -> None : core/pose/MiniPose.hh:42

C++ signature :
    void __init__(_object*,core::pose::Pose)

init( (object)arg1, (MiniPose)) -> None : lightweight version of the pose with stuff I need. not quite (silent_structs don't necessarily have xyz). Kind of like a Conformation but without the overtree of an atom_tree. @remark 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.

C++ signature :
    void __init__(_object*,core::pose::MiniPose)

init( (object)arg1, (object)coords, (FoldTree)fold_tree, (str)sequence) -> None : core/pose/MiniPose.hh:46

C++ signature :
    void __init__(_object*,utility::vector1<utility::vector1<numeric::xyzVector<double>, std::allocator<numeric::xyzVector<double> > >, std::allocator<utility::vector1<numeric::xyzVector<double>, std::allocator<numeric::xyzVector<double> > > > >,core::kinematics::FoldTree,std::string)

def atom_name(

...)

atom_name( (MiniPose)arg1, (AtomID)atom_id) -> str : core/pose/MiniPose.hh:66

C++ signature : std::string atom_name(core::pose::MiniPose {lvalue},core::id::AtomID)

def atom_names_list(

...)

atom_names_list( (MiniPose)arg1) -> vec1_vec1_string : core/pose/MiniPose.hh:54

C++ signature : utility::vector1 >, std::allocator > > > atom_names_list(core::pose::MiniPose {lvalue})

def coords(

...)

coords( (MiniPose)arg1) -> object : core/pose/MiniPose.hh:52

C++ signature : utility::vector1, std::allocator > >, std::allocator, std::allocator > > > > coords(core::pose::MiniPose {lvalue})

def fold_tree(

...)

fold_tree( (MiniPose)arg1) -> FoldTree : core/pose/MiniPose.hh:50

C++ signature : core::kinematics::FoldTree fold_tree(core::pose::MiniPose {lvalue})

def sequence(

...)

sequence( (MiniPose)arg1) -> str : core/pose/MiniPose.hh:62

C++ signature : std::string sequence(core::pose::MiniPose {lvalue})

def size(

...)

size( (MiniPose)arg1) -> int : core/pose/MiniPose.hh:58

C++ signature : unsigned long size(core::pose::MiniPose {lvalue})

def total_residue(

...)

total_residue( (MiniPose)arg1) -> int : core/pose/MiniPose.hh:60

C++ signature : unsigned long total_residue(core::pose::MiniPose {lvalue})

def variant_types(

...)

variant_types( (MiniPose)arg1, (int)seq_num) -> vector1_string : core/pose/MiniPose.hh:68

C++ signature : utility::vector1 > variant_types(core::pose::MiniPose {lvalue},unsigned long)

def variant_types_list(

...)

variant_types_list( (MiniPose)arg1) -> vec1_vec1_string : core/pose/MiniPose.hh:56

C++ signature : utility::vector1 >, std::allocator > > > variant_types_list(core::pose::MiniPose {lvalue})

def xyz(

...)

xyz( (MiniPose)arg1, (AtomID)atom_id) -> xyzVector_Real : core/pose/MiniPose.hh:64

C++ signature : numeric::xyzVector xyz(core::pose::MiniPose {lvalue},core::id::AtomID)

class MiniPoseAP

Ancestors (in MRO)

MiniPoseAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (MiniPoseAP)arg1) -> MiniPose :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class MiniPoseCAP

Ancestors (in MRO)

MiniPoseCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (MiniPoseCAP)arg1) -> MiniPose :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class PDBInfo

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 id 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(). @remarks 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.

Ancestors (in MRO)

PDBInfo
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (int)n) -> None : size constructor (ensure space for 'n' residue records), obsolete is true

C++ signature :
    void __init__(_object*,unsigned long)

init( (object)arg1, (Pose)pose [, (bool)init=True]) -> None : Pose constructor (ensures space for residue and atom records relative to Pose) [in] pose Pose [in] init if true (default), then residue records are initialized and obsolete set to false, otherwise obsolete is true using Pose residue numbering and chains of the Residues in the Conformation

C++ signature :
    void __init__(_object*,core::pose::Pose [,bool=True])

init( (object)arg1, (PDBInfo)info) -> None : copy constructor

C++ signature :
    void __init__(_object*,core::pose::PDBInfo)

def add_reslabel(

...)

add_reslabel( (PDBInfo)arg1, (int)res, (str)label) -> None : adds a label associated to a pose resid. [in] res residue in pose numbering [in] label string that is the "label"

C++ signature : void add_reslabel(core::pose::PDBInfo {lvalue},unsigned long,std::string)

def add_unrecognized_atom(

...)

add_unrecognized_atom( (PDBInfo)arg1, (int)resnum, (str)resname, (str)atomname, (xyzVector_Real)coords, (float)temp) -> None : remembers info about atoms not read into the pose

C++ signature : void add_unrecognized_atom(core::pose::PDBInfo {lvalue},unsigned long,std::string,std::string,numeric::xyzVector,double)

def alt_loc(

...)

alt_loc( (PDBInfo)arg1, (int)res, (int)atom_index) -> str : Returns the alternate location for the atom of pose residue example(s): pose.pdb_info().alt_loc(1,1) See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    char alt_loc(core::pose::PDBInfo {lvalue},unsigned long,unsigned long)

alt_loc( (PDBInfo)arg1, (int)res, (int)atom_index, (str)loc) -> None : Sets the alternate location of the atom of pose residue to : is an alternate location character

C++ signature :
    void alt_loc(core::pose::PDBInfo {lvalue},unsigned long,unsigned long,char)

def append_res(

...)

append_res( (PDBInfo)arg1, (int)res, (int)natoms [, (int)n=1]) -> None : Appends residue records given a pose residue number [in] res residue to append after (in internal/pose numbering) [in] natoms number of atoms in type of appended residue [in] n number of residue records to append

C++ signature : void append_res(core::pose::PDBInfo {lvalue},unsigned long,unsigned long [,unsigned long=1])

def assign(

...)

assign( (PDBInfo)arg1, (PDBInfo)info) -> PDBInfo : copy assignment

C++ signature : core::pose::PDBInfo {lvalue} assign(core::pose::PDBInfo {lvalue},core::pose::PDBInfo)

def attach_to(

...)

attach_to( (PDBInfo)arg1, (Conformation)conf) -> None : Attaches the Conformation and begins observation example(s): See also: Pose PDBInfo

C++ signature : void attach_to(core::pose::PDBInfo {lvalue},core::conformation::Conformation {lvalue})

def chain(

...)

chain( (PDBInfo)arg1, (int)res) -> str : Returns the chain id for pose residue example(s): pose.pdb_info().chain(3) See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    char chain(core::pose::PDBInfo {lvalue},unsigned long)

chain( (PDBInfo)arg1, (int)res, (str)chain_id) -> None : Sets the chain id of pose residue to @remarks chain id should not be the empty record character, currently '^' Returns the pdb insertion code of residue example(s): pose.pdb_info().chain(3,"R") See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    void chain(core::pose::PDBInfo {lvalue},unsigned long,char)

def clear_reslabel(

...)

clear_reslabel( (PDBInfo)arg1, (int)res) -> None : clean all the label(s) associated to a pose resid. [in] res residue in pose numbering

C++ signature : void clear_reslabel(core::pose::PDBInfo {lvalue},unsigned long)

def copy(

...)

copy( (PDBInfo)arg1, (PDBInfo)input_info, (int)copy_from, (int)copy_to, (int)start_from) -> None : Copyies a section from PDBInfo [in] input_info the PDBInfo to copy from [in] copy_from the first residue position in input_info to copy [in] copy_to the final residue position in input_info to copy [in] start_from the first residue position in this PDBInfo to copy into

C++ signature : void copy(core::pose::PDBInfo {lvalue},core::pose::PDBInfo,unsigned long,unsigned long,unsigned long)

def crystinfo(

...)

crystinfo( (PDBInfo)arg1) -> CrystInfo : Returns the pdb crystinfo

C++ signature : core::pose::CrystInfo crystinfo(core::pose::PDBInfo {lvalue})

def delete_res(

...)

delete_res( (PDBInfo)arg1, (int)res [, (int)n=1]) -> None : Deletes residue records starting from pose residue [in] res residue to start deleting from (in internal/pose numbering) [in] n number of residue records to delete

C++ signature : void delete_res(core::pose::PDBInfo {lvalue},unsigned long [,unsigned long=1])

def detach_from(

...)

detach_from( (PDBInfo)arg1) -> None : Detaches the Conformation and stops observation @remarks 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++ signature : void detach_from(core::pose::PDBInfo {lvalue})

def get_num_unrecognized_atoms(

...)

get_num_unrecognized_atoms( (PDBInfo)arg1) -> int : core/pose/PDBInfo.hh:1153

C++ signature : unsigned long get_num_unrecognized_atoms(core::pose::PDBInfo {lvalue})

def get_num_unrecognized_res(

...)

get_num_unrecognized_res( (PDBInfo)arg1) -> int : core/pose/PDBInfo.hh:1160

C++ signature : unsigned long get_num_unrecognized_res(core::pose::PDBInfo {lvalue})

def get_reslabels(

...)

get_reslabels( (PDBInfo)arg1, (int)res) -> vector1_string : returns the pose(number) labels associated to the residue [in] res residue in pose numbering

C++ signature : utility::vector1 > get_reslabels(core::pose::PDBInfo {lvalue},unsigned long)

def get_unrecognized_atoms(

...)

get_unrecognized_atoms( (PDBInfo)arg1) -> object : remembers info about atoms not read into the pose

C++ signature : utility::vector1 > get_unrecognized_atoms(core::pose::PDBInfo {lvalue})

def get_unrecognized_res_name(

...)

get_unrecognized_res_name( (PDBInfo)arg1, (int)i) -> str : core/pose/PDBInfo.hh:1167

C++ signature : std::string get_unrecognized_res_name(core::pose::PDBInfo {lvalue},unsigned long)

def get_unrecognized_res_size(

...)

get_unrecognized_res_size( (PDBInfo)arg1, (int)i) -> int : core/pose/PDBInfo.hh:1174

C++ signature : unsigned long get_unrecognized_res_size(core::pose::PDBInfo {lvalue},unsigned long)

def header_information(

...)

header_information( (PDBInfo)arg1, (HeaderInformation)header_information) -> None : For structures deposited into the protein databank, the header information record stores the classfication, deposition date and the 4 character identification code. For now only allow initalizing it with copy and accessing it with a constant owning pointer. Note: The header information is only initialized if it is needed. Generally this requires using the -run:preserve_header options flag.

C++ signature :
    void header_information(core::pose::PDBInfo {lvalue},boost::shared_ptr<core::io::pdb::HeaderInformation>)

header_information( (PDBInfo)arg1) -> HeaderInformation : core/pose/PDBInfo.hh:542

C++ signature :
    boost::shared_ptr<core::io::pdb::HeaderInformation const> header_information(core::pose::PDBInfo {lvalue})

header_information( (PDBInfo)arg1) -> HeaderInformation : core/pose/PDBInfo.hh:548

C++ signature :
    boost::shared_ptr<core::io::pdb::HeaderInformation> header_information(core::pose::PDBInfo {lvalue})

def icode(

...)

icode( (PDBInfo)arg1, (int)res) -> str : Returns the pdb insertion code of residue example(s): pose.pdb_info().icode(3) See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    char icode(core::pose::PDBInfo {lvalue},unsigned long)

icode( (PDBInfo)arg1, (int)res, (str)ins_code) -> None : Sets the insertion code of pose residue to Returns the pdb insertion code of residue example(s): See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    void icode(core::pose::PDBInfo {lvalue},unsigned long,char)

def is_het(

...)

is_het( (PDBInfo)arg1, (int)res, (int)atom_index) -> bool : Returns true if the atom of pose residue 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++ signature :
    bool is_het(core::pose::PDBInfo {lvalue},unsigned long,unsigned long)

is_het( (PDBInfo)arg1, (int)res, (int)atom_index, (bool)flag) -> None : Sets the heteroatom flag of the atom of pose residue to 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++ signature :
    void is_het(core::pose::PDBInfo {lvalue},unsigned long,unsigned long,bool)

def is_observing(

...)

is_observing( (PDBInfo)arg1) -> ConformationCAP : 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++ signature : boost::weak_ptr is_observing(core::pose::PDBInfo {lvalue})

def modeltag(

...)

modeltag( (PDBInfo)arg1) -> str : Returns the model tag for a multi-model pdb example(s): pose.pdb_info().modeltag() See also: Pose PDBInfo

C++ signature :
    std::string modeltag(core::pose::PDBInfo {lvalue})

modeltag( (PDBInfo)arg1, (str)tag) -> None : Sets the model tag for a multi-model pdb to example(s): pose.pdb_info().modeltag('Number1') See also: Pose PDBInfo

C++ signature :
    void modeltag(core::pose::PDBInfo {lvalue},std::string)

def name(

...)

name( (PDBInfo)arg1) -> str : Returns the pdb name example(s): pose.pdb_info().name() See also: Pose PDBInfo

C++ signature :
    std::string name(core::pose::PDBInfo {lvalue})

name( (PDBInfo)arg1, (str)s) -> None : Sets the pdb name example(s): pose.pdb_info().name('MyPDB') See also: Pose PDBInfo

C++ signature :
    void name(core::pose::PDBInfo {lvalue},std::string)

def natoms(

...)

natoms( (PDBInfo)arg1, (int)res) -> int : Returns the number of atoms represented for the residue : residue must be in pose numbering example(s): pose.pdb_info().natoms(3) See also: Pose PDBInfo

C++ signature : unsigned long natoms(core::pose::PDBInfo {lvalue},unsigned long)

def nres(

...)

nres( (PDBInfo)arg1) -> int : Returns the number of residues represented in PDBInfo example(s): pose.pdb_info().nres() See also: Pose PDBInfo

C++ signature : unsigned long nres(core::pose::PDBInfo {lvalue})

def number(

...)

number( (PDBInfo)arg1, (int)res) -> int : Returns the pdb sequence number of pose residue example(s): pose.pdb_info().number(3) See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    int number(core::pose::PDBInfo {lvalue},unsigned long)

number( (PDBInfo)arg1, (int)res, (int)pdb_res) -> None : Sets the pdb sequence residue number of pose residue to Returns the pdb insertion code of residue example(s): pose.pdb_info().number(3,81) See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    void number(core::pose::PDBInfo {lvalue},unsigned long,int)

def obsolete(

...)

obsolete( (PDBInfo)arg1) -> 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++ signature :
    bool obsolete(core::pose::PDBInfo {lvalue})

obsolete( (PDBInfo)arg1, (bool)flag) -> None : Sets the obsolete state to 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++ signature :
    void obsolete(core::pose::PDBInfo {lvalue},bool)

def occupancy(

...)

occupancy( (PDBInfo)arg1, (int)res, (int)atom_index) -> float : Returns the occupancy for the atom of pose residue example(s): pose.pdb_info().occupancy(1,1) See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    double occupancy(core::pose::PDBInfo {lvalue},unsigned long,unsigned long)

occupancy( (PDBInfo)arg1, (int)res, (int)atom_index, (float)occ) -> None : Sets the occupancy of the atom of pose residue to

C++ signature :
    void occupancy(core::pose::PDBInfo {lvalue},unsigned long,unsigned long,double)

def on_connection_change(

...)

on_connection_change( (PDBInfo)arg1, (ConnectionEvent)event) -> None : Updates when connection to Conformation is changed

C++ signature : void on_connection_change(core::pose::PDBInfo {lvalue},core::conformation::signals::ConnectionEvent)

def on_identity_change(

...)

on_identity_change( (PDBInfo)arg1, (IdentityEvent)event) -> None : Updates atom records when residue identity changes in Conformation

C++ signature : void on_identity_change(core::pose::PDBInfo {lvalue},core::conformation::signals::IdentityEvent)

def on_length_change(

...)

on_length_change( (PDBInfo)arg1, (LengthEvent)event) -> None : Updates residue and atom records when length changes in Conformation, obsoletes PDBInfo

C++ signature : void on_length_change(core::pose::PDBInfo {lvalue},core::conformation::signals::LengthEvent)

def pdb2pose(

...)

pdb2pose( (PDBInfo)arg1, (str)chain, (int)res [, (str)icode=' ']) -> int : Returns the pose numbering of the pdb residue with chain , pdb residue , and insertion code : 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++ signature :
    unsigned long pdb2pose(core::pose::PDBInfo {lvalue},char,int [,char=' '])

pdb2pose( (PDBInfo)arg1) -> PDBPoseMap : Returns the internally maintained PDBPoseMap example(s): See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    core::pose::PDBPoseMap pdb2pose(core::pose::PDBInfo {lvalue})

def pose2pdb(

...)

pose2pdb( (PDBInfo)arg1, (int)res) -> str : Returns the pdb numbering string of pose residue : pdb string contains the chainID 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++ signature : std::string pose2pdb(core::pose::PDBInfo {lvalue},unsigned long)

def prepend_res(

...)

prepend_res( (PDBInfo)arg1, (int)res, (int)natoms [, (int)n=1]) -> None : Prepends residue records before given pose residue number [in] res residue to prepend before (in internal/pose numbering) [in] natoms number of atoms in type of appended residue [in] n number of residue records to prepend

C++ signature : void prepend_res(core::pose::PDBInfo {lvalue},unsigned long,unsigned long [,unsigned long=1])

def rebuild_pdb2pose(

...)

rebuild_pdb2pose( (PDBInfo)arg1) -> None : rebuilds PDBPoseMap from scratch

C++ signature : void rebuild_pdb2pose(core::pose::PDBInfo {lvalue})

def remarks(

...)

remarks( (PDBInfo)arg1) -> Remarks : Returns the pdb remarks (const) example(s): pose.pdb_info().remarks() See also: Pose PDBInfo

C++ signature :
    core::pose::Remarks remarks(core::pose::PDBInfo {lvalue})

remarks( (PDBInfo)arg1) -> 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++ signature :
    core::pose::Remarks {lvalue} remarks(core::pose::PDBInfo {lvalue})

remarks( (PDBInfo)arg1, (Remarks)in) -> None : Sets the pdb remarks to example(s): See also: Pose PDBInfo

C++ signature :
    void remarks(core::pose::PDBInfo {lvalue},core::pose::Remarks)

def replace_res(

...)

replace_res( (PDBInfo)arg1, (int)res, (int)natoms) -> None : "Replaces" residue record for pose residue Leaves information in residue record untouched, but resizes and zeroes atom records for the residue. [in] res residue to replace [in] natoms number of atoms in type of residue

C++ signature : void replace_res(core::pose::PDBInfo {lvalue},unsigned long,unsigned long)

def replace_res_remap_bfactors(

...)

replace_res_remap_bfactors( (PDBInfo)arg1, (int)res, (Residue)tgt) -> None : same as replace_res BUT remaps B factors from src to tgt

C++ signature : void replace_res_remap_bfactors(core::pose::PDBInfo {lvalue},unsigned long,core::conformation::Residue)

def res_haslabel(

...)

res_haslabel( (PDBInfo)arg1, (int)res, (str)target_label) -> bool : uses std iterators to check if a residue has a label associated to it [in] res residue in pose numbering [in] target_label string to look for inside the labes associated to the residue

C++ signature : bool res_haslabel(core::pose::PDBInfo {lvalue},unsigned long,std::string)

def resize_atom_records(

...)

resize_atom_records( (PDBInfo)arg1, (int)res, (int)n [, (bool)zero=True]) -> None : Ensures atom records for residue are available : if is true, zero the atom records for this residue

C++ signature :
    void resize_atom_records(core::pose::PDBInfo {lvalue},unsigned long,unsigned long [,bool=True])

resize_atom_records( (PDBInfo)arg1, (int)n [, (bool)zero=True]) -> None : Ensures atom records for residue are available : if is true, zero the atom records for this residue

C++ signature :
    void resize_atom_records(core::pose::PDBInfo {lvalue},unsigned long [,bool=True])

resize_atom_records( (PDBInfo)arg1, (Pose)pose) -> None : Updates the number of atom records with respect to atoms in 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++ signature :
    void resize_atom_records(core::pose::PDBInfo {lvalue},core::pose::Pose)

def resize_residue_records(

...)

resize_residue_records( (PDBInfo)arg1, (int)n) -> None : Resizes for 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. @warning 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++ signature : void resize_residue_records(core::pose::PDBInfo {lvalue},unsigned long)

def set_chains(

...)

set_chains( (PDBInfo)arg1, (str)id) -> None : Sets all residue chain ids to the character

C++ signature : void set_chains(core::pose::PDBInfo {lvalue},char)

def set_crystinfo(

...)

set_crystinfo( (PDBInfo)arg1, (CrystInfo)crystinfoin) -> None : Sets the pdb crystinfo

C++ signature : void set_crystinfo(core::pose::PDBInfo {lvalue},core::pose::CrystInfo)

def set_resinfo(

...)

set_resinfo( (PDBInfo)arg1, (int)res, (str)chain_id, (int)pdb_res [, (str)ins_code=' ']) -> None : Sets the chain id, pdb sequence residue numbering, and insertion code for pose residue to , , and respectfully : convenience method; more efficient than doing each individually due to map updates Returns the pdb insertion code of residue example(s): pose.pdb_info().icode(3) See also: Pose PDBInfo PDBInfo.chain PDBInfo.icode PDBInfo.number PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature : void set_resinfo(core::pose::PDBInfo {lvalue},unsigned long,char,int [,char=' '])

def show(

...)

show( (PDBInfo)arg1, (OStream)out) -> 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++ signature : void show(core::pose::PDBInfo {lvalue},std::ostream {lvalue})

def temperature(

...)

temperature( (PDBInfo)arg1, (int)res, (int)atom_index) -> float : Returns the temperature for the atom of pose residue example(s): pose.pdb_info().temperature(1,1) See also: Pose PDBInfo PDBInfo.pdb2pose PDBInfo.pose2pdb

C++ signature :
    double temperature(core::pose::PDBInfo {lvalue},unsigned long,unsigned long)

temperature( (PDBInfo)arg1, (int)res, (int)atom_index, (float)t) -> None : Sets the temperature of the atom of pose residue to

C++ signature :
    void temperature(core::pose::PDBInfo {lvalue},unsigned long,unsigned long,double)

def tighten_memory(

...)

tighten_memory( (PDBInfo)arg1) -> None : Tightens memory usage

C++ signature : void tighten_memory(core::pose::PDBInfo {lvalue})

class PDBInfoAP

Ancestors (in MRO)

PDBInfoAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PDBInfoAP)arg1) -> PDBInfo :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class PDBInfoCAP

Ancestors (in MRO)

PDBInfoCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PDBInfoCAP)arg1) -> PDBInfo :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class PDBPoseMap

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.

Ancestors (in MRO)

PDBPoseMap
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (PDBInfo)info) -> None : PDBInfo constructor

C++ signature :
    void __init__(_object*,core::pose::PDBInfo)

init( (object)arg1, (PDBPoseMap)map) -> None : copy constructor

C++ signature :
    void __init__(_object*,core::pose::PDBPoseMap)

def assign(

...)

assign( (PDBPoseMap)arg1, (PDBPoseMap)m) -> PDBPoseMap : copy assignment

C++ signature : core::pose::PDBPoseMap {lvalue} assign(core::pose::PDBPoseMap {lvalue},core::pose::PDBPoseMap)

def clear(

...)

clear( (PDBPoseMap)arg1) -> None : clear the current mapping data

C++ signature : void clear(core::pose::PDBPoseMap {lvalue})

def conditional_erase(

...)

conditional_erase( (PDBPoseMap)arg1, (str)chain, (int)pdb_res, (str)ins_code, (int)pose_res) -> bool : remove mapping for pdb residue key only if Pose residue matches [in] chain chain id [in] pdb_res pdb residue numbering [in] ins_code insertion code, use ' ' if no insertion code [in] pose_res the mapped Pose residue true if key-value pair erase, false otherwise

C++ signature : bool conditional_erase(core::pose::PDBPoseMap {lvalue},char,int,char,unsigned long)

def erase(

...)

erase( (PDBPoseMap)arg1, (str)chain, (int)pdb_res, (str)ins_code) -> None : forcibly remove mapping for pdb residue key [in] chain chain id [in] pdb_res pdb residue numbering [in] ins_code insertion code, use ' ' if no insertion code

C++ signature : void erase(core::pose::PDBPoseMap {lvalue},char,int,char)

def fill(

...)

fill( (PDBPoseMap)arg1, (PDBInfo)info) -> None : fill with corresponding pdb -> pose residue mapping does not clear any currently existing mapping data

C++ signature : void fill(core::pose::PDBPoseMap {lvalue},core::pose::PDBInfo)

def find(

...)

find( (PDBPoseMap)arg1, (str)chain, (int)pdb_res [, (str)ins_code=' ']) -> int : lookup pose numbering [in] chain chain id [in] pdb_res pdb residue numbering [in] ins_code insertion code pose numbering for residue, returns 0 if not found

C++ signature : unsigned long find(core::pose::PDBPoseMap {lvalue},char,int [,char=' '])

def insert(

...)

insert( (PDBPoseMap)arg1, (str)chain, (int)pdb_res, (str)ins_code, (int)pose_res) -> None : insert pdb -> pose number mapping [in] chain chain id [in] pdb_res pdb residue numbering [in] ins_code insertion code, use ' ' if no insertion code [in] pose_res pose numbering for residue @remarks if the chain is equal to the PDBInfo's empty record character, the insertion will be skipped

C++ signature : void insert(core::pose::PDBPoseMap {lvalue},char,int,char,unsigned long)

def size(

...)

size( (PDBPoseMap)arg1) -> int : number of mappings

C++ signature : unsigned long size(core::pose::PDBPoseMap {lvalue})

class PDBPoseMapAP

Ancestors (in MRO)

PDBPoseMapAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PDBPoseMapAP)arg1) -> PDBPoseMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class PDBPoseMapCAP

Ancestors (in MRO)

PDBPoseMapCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PDBPoseMapCAP)arg1) -> PDBPoseMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class Pose

A molecular system including residues, kinematics, and energies 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.energies Pose.fold_tree Pose.pdb_info Pose.residue Pose.sequence Pose.total_residue

Ancestors (in MRO)

Pose
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (Pose)src) -> None : copy constructor

C++ signature :
    void __init__(_object*,core::pose::Pose)

init( (object)arg1, (Pose)src, (int)residue_begin, (int)residue_end) -> None : partial copy constructor

C++ signature :
    void __init__(_object*,core::pose::Pose,unsigned long,unsigned long)

def aa(

...)

aa( (Pose)arg1, (int)seqpos) -> AA : Returns the chemical::AA of the residue at example(s): pose.aa(17) See also: Pose Pose.Residue Pose.sequence Residue

C++ signature : core::chemical::AA aa(core::pose::Pose {lvalue},unsigned long)

def add_constraint(

...)

add_constraint( (Pose)arg1, (CPP_Constraint)cst) -> Constraint : adding a constraint is done by cloning the input constraint. A const copy is then returned

C++ signature : boost::shared_ptr add_constraint(core::pose::Pose {lvalue},boost::shared_ptr)

def add_constraints(

...)

add_constraints( (Pose)arg1, (object)csts) -> object : core/pose/Pose.hh:350

C++ signature : utility::vector1, std::allocator > > add_constraints(core::pose::Pose {lvalue},utility::vector1, std::allocator > >)

def alpha(

...)

alpha( (Pose)arg1, (int)pos) -> float : Returns the alpha torsion angle of residue assumes the residue is an nucleic acid example(s): pose.alpha(1) See also: Pose Pose.residue Pose.set_alpha Residue

C++ signature : double alpha(core::pose::Pose {lvalue},unsigned long)

def annotated_sequence(

...)

annotated_sequence( (Pose)arg1 [, (bool)show_all_variants=False]) -> 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.total_residue Residue

C++ signature : std::string annotated_sequence(core::pose::Pose {lvalue} [,bool=False])

def append_polymer_residue_after_seqpos(

...)

append_polymer_residue_after_seqpos( (Pose)arg1, (Residue)new_rsd, (int)seqpos, (bool)build_ideal_geometry) -> None : glues to seqpos and perhaps also seqpos+1

C++ signature : void append_polymer_residue_after_seqpos(core::pose::Pose {lvalue},core::conformation::Residue,unsigned long,bool)

def append_pose_by_jump(

...)

append_pose_by_jump( (Pose)arg1, (Pose)src, (int)jump_anchor_residue [, (str)jump_anchor_atom='' [, (str)jump_root_atom='']]) -> None : Appends source pose conformation to pose by a new jump

C++ signature : void append_pose_by_jump(core::pose::Pose {lvalue},core::pose::Pose,unsigned long [,std::string='' [,std::string='']])

def append_residue_by_bond(

...)

append_residue_by_bond( (Pose)arg1, (Residue)new_rsd [, (bool)build_ideal_geometry=False [, (int)connection=0 [, (int)anchor_residue=0 [, (int)anchor_connection=0 [, (bool)start_new_chain=False [, (bool)lookup_bond_length=False]]]]]]) -> None : Appends (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++ signature : void append_residue_by_bond(core::pose::Pose {lvalue},core::conformation::Residue [,bool=False [,int=0 [,unsigned long=0 [,int=0 [,bool=False [,bool=False]]]]]])

def append_residue_by_jump(

...)

append_residue_by_jump( (Pose)arg1, (Residue)new_rsd, (int)jump_anchor_residue [, (str)jump_anchor_atom='' [, (str)jump_root_atom='' [, (bool)start_new_chain=False]]]) -> None : ///////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// Appends (a residue) to pose by a new jump

C++ signature : void append_residue_by_jump(core::pose::Pose {lvalue},core::conformation::Residue,unsigned long [,std::string='' [,std::string='' [,bool=False]]])

def apply_transform_Rx_plus_v(

...)

apply_transform_Rx_plus_v( (Pose)arg1, (xyzMatrix_Real)R, (xyzVector_Real)v) -> None : Apply a transform of the Rx + v form, where R is a rotation matrix and v is a translation vector.

C++ signature : void apply_transform_Rx_plus_v(core::pose::Pose {lvalue},numeric::xyzMatrix,numeric::xyzVector)

def assign(

...)

assign( (Pose)arg1, (Pose)src) -> Pose : Copies into the pose example(s): test_pose.assign(pose) See also: Pose

C++ signature : core::pose::Pose {lvalue} assign(core::pose::Pose {lvalue},core::pose::Pose)

def atom_tree(

...)

atom_tree( (Pose)arg1) -> AtomTree : Returns the pose AtomTree

C++ signature : core::kinematics::AtomTree atom_tree(core::pose::Pose {lvalue})

def batch_get_xyz(

...)

batch_get_xyz( (Pose)arg1, (vector1_AtomID)ids, (vector1_xyzVector_Real)points) -> None : Gets the locations (xyz) of pose AtomIDs in

C++ signature : void batch_get_xyz(core::pose::Pose {lvalue},utility::vector1 >,utility::vector1, std::allocator > > {lvalue})

def batch_set_xyz(

...)

batch_set_xyz( (Pose)arg1, (vector1_AtomID)ids, (vector1_xyzVector_Real)points) -> None : Sets the locations (xyz) of pose AtomIDs in to mathcing PointPositions in

C++ signature : void batch_set_xyz(core::pose::Pose {lvalue},utility::vector1 >,utility::vector1, std::allocator > >)

def beta(

...)

beta( (Pose)arg1, (int)seqpos) -> float : Returns the beta torsion angle of residue assumes the residue is an nucleic acid example(s): pose.beta(2) See also: Pose Pose.residue Pose.set_beta Residue

C++ signature : double beta(core::pose::Pose {lvalue},unsigned long)

def center(

...)

center( (Pose)arg1) -> None : Sets pose coordinates such that the pose center is at the Euclidean origin

C++ signature : void center(core::pose::Pose {lvalue})

def chain(

...)

chain( (Pose)arg1, (int)seqpos) -> int : Returns the chain number of residue example(s): pose.chain(3) See also: Pose Pose.annotated_sequence Pose.chain_sequence Pose.fold_tree Pose.sequence FoldTree

C++ signature : int chain(core::pose::Pose {lvalue},unsigned long)

def chain_sequence(

...)

chain_sequence( (Pose)arg1, (int)chain_in) -> str : Returns the sequence for the chain Example(s): pose.chain_sequence(1) See also: Pose Pose.chain Pose.residue Pose.sequence

C++ signature : std::string chain_sequence(core::pose::Pose {lvalue},unsigned long)

def chi(

...)

chi( (Pose)arg1, (int)chino, (int)seqpos) -> float : Returns the chi torsion angle of residue 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++ signature :
    double chi(core::pose::Pose {lvalue},int,unsigned long)

chi( (Pose)arg1, (int)seqpos) -> float : Returns the chi torsion angle of residue assumes the residue is an nucleic acid example(s): pose.chi(7) See also: Pose Pose.residue Pose.set_chi Residue

C++ signature :
    double chi(core::pose::Pose {lvalue},unsigned long)

def clear(

...)

clear( (Pose)arg1) -> None : Empty the pose contents example(s): pose.clear() See also: Pose Pose.assign Pose.empty

C++ signature : void clear(core::pose::Pose {lvalue})

def clone(

...)

clone( (Pose)arg1) -> Pose : clone the conformation

C++ signature : boost::shared_ptr clone(core::pose::Pose {lvalue})

def conformation(

...)

conformation( (Pose)arg1) -> Conformation : ///////////////////////////////////// Returns the pose Conformation (const-access)

 example(s):
     pose.Conformation()
 See also:
     Pose
     Conformation


C++ signature :
    core::conformation::Conformation conformation(core::pose::Pose {lvalue})

conformation( (Pose)arg1) -> Conformation : Returns the pose Conformation (non-const access)

C++ signature :
    core::conformation::Conformation {lvalue} conformation(core::pose::Pose {lvalue})

def conformation_ptr(

...)

conformation_ptr( (Pose)arg1) -> Conformation : Returns the pose Conformation pointer (const access)

C++ signature :
    boost::shared_ptr<core::conformation::Conformation const> conformation_ptr(core::pose::Pose {lvalue})

conformation_ptr( (Pose)arg1) -> CPP_Conformation : Returns the pose Conformation pointer (const access)

C++ signature :
    boost::shared_ptr<core::conformation::Conformation> {lvalue} conformation_ptr(core::pose::Pose {lvalue})

def constraint_set(

...)

constraint_set( (Pose)arg1) -> ConstraintSet : core/pose/Pose.hh:343

C++ signature :
    boost::shared_ptr<core::scoring::constraints::ConstraintSet const> constraint_set(core::pose::Pose {lvalue})

constraint_set( (Pose)arg1, (CPP_ConstraintSet)) -> None : core/pose/Pose.hh:370

C++ signature :
    void constraint_set(core::pose::Pose {lvalue},boost::shared_ptr<core::scoring::constraints::ConstraintSet>)

def copy_segment(

...)

copy_segment( (Pose)arg1, (int)size, (Pose)src, (int)begin, (int)src_begin) -> None : Copy a stretch of coordinates/torsions from to pose

C++ signature : void copy_segment(core::pose::Pose {lvalue},unsigned long,core::pose::Pose,unsigned long,unsigned long)

def data(

...)

data( (Pose)arg1) -> BasicDataCache : //////////////////// BasicDataCache indexed by enum in core/pose/datacache/CacheableDataType.hh

C++ signature :
    basic::datacache::BasicDataCache data(core::pose::Pose {lvalue})

data( (Pose)arg1) -> BasicDataCache : BasicDataCache indexed by enum in core/pose/datacache/CacheableDataType.hh

C++ signature :
    basic::datacache::BasicDataCache {lvalue} data(core::pose::Pose {lvalue})

def delete_polymer_residue(

...)

delete_polymer_residue( (Pose)arg1, (int)seqpos) -> None : core/pose/Pose.hh:518

C++ signature : void delete_polymer_residue(core::pose::Pose {lvalue},unsigned long)

def delta(

...)

delta( (Pose)arg1, (int)pos) -> float : Returns the delta torsion angle of residue assumes the residue is an nucleic acid example(s): pose.delta(4) See also: Pose Pose.residue Pose.set_delta Residue

C++ signature : double delta(core::pose::Pose {lvalue},unsigned long)

def dof(

...)

dof( (Pose)arg1, (DOF_ID)id) -> float : //////////////////////////////////////////////////////////////////////// Returns the value of the AtomTree DOF

Ancestors (in MRO)

PoseAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PoseAP)arg1) -> Pose :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class PoseCAP

Ancestors (in MRO)

PoseCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PoseCAP)arg1) -> Pose :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class PoseCoordPickMode

core/pose/xyzStripeHashPose.fwd.hh:19

Ancestors (in MRO)

PoseCoordPickMode
Boost.Python.enum
__builtin__.int
__builtin__.object

Class variables

var PoseCoordPickMode_ALL

var PoseCoordPickMode_BB

var PoseCoordPickMode_BNP

var PoseCoordPickMode_CA

var PoseCoordPickMode_CB

var PoseCoordPickMode_CB_else_CA

var PoseCoordPickMode_CBorCA

var PoseCoordPickMode_HVY

var PoseCoordPickMode_HVY_IF_NP

var PoseCoordPickMode_NBR

var PoseCoordPickMode_NUL

var PoseCoordPickMode_N_CA_C

var PoseCoordPickMode_N_CA_C_CB

var PoseCoordPickMode_N_C_O

var denominator

var imag

var name

var names

var numerator

var real

var values

class PosePyObserver

Ancestors (in MRO)

PosePyObserver
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def add_observer(

...)

add_observer( (PosePyObserver)arg1, (Pose)arg2) -> None :

C++ signature : void add_observer(PosePyObserver {lvalue},core::pose::Pose {lvalue})

def generalEvent(

...)

generalEvent( (PosePyObserver)arg1, (GeneralEvent)arg2) -> None :

C++ signature :
    void generalEvent(PosePyObserver {lvalue},core::pose::signals::GeneralEvent)

generalEvent( (PosePyObserver)arg1, (GeneralEvent)arg2) -> None :

C++ signature :
    void generalEvent(Wrapper_PosePyObserver {lvalue},core::pose::signals::GeneralEvent)

def remove_observer(

...)

remove_observer( (PosePyObserver)arg1, (Pose)arg2) -> None :

C++ signature : void remove_observer(PosePyObserver {lvalue},core::pose::Pose {lvalue})

class Py_basic_datacache_DataCache_CacheableObserver

Ancestors (in MRO)

Py_basic_datacache_DataCache_CacheableObserver
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

class RemarkInfo

core/pose/Remarks.hh:32

Ancestors (in MRO)

RemarkInfo
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (RemarkInfo)) -> None : core/pose/Remarks.hh:32

C++ signature :
    void __init__(_object*,core::pose::RemarkInfo)

class RemarkInfoAP

Ancestors (in MRO)

RemarkInfoAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RemarkInfoAP)arg1) -> RemarkInfo :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class RemarkInfoCAP

Ancestors (in MRO)

RemarkInfoCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RemarkInfoCAP)arg1) -> RemarkInfo :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class Remarks

core/pose/Remarks.hh:50

Ancestors (in MRO)

Remarks
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

class RemarksAP

Ancestors (in MRO)

RemarksAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RemarksAP)arg1) -> Remarks :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class RemarksCAP

Ancestors (in MRO)

RemarksCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RemarksCAP)arg1) -> Remarks :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class SingletonBase_T_core_chemical_ChemicalManager_T

SingletonBase is meant to serve as a base class for singleton classes in Rosetta handling the initialization of the singleton in a thread-safe way. The derived class must a) implement a private, static function: T * create_singleton_instance() so that the SingletonBase class can invoke this function, and b) declare the SingletonBase class to be a friend, so that it can invoke this function The .cc file in which the derived singleton must be put will need to include the definitions for the two static data members, instance_ and singleton_mutex_.

Ancestors (in MRO)

SingletonBase_T_core_chemical_ChemicalManager_T
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

class SingletonBase_T_core_chemical_ChemicalManager_TAP

Ancestors (in MRO)

SingletonBase_T_core_chemical_ChemicalManager_TAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SingletonBase_T_core_chemical_ChemicalManager_TAP)arg1) -> SingletonBase_T_core_chemical_ChemicalManager_T :

C++ signature : boost::shared_ptr > get(boost::weak_ptr >)

class SingletonBase_T_core_chemical_ChemicalManager_TCAP

Ancestors (in MRO)

SingletonBase_T_core_chemical_ChemicalManager_TCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SingletonBase_T_core_chemical_ChemicalManager_TCAP)arg1) -> SingletonBase_T_core_chemical_ChemicalManager_T :

C++ signature : boost::shared_ptr const> get(boost::weak_ptr const>)

class UnrecognizedAtomRecord

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

Ancestors (in MRO)

UnrecognizedAtomRecord
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1, (int)res_num, (str)res_name, (str)atom_name, (xyzVector_Real)coords, (float)temp) -> None : core/pose/PDBInfo.hh:66

C++ signature :
    void __init__(_object*,unsigned long,std::string,std::string,numeric::xyzVector<double>,double)

init( (object)arg1, (UnrecognizedAtomRecord)) -> None : info about an atom in a unrecognized res (not in pose, but we want to remember it)

C++ signature :
    void __init__(_object*,core::pose::UnrecognizedAtomRecord)

def atom_name(

...)

atom_name( (UnrecognizedAtomRecord)arg1) -> str : core/pose/PDBInfo.hh:75

C++ signature : std::string atom_name(core::pose::UnrecognizedAtomRecord {lvalue})

def coords(

...)

coords( (UnrecognizedAtomRecord)arg1) -> xyzVector_Real : core/pose/PDBInfo.hh:76

C++ signature : numeric::xyzVector coords(core::pose::UnrecognizedAtomRecord {lvalue})

def res_name(

...)

res_name( (UnrecognizedAtomRecord)arg1) -> str : core/pose/PDBInfo.hh:74

C++ signature : std::string res_name(core::pose::UnrecognizedAtomRecord {lvalue})

def res_num(

...)

res_num( (UnrecognizedAtomRecord)arg1) -> int : core/pose/PDBInfo.hh:73

C++ signature : unsigned long res_num(core::pose::UnrecognizedAtomRecord {lvalue})

def temp(

...)

temp( (UnrecognizedAtomRecord)arg1) -> float : core/pose/PDBInfo.hh:77

C++ signature : double temp(core::pose::UnrecognizedAtomRecord {lvalue})

class UnrecognizedAtomRecordAP

Ancestors (in MRO)

UnrecognizedAtomRecordAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (UnrecognizedAtomRecordAP)arg1) -> UnrecognizedAtomRecord :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class UnrecognizedAtomRecordCAP

Ancestors (in MRO)

UnrecognizedAtomRecordCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (UnrecognizedAtomRecordCAP)arg1) -> UnrecognizedAtomRecord :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class xyzStripeHashPose

core/pose/xyzStripeHashPose.hh:31

Ancestors (in MRO)

xyzStripeHashPose
rosetta.numeric.geometry.hashing._numeric_geometry_hashing_.xyzStripeHash
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1 [, (float)radius=0.0]) -> None : core/pose/xyzStripeHashPose.hh:35

C++ signature :
    void __init__(_object* [,double=0.0])

init( (object)arg1, (xyzStripeHashPose)) -> None : core/pose/xyzStripeHashPose.hh:31

C++ signature :
    void __init__(_object*,core::pose::xyzStripeHashPose)

init( (object)arg1, (Pose)p [, (PoseCoordPickMode)m=rosetta.core.pose.core_pose.PoseCoordPickMode.PoseCoordPickMode_BB [, (float)radius=0.0]]) -> None : core/pose/xyzStripeHashPose.hh:40

C++ signature :
    void __init__(_object*,core::pose::Pose [,core::pose::PoseCoordPickMode=rosetta.core.pose._core_pose_.PoseCoordPickMode.PoseCoordPickMode_BB [,double=0.0]])

init( (object)arg1, (Pose)p, (vector1_int)resmap [, (PoseCoordPickMode)m=rosetta.core.pose.core_pose.PoseCoordPickMode.PoseCoordPickMode_BB [, (float)radius=0.0]]) -> None : core/pose/xyzStripeHashPose.hh:46

C++ signature :
    void __init__(_object*,core::pose::Pose,utility::vector1<int, std::allocator<int> > [,core::pose::PoseCoordPickMode=rosetta.core.pose._core_pose_.PoseCoordPickMode.PoseCoordPickMode_BB [,double=0.0]])

init( (object)arg1, (Pose)p, (AtomID_Map_T_double_T)amap [, (float)radius=0.0]) -> None : core/pose/xyzStripeHashPose.hh:51

C++ signature :
    void __init__(_object*,core::pose::Pose,core::id::AtomID_Map<double> [,double=0.0])

def add_pose(

...)

add_pose( (xyzStripeHashPose)arg1, (Pose)p, (AtomID_Map_T_double_T)amap) -> None : core/pose/xyzStripeHashPose.hh:56

C++ signature :
    void add_pose(core::pose::xyzStripeHashPose {lvalue},core::pose::Pose,core::id::AtomID_Map<double>)

add_pose( (xyzStripeHashPose)arg1, (Pose)p [, (PoseCoordPickMode)m=rosetta.core.pose.core_pose.PoseCoordPickMode.PoseCoordPickMode_BB]) -> None : core/pose/xyzStripeHashPose.hh:61

C++ signature :
    void add_pose(core::pose::xyzStripeHashPose {lvalue},core::pose::Pose [,core::pose::PoseCoordPickMode=rosetta.core.pose._core_pose_.PoseCoordPickMode.PoseCoordPickMode_BB])

def ball(

...)

ball( (xyzStripeHash)arg1, (int)ib) -> Ball : numeric/geometry/hashing/xyzStripeHash.hh:216

C++ signature : numeric::geometry::hashing::Ball ball(numeric::geometry::hashing::xyzStripeHash {lvalue},unsigned long)

def begin(

...)

begin( (xyzStripeHash)arg1) -> object : numeric/geometry/hashing/xyzStripeHash.hh:97

C++ signature : numeric::geometry::hashing::xyzStripeHash::const_iterator begin(numeric::geometry::hashing::xyzStripeHash {lvalue})

def clash(

...)

clash( (xyzStripeHash)arg1, (xyzVector_float)v_in) -> bool : numeric/geometry/hashing/xyzStripeHash.hh:106

C++ signature : bool clash(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::xyzVector)

def clash_amount(

...)

clash_amount( (xyzStripeHash)arg1, (xyzVector_float)v_in) -> float : numeric/geometry/hashing/xyzStripeHash.hh:109

C++ signature : float clash_amount(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::xyzVector)

def clash_check_ball(

...)

clash_check_ball( (xyzStripeHash)arg1, (Ball)b) -> int : numeric/geometry/hashing/xyzStripeHash.hh:116

C++ signature : int clash_check_ball(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::geometry::hashing::Ball)

def clash_check_residue_pairs(

...)

clash_check_residue_pairs( (xyzStripeHash)arg1, (vector1_numeric_geometry_hashing_Ball)test_balls, (map_Size_Size)residue_pairs) -> bool : numeric/geometry/hashing/xyzStripeHash.hh:133

C++ signature : bool clash_check_residue_pairs(numeric::geometry::hashing::xyzStripeHash {lvalue},utility::vector1 >,std::map, std::allocator > > {lvalue})

def clash_not_resid(

...)

clash_not_resid( (xyzStripeHash)arg1, (xyzVector_float)v_in, (int)resid [, (int)resid2=0]) -> bool : numeric/geometry/hashing/xyzStripeHash.hh:107

C++ signature : bool clash_not_resid(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::xyzVector,int [,int=0])

def clash_raw(

...)

clash_raw( (xyzStripeHash)arg1, (xyzVector_float)v) -> bool : numeric/geometry/hashing/xyzStripeHash.hh:108

C++ signature : bool clash_raw(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::xyzVector)

def debug_pdb(

...)

debug_pdb( (xyzStripeHash)arg1, (xyzTransform_T_double_T)x) -> str : numeric/geometry/hashing/xyzStripeHash.hh:102

C++ signature : std::string debug_pdb(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::xyzTransform)

def end(

...)

end( (xyzStripeHash)arg1) -> object : numeric/geometry/hashing/xyzStripeHash.hh:98

C++ signature : numeric::geometry::hashing::xyzStripeHash::const_iterator end(numeric::geometry::hashing::xyzStripeHash {lvalue})

def fill_pairs(

...)

fill_pairs( (xyzStripeHash)arg1, (xyzVector_float)v, (int)ir, (vector1_pair_int_int)pairs [, (float)maxd2=0.0]) -> None : numeric/geometry/hashing/xyzStripeHash.hh:140

C++ signature : void fill_pairs(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::xyzVector,int,utility::vector1, std::allocator > > {lvalue} [,float=0.0])

def grid_atoms(

...)

grid_atoms( (xyzStripeHash)arg1) -> Ball : numeric/geometry/hashing/xyzStripeHash.hh:203

C++ signature : numeric::geometry::hashing::Ball const* grid_atoms(numeric::geometry::hashing::xyzStripeHash {lvalue})

def grid_size(

...)

grid_size( (xyzStripeHash)arg1) -> float : numeric/geometry/hashing/xyzStripeHash.hh:209

C++ signature : float grid_size(numeric::geometry::hashing::xyzStripeHash {lvalue})

def grid_size2(

...)

grid_size2( (xyzStripeHash)arg1) -> float : numeric/geometry/hashing/xyzStripeHash.hh:210

C++ signature : float grid_size2(numeric::geometry::hashing::xyzStripeHash {lvalue})

def grid_stripe(

...)

grid_stripe( (xyzStripeHash)arg1) -> object : numeric/geometry/hashing/xyzStripeHash.hh:214

C++ signature : numeric::geometry::hashing::xyzStripeHash::ushort2 const* grid_stripe(numeric::geometry::hashing::xyzStripeHash {lvalue})

def init(

...)

init( (xyzStripeHash)arg1, (vector1_numeric_geometry_hashing_Ball)balls) -> None : numeric/geometry/hashing/xyzStripeHash.hh:90

C++ signature : void init(numeric::geometry::hashing::xyzStripeHash {lvalue},utility::vector1 >)

def init_posehash(

...)

init_posehash( (xyzStripeHashPose)arg1) -> None : core/pose/xyzStripeHashPose.hh:64

C++ signature : void init_posehash(core::pose::xyzStripeHashPose {lvalue})

def natom(

...)

natom( (xyzStripeHash)arg1) -> int : numeric/geometry/hashing/xyzStripeHash.hh:205

C++ signature : int natom(numeric::geometry::hashing::xyzStripeHash {lvalue})

def nbcount(

...)

nbcount( (xyzStripeHash)arg1, (xyzVector_float)v_in) -> int : numeric/geometry/hashing/xyzStripeHash.hh:104

C++ signature : int nbcount(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::xyzVector)

def nbcount_raw(

...)

nbcount_raw( (xyzStripeHash)arg1, (xyzVector_float)v) -> int : numeric/geometry/hashing/xyzStripeHash.hh:105

C++ signature : int nbcount_raw(numeric::geometry::hashing::xyzStripeHash {lvalue},numeric::xyzVector)

def resi(

...)

resi( (xyzStripeHash)arg1, (int)ib) -> int : numeric/geometry/hashing/xyzStripeHash.hh:218

C++ signature : unsigned long resi(numeric::geometry::hashing::xyzStripeHash {lvalue},unsigned long)

def sanity_check(

...)

sanity_check( (xyzStripeHash)arg1) -> bool : numeric/geometry/hashing/xyzStripeHash.hh:100

C++ signature : bool sanity_check(numeric::geometry::hashing::xyzStripeHash {lvalue})

def size(

...)

size( (xyzStripeHash)arg1) -> int : numeric/geometry/hashing/xyzStripeHash.hh:204

C++ signature : unsigned long size(numeric::geometry::hashing::xyzStripeHash {lvalue})

def translation(

...)

translation( (xyzStripeHash)arg1) -> xyzVector_float : numeric/geometry/hashing/xyzStripeHash.hh:211

C++ signature : numeric::xyzVector translation(numeric::geometry::hashing::xyzStripeHash {lvalue})

def translation_real(

...)

translation_real( (xyzStripeHash)arg1) -> xyzVector_Real : numeric/geometry/hashing/xyzStripeHash.hh:212

C++ signature : numeric::xyzVector translation_real(numeric::geometry::hashing::xyzStripeHash {lvalue})

def xdim(

...)

xdim( (xyzStripeHash)arg1) -> int : numeric/geometry/hashing/xyzStripeHash.hh:206

C++ signature : int xdim(numeric::geometry::hashing::xyzStripeHash {lvalue})

def xyz(

...)

xyz( (xyzStripeHash)arg1, (int)ib) -> xyzVector_float : numeric/geometry/hashing/xyzStripeHash.hh:217

C++ signature : numeric::xyzVector xyz(numeric::geometry::hashing::xyzStripeHash {lvalue},unsigned long)

def ydim(

...)

ydim( (xyzStripeHash)arg1) -> int : numeric/geometry/hashing/xyzStripeHash.hh:207

C++ signature : int ydim(numeric::geometry::hashing::xyzStripeHash {lvalue})

def zdim(

...)

zdim( (xyzStripeHash)arg1) -> int : numeric/geometry/hashing/xyzStripeHash.hh:208

C++ signature : int zdim(numeric::geometry::hashing::xyzStripeHash {lvalue})

class xyzStripeHashPoseAP

Ancestors (in MRO)

xyzStripeHashPoseAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (xyzStripeHashPoseAP)arg1) -> xyzStripeHashPose :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class xyzStripeHashPoseCAP

Ancestors (in MRO)

xyzStripeHashPoseCAP
Boost.Python.instance
__builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (xyzStripeHashPoseCAP)arg1) -> xyzStripeHashPose :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

Index

Module variables

Functions

Classes

Module variables

Functions

Classes

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Class variables

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Methods