Bindings for core::pose namespace

Modules
		rosetta.core.pose.carbohydrates rosetta.core.pose.copydofs rosetta.core.pose.datacache rosetta.core.pose.full_model_info rosetta.core.pose.metrics rosetta.core.pose.motif rosetta.core.pose.ncbb rosetta.core.pose.reference_pose rosetta.core.pose.rna rosetta.core.pose.signals rosetta.core.pose.symmetry

Classes
		builtins.object MiniPose PDBInfo PDBPoseMap Pose PoseCoordPickMode ResidueIndexDescription ResidueIndexDescriptionFromFile UnrecognizedAtomRecord rosetta.numeric.geometry.hashing.xyzStripeHash(builtins.object) xyzStripeHashPose   class MiniPose(builtins.object)     not quite (silent_structs don't necessarily have xyz). Kind of like a Conformation but without the overtree of an atom_tree.     Should save memory compared to keeping the full pose (which includes atom_tree, energies etc.) This is a bit like the SilentStruct -- although that class has gotten a bit complicated -- easier to start from scratch.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.pose.MiniPose, pose : rosetta.core.pose.Pose) -> NoneType   2. __init__(self : rosetta.core.pose.MiniPose, coords : rosetta.utility.vector1_utility_vector1_numeric_xyzVector_double_std_allocator_numeric_xyzVector_double_t, fold_tree : rosetta.core.kinematics.FoldTree, sequence : str) -> NoneType   3. __init__(self : rosetta.core.pose.MiniPose,  : rosetta.core.pose.MiniPose) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.pose.MiniPose,  : rosetta.core.pose.MiniPose) -> rosetta.core.pose.MiniPose atom_name(...) from builtins.PyCapsule atom_name(self : rosetta.core.pose.MiniPose, atom_id : rosetta.core.id.AtomID) -> str atom_names_list(...) from builtins.PyCapsule atom_names_list(rosetta.core.pose.MiniPose) -> rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t coords(...) from builtins.PyCapsule coords(rosetta.core.pose.MiniPose) -> rosetta.utility.vector1_utility_vector1_numeric_xyzVector_double_std_allocator_numeric_xyzVector_double_t fold_tree(...) from builtins.PyCapsule fold_tree(rosetta.core.pose.MiniPose) -> rosetta.core.kinematics.FoldTree sequence(...) from builtins.PyCapsule sequence(rosetta.core.pose.MiniPose) -> str size(...) from builtins.PyCapsule size(rosetta.core.pose.MiniPose) -> int total_residue(...) from builtins.PyCapsule total_residue(rosetta.core.pose.MiniPose) -> int variant_types(...) from builtins.PyCapsule variant_types(self : rosetta.core.pose.MiniPose, seq_num : int) -> rosetta.utility.vector1_std_string variant_types_list(...) from builtins.PyCapsule variant_types_list(rosetta.core.pose.MiniPose) -> rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t xyz(...) from builtins.PyCapsule xyz(self : rosetta.core.pose.MiniPose, atom_id : rosetta.core.id.AtomID) -> rosetta.numeric.xyzVector_double_t   class PDBInfo(builtins.object)     maintains pdb residue & atom information inside a Pose     Upon creation of new residue records, e.g. when calling the  constructors without 'init' or appending/prepending residues, the  chain 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().     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.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.pose.PDBInfo) -> NoneType   2. __init__(self : rosetta.core.pose.PDBInfo, n : int) -> NoneType   3. __init__(rosetta.core.pose.PDBInfo, rosetta.core.pose.Pose) -> NoneType   doc   4. __init__(self : rosetta.core.pose.PDBInfo, pose : rosetta.core.pose.Pose, init : bool) -> NoneType   5. __init__(self : rosetta.core.pose.PDBInfo, info : rosetta.core.pose.PDBInfo) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.pose.PDBInfo) -> str add_reslabel(...) from builtins.PyCapsule add_reslabel(self : rosetta.core.pose.PDBInfo, res : int, label : str) -> NoneType   adds a label associated to a pose resid.       residue in pose numbering       string that is the "label" add_unrecognized_atoms(...) from builtins.PyCapsule add_unrecognized_atoms(self : rosetta.core.pose.PDBInfo, UAs : rosetta.utility.vector1_core_pose_UnrecognizedAtomRecord) -> NoneType   remembers info about atoms not read into the pose alt_loc(...) from builtins.PyCapsule alt_loc(*args, **kwargs) Overloaded function.   1. alt_loc(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int) -> str   Returns the alternate location for the  <atom_index>  atom of pose  residue  <res>    example(s):      pose.pdb_info().alt_loc(1,1)  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb   2. alt_loc(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int, loc : str) -> NoneType   Sets the alternate location of the  <atom_index>  atom of pose  residue  <res>  to   <loc>     :  <loc> is an alternate location character append_res(...) from builtins.PyCapsule append_res(*args, **kwargs) Overloaded function.   1. append_res(self : rosetta.core.pose.PDBInfo, res : int, natoms : int) -> NoneType   Appends residue records given a pose residue number  <res>       residue to append after (in internal/pose numbering)       number of atoms in type of appended residue         number of residue records to append   2. append_res(self : rosetta.core.pose.PDBInfo, res : int, natoms : int, n : int) -> NoneType   Appends residue records given a pose residue number  <res>       residue to append after (in internal/pose numbering)       number of atoms in type of appended residue         number of residue records to append assign(...) from builtins.PyCapsule assign(self : rosetta.core.pose.PDBInfo, info : rosetta.core.pose.PDBInfo) -> rosetta.core.pose.PDBInfo   copy assignment attach_to(...) from builtins.PyCapsule attach_to(self : rosetta.core.pose.PDBInfo, conf : rosetta.core.conformation.Conformation) -> NoneType   Attaches the Conformation  <conf>  and begins observation    example(s):    See also:      Pose      PDBInfo bfactor(...) from builtins.PyCapsule bfactor(*args, **kwargs) Overloaded function.   1. bfactor(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int) -> float   Returns the temperature for the  <atom_index>  atom of pose residue  <res>    example(s):      pose.pdb_info().temperature(1,1)  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb   2. bfactor(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int, t : float) -> NoneType   Sets the temperature of the  <atom_index>  atom of pose residue  <res>  to  <t> chain(...) from builtins.PyCapsule chain(*args, **kwargs) Overloaded function.   1. chain(self : rosetta.core.pose.PDBInfo, res : int) -> str   Returns the chain id for pose residue  <res>    example(s):      pose.pdb_info().chain(3)  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb   2. chain(self : rosetta.core.pose.PDBInfo, res : int, chain_id : str) -> NoneType   Sets the chain id of pose residue  <res>  to  <chain_id>      chain id should not be the empty record character, currently '^'      Returns the pdb insertion code of residue  <res>    example(s):      pose.pdb_info().chain(3,"R")  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb clear_reslabel(...) from builtins.PyCapsule clear_reslabel(self : rosetta.core.pose.PDBInfo, res : int) -> NoneType   clean all the label(s) associated to a pose resid.       residue in pose numbering copy(...) from builtins.PyCapsule copy(self : rosetta.core.pose.PDBInfo, input_info : rosetta.core.pose.PDBInfo, copy_from : int, copy_to : int, start_from : int) -> NoneType   Copyies a section from PDBInfo  <input_info>      the PDBInfo to copy from      the first residue position in input_info to copy      the final residue position in input_info to copy      the first residue position in this PDBInfo to   copy into crystinfo(...) from builtins.PyCapsule crystinfo(rosetta.core.pose.PDBInfo) -> rosetta.core.io.CrystInfo   Returns the pdb crystinfo delete_res(...) from builtins.PyCapsule delete_res(*args, **kwargs) Overloaded function.   1. delete_res(self : rosetta.core.pose.PDBInfo, res : int) -> NoneType   Deletes  <n>  residue records starting from pose residue  <res>       residue to start deleting from (in internal/pose numbering)         number of residue records to delete   2. delete_res(self : rosetta.core.pose.PDBInfo, res : int, n : int) -> NoneType   Deletes  <n>  residue records starting from pose residue  <res>       residue to start deleting from (in internal/pose numbering)         number of residue records to delete detach_from(...) from builtins.PyCapsule detach_from(rosetta.core.pose.PDBInfo) -> NoneType   Detaches the Conformation and stops observation      takes no arguments because PDBInfo can only observe one  Conformation at a time    example(s):      pose.pdb_info().detach_from()  See also:      Pose      PDBInfo empty_record(...) from builtins.PyCapsule empty_record() -> str   Returns the chain id character specifying "empty record",  currently '^' get_num_unrecognized_atoms(...) from builtins.PyCapsule get_num_unrecognized_atoms(rosetta.core.pose.PDBInfo) -> int get_num_unrecognized_res(...) from builtins.PyCapsule get_num_unrecognized_res(rosetta.core.pose.PDBInfo) -> int get_reslabels(...) from builtins.PyCapsule get_reslabels(self : rosetta.core.pose.PDBInfo, res : int) -> rosetta.utility.vector1_std_string   returns the pose(number) labels associated to the residue       residue in pose numbering get_unrecognized_atoms(...) from builtins.PyCapsule get_unrecognized_atoms(rosetta.core.pose.PDBInfo) -> rosetta.utility.vector1_core_pose_UnrecognizedAtomRecord   remembers info about atoms not read into the pose get_unrecognized_res_name(...) from builtins.PyCapsule get_unrecognized_res_name(self : rosetta.core.pose.PDBInfo, i : int) -> str get_unrecognized_res_size(...) from builtins.PyCapsule get_unrecognized_res_size(self : rosetta.core.pose.PDBInfo, i : int) -> int header_information(...) from builtins.PyCapsule header_information(*args, **kwargs) Overloaded function.   1. header_information(self : rosetta.core.pose.PDBInfo, header_information : rosetta.core.io.HeaderInformation) -> NoneType   Note: The header information is only initialized if it is needed.  Generally this requires using the -run:preserve_header options flag.   2. header_information(rosetta.core.pose.PDBInfo) -> rosetta.core.io.HeaderInformation   3. header_information(rosetta.core.pose.PDBInfo) -> rosetta.core.io.HeaderInformation icode(...) from builtins.PyCapsule icode(*args, **kwargs) Overloaded function.   1. icode(self : rosetta.core.pose.PDBInfo, res : int) -> str   Returns the pdb insertion code of residue  <res>    example(s):      pose.pdb_info().icode(3)  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb   2. icode(self : rosetta.core.pose.PDBInfo, res : int, ins_code : str) -> NoneType   Sets the insertion code of pose residue  <res>  to  _code>      Returns the pdb insertion code of residue  <res>    example(s):    See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb is_het(...) from builtins.PyCapsule is_het(*args, **kwargs) Overloaded function.   1. is_het(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int) -> bool   Returns true if the  <atom_index>  atom of pose residue  <res>  is a heteratom     : atom index within instance of core::conformation::Residue,  currently Rosetta's pdb file output treats the value of .is_het() as an  override -- if this is set to true, the record will be hetatm, otherwise it  will decide by Residue type (the usual default)   2. is_het(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int, flag : bool) -> NoneType   Sets the heteroatom flag of the  <atom_index>  atom of pose  residue  <res>  to  <flag>      currently Rosetta's pdb file output treats the value of .is_het() as an  override -- if this is set to true, the record will be hetatm, otherwise it  will decide by Residue type (the usual default) is_observing(...) from builtins.PyCapsule is_observing(rosetta.core.pose.PDBInfo) -> rosetta.std.weak_ptr_const_core_conformation_Conformation_t   Returns the Conformation if this PDBInfo is currently observing  a conformation, otherwise return NULL    example(s):      pose.pdb_info().is_observing()  See also:      Pose      PDBInfo modeltag(...) from builtins.PyCapsule modeltag(*args, **kwargs) Overloaded function.   1. modeltag(rosetta.core.pose.PDBInfo) -> str   Returns the model tag for a multi-model pdb    example(s):      pose.pdb_info().modeltag()  See also:      Pose      PDBInfo   2. modeltag(self : rosetta.core.pose.PDBInfo, tag : str) -> NoneType   Sets the model tag for a multi-model pdb to  <tag>    example(s):      pose.pdb_info().modeltag('Number1')  See also:      Pose      PDBInfo name(...) from builtins.PyCapsule name(*args, **kwargs) Overloaded function.   1. name(rosetta.core.pose.PDBInfo) -> str   Returns the pdb name    example(s):      pose.pdb_info().name()  See also:      Pose      PDBInfo   2. name(self : rosetta.core.pose.PDBInfo, s : str) -> NoneType   Sets the pdb name    example(s):      pose.pdb_info().name('MyPDB')  See also:      Pose      PDBInfo natoms(...) from builtins.PyCapsule natoms(self : rosetta.core.pose.PDBInfo, res : int) -> int   Returns the number of atoms represented for the residue  <res>     : residue  <res>  must be in pose numbering    example(s):      pose.pdb_info().natoms(3)  See also:      Pose      PDBInfo nres(...) from builtins.PyCapsule nres(rosetta.core.pose.PDBInfo) -> int   Returns the number of residues represented in PDBInfo    example(s):      pose.pdb_info().nres()  See also:      Pose      PDBInfo number(...) from builtins.PyCapsule number(*args, **kwargs) Overloaded function.   1. number(self : rosetta.core.pose.PDBInfo, res : int) -> int   Returns the pdb sequence number of pose residue  <res>    example(s):      pose.pdb_info().number(3)  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb   2. number(self : rosetta.core.pose.PDBInfo, res : int, pdb_res : int) -> NoneType   Sets the pdb sequence residue number of pose residue  <res>  to  <pdb_res>      Returns the pdb insertion code of residue  <res>    example(s):      pose.pdb_info().number(3,81)  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb obsolete(...) from builtins.PyCapsule obsolete(*args, **kwargs) Overloaded function.   1. obsolete(rosetta.core.pose.PDBInfo) -> bool   Returns true if PDBInfo is obsolete and needs updating      This flag is currently not used within the class and  is provided for user convenience.  Setting this will  forcibly turn off pdb numbering when dumping pdbs.    example(s):      pose.pdb_info().obsolete()  See also:      Pose      PDBInfo   2. obsolete(self : rosetta.core.pose.PDBInfo, flag : bool) -> NoneType   Sets the obsolete state to  <flag>      this flag is currently not used within the class and  is provided for user convenience.  Setting this will  forcibly turn off pdb numbering when dumping pdbs. occupancy(...) from builtins.PyCapsule occupancy(*args, **kwargs) Overloaded function.   1. occupancy(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int) -> float   Returns the occupancy for the  <atom_index>  atom  of pose residue  <res>    example(s):      pose.pdb_info().occupancy(1,1)  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb   2. occupancy(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int, occ : float) -> NoneType   Sets the occupancy of the  <atom_index>  atom of pose residue  <res>  to  <occ> on_connection_change(...) from builtins.PyCapsule on_connection_change(self : rosetta.core.pose.PDBInfo, event : rosetta.core.conformation.signals.ConnectionEvent) -> NoneType   Updates when connection to Conformation is changed on_identity_change(...) from builtins.PyCapsule on_identity_change(self : rosetta.core.pose.PDBInfo, event : rosetta.core.conformation.signals.IdentityEvent) -> NoneType   Updates atom records when residue identity changes in Conformation on_length_change(...) from builtins.PyCapsule on_length_change(self : rosetta.core.pose.PDBInfo, event : rosetta.core.conformation.signals.LengthEvent) -> NoneType   Updates residue and atom records when length changes in Conformation,  obsoletes PDBInfo pdb2pose(...) from builtins.PyCapsule pdb2pose(*args, **kwargs) Overloaded function.   1. pdb2pose(self : rosetta.core.pose.PDBInfo, chain : str, res : int) -> int   Returns the pose numbering of the pdb residue with chain  <chain>,  pdb residue  <res>, and insertion code  <icode>     :  <icode>  is not required, returns 0 if not found,  pose numbering is sequential ie. starts at 1 and goes up  pdb numbering can be anything    example(s):      pose.pdb_info().pdb2pose("B",5)  See also:      Pose      PDBInfo      PDBInfo.pose2pdb   2. pdb2pose(self : rosetta.core.pose.PDBInfo, chain : str, res : int, icode : str) -> int   Returns the pose numbering of the pdb residue with chain  <chain>,  pdb residue  <res>, and insertion code  <icode>     :  <icode>  is not required, returns 0 if not found,  pose numbering is sequential ie. starts at 1 and goes up  pdb numbering can be anything    example(s):      pose.pdb_info().pdb2pose("B",5)  See also:      Pose      PDBInfo      PDBInfo.pose2pdb   3. pdb2pose(rosetta.core.pose.PDBInfo) -> rosetta.core.pose.PDBPoseMap   Returns the internally maintained PDBPoseMap    example(s):    See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb pose2pdb(...) from builtins.PyCapsule pose2pdb(self : rosetta.core.pose.PDBInfo, res : int) -> str   Returns the pdb numbering string of pose residue  <res>     : 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 prepend_res(...) from builtins.PyCapsule prepend_res(*args, **kwargs) Overloaded function.   1. prepend_res(self : rosetta.core.pose.PDBInfo, res : int, natoms : int) -> NoneType   Prepends residue records before given pose residue number  <res>       residue to prepend before (in internal/pose numbering)       number of atoms in type of appended residue         number of residue records to prepend   2. prepend_res(self : rosetta.core.pose.PDBInfo, res : int, natoms : int, n : int) -> NoneType   Prepends residue records before given pose residue number  <res>       residue to prepend before (in internal/pose numbering)       number of atoms in type of appended residue         number of residue records to prepend rebuild_pdb2pose(...) from builtins.PyCapsule rebuild_pdb2pose(rosetta.core.pose.PDBInfo) -> NoneType   rebuilds PDBPoseMap from scratch remarks(...) from builtins.PyCapsule remarks(*args, **kwargs) Overloaded function.   1. remarks(rosetta.core.pose.PDBInfo) -> rosetta.core.io.Remarks   Returns the pdb remarks (const)    example(s):      pose.pdb_info().remarks()  See also:      Pose      PDBInfo   2. remarks(rosetta.core.pose.PDBInfo) -> rosetta.core.io.Remarks   Returns the pdb remarks (mutable)      we allow direct access to the remarks vector because its  state is independent of the rest of PDBInfo and it's much more  convenient for the user    example(s):      pose.pdb_info().remarks()  See also:      Pose      PDBInfo   3. remarks(self : rosetta.core.pose.PDBInfo, in : rosetta.core.io.Remarks) -> NoneType   Sets the pdb remarks to  <in>    example(s):    See also:      Pose      PDBInfo replace_res(...) from builtins.PyCapsule replace_res(self : rosetta.core.pose.PDBInfo, res : int, natoms : int) -> NoneType   "Replaces" residue record for pose residue  <res>      Leaves information in residue record untouched, but resizes  and zeroes atom records for the residue.      residue to replace      number of atoms in type of residue replace_res_remap_bfactors(...) from builtins.PyCapsule replace_res_remap_bfactors(self : rosetta.core.pose.PDBInfo, res : int, tgt : rosetta.core.conformation.Residue) -> NoneType   same as replace_res BUT remaps B factors from src to tgt res_haslabel(...) from builtins.PyCapsule res_haslabel(self : rosetta.core.pose.PDBInfo, res : int, target_label : str) -> bool   uses std iterators to check if a residue has a label associated to it       residue in pose numbering      string to look for inside the labes associated to the residue resize_atom_records(...) from builtins.PyCapsule resize_atom_records(*args, **kwargs) Overloaded function.   1. resize_atom_records(self : rosetta.core.pose.PDBInfo, res : int, n : int) -> NoneType   Ensures  <n>  atom records for residue  <res>  are available     : if  <zero>  is true, zero the atom records for this residue   2. resize_atom_records(self : rosetta.core.pose.PDBInfo, res : int, n : int, zero : bool) -> NoneType   Ensures  <n>  atom records for residue  <res>  are available     : if  <zero>  is true, zero the atom records for this residue   3. resize_atom_records(self : rosetta.core.pose.PDBInfo, n : int) -> NoneType   Ensures  <n>  atom records for residue  <res>  are available     : if  <zero>  is true, zero the atom records for this residue   4. resize_atom_records(self : rosetta.core.pose.PDBInfo, n : int, zero : bool) -> NoneType   Ensures  <n>  atom records for residue  <res>  are available     : if  <zero>  is true, zero the atom records for this residue   5. resize_atom_records(self : rosetta.core.pose.PDBInfo, pose : rosetta.core.pose.Pose) -> NoneType   Updates the number of atom records with respect to atoms in  <pose>      Number of internally available atom records will be adjusted  to match number of atoms within each residue in Pose.  Only newly  created records will be zeroed, any existing records are untouched. resize_residue_records(...) from builtins.PyCapsule resize_residue_records(self : rosetta.core.pose.PDBInfo, n : int) -> NoneType   Resizes for  <n>  residue records      Leaves atom record state inconsistent.  Atom records for  remaining residues are untouched while new residues have no atom  records, so make sure and call one of resize_atom_records()  afterwards if necessary.      Do not use this method for ins/del of residues, as it leaves  the data state inconsistent.  See append_res/prepend_res/delete_res  for that type of functionality. segmentID(...) from builtins.PyCapsule segmentID(*args, **kwargs) Overloaded function.   1. segmentID(self : rosetta.core.pose.PDBInfo, res : int) -> str   2. segmentID(self : rosetta.core.pose.PDBInfo, res : int, segmentID : str) -> NoneType   Sets the insertion code of pose residue  <res>  to  _code>      Returns the pdb insertion code of residue  <res>    example(s):    See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb set_chains(...) from builtins.PyCapsule set_chains(self : rosetta.core.pose.PDBInfo, id : str) -> NoneType   Sets all residue chain ids to the character  <id> set_crystinfo(...) from builtins.PyCapsule set_crystinfo(self : rosetta.core.pose.PDBInfo, crystinfoin : rosetta.core.io.CrystInfo) -> NoneType   Sets the pdb crystinfo set_resinfo(...) from builtins.PyCapsule set_resinfo(*args, **kwargs) Overloaded function.   1. set_resinfo(self : rosetta.core.pose.PDBInfo, res : int, chain_id : str, pdb_res : int) -> NoneType   Sets the chain id, pdb sequence residue numbering, and insertion  code for pose residue  <res>  to  <chain_id>  ,  <pdb_res>  , and  _code>  respectfully     : convenience method; more efficient than doing each individually  due to map updates      Returns the pdb insertion code of residue  <res>    example(s):      pose.pdb_info().icode(3)  See also:      Pose      PDBInfo      PDBInfo.chain      PDBInfo.icode      PDBInfo.number      PDBInfo.pdb2pose      PDBInfo.pose2pdb   2. set_resinfo(self : rosetta.core.pose.PDBInfo, res : int, chain_id : str, pdb_res : int, ins_code : str) -> NoneType   Sets the chain id, pdb sequence residue numbering, and insertion  code for pose residue  <res>  to  <chain_id>  ,  <pdb_res>  , and  _code>  respectfully     : convenience method; more efficient than doing each individually  due to map updates      Returns the pdb insertion code of residue  <res>    example(s):      pose.pdb_info().icode(3)  See also:      Pose      PDBInfo      PDBInfo.chain      PDBInfo.icode      PDBInfo.number      PDBInfo.pdb2pose      PDBInfo.pose2pdb temperature(...) from builtins.PyCapsule temperature(*args, **kwargs) Overloaded function.   1. temperature(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int) -> float   Returns the temperature for the  <atom_index>  atom of pose residue  <res>    example(s):      pose.pdb_info().temperature(1,1)  See also:      Pose      PDBInfo      PDBInfo.pdb2pose      PDBInfo.pose2pdb   2. temperature(self : rosetta.core.pose.PDBInfo, res : int, atom_index : int, t : float) -> NoneType   Sets the temperature of the  <atom_index>  atom of pose residue  <res>  to  <t> tighten_memory(...) from builtins.PyCapsule tighten_memory(rosetta.core.pose.PDBInfo) -> NoneType   Tightens memory usage   class PDBPoseMap(builtins.object)     PDBPoseMap can be queried with PDB information (chain, sequence position) and returns a pose's resid position.  Useful for handing input/output in terms of PDB positions.  Can be tucked into the pose for repeated access, or generated just-in-time for a single use.  Basically a wrapper class for std::map.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.pose.PDBPoseMap) -> NoneType   2. __init__(self : rosetta.core.pose.PDBPoseMap, info : core::pose::PDBInfo) -> NoneType   3. __init__(self : rosetta.core.pose.PDBPoseMap, map : rosetta.core.pose.PDBPoseMap) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.pose.PDBPoseMap, m : rosetta.core.pose.PDBPoseMap) -> rosetta.core.pose.PDBPoseMap   copy assignment clear(...) from builtins.PyCapsule clear(rosetta.core.pose.PDBPoseMap) -> NoneType   clear the current mapping data conditional_erase(...) from builtins.PyCapsule conditional_erase(self : rosetta.core.pose.PDBPoseMap, chain : str, pdb_res : int, ins_code : str, pose_res : int) -> bool   remove mapping for pdb residue key only if Pose residue matches       chain id       pdb residue numbering      insertion code, use ' ' if no insertion code      the mapped Pose residue      true if key-value pair erase, false otherwise erase(...) from builtins.PyCapsule erase(self : rosetta.core.pose.PDBPoseMap, chain : str, pdb_res : int, ins_code : str) -> NoneType   forcibly remove mapping for pdb residue key       chain id       pdb residue numbering      insertion code, use ' ' if no insertion code fill(...) from builtins.PyCapsule fill(self : rosetta.core.pose.PDBPoseMap, info : core::pose::PDBInfo) -> NoneType   fill with corresponding pdb -> pose residue mapping      does not clear any currently existing mapping data find(...) from builtins.PyCapsule find(*args, **kwargs) Overloaded function.   1. find(self : rosetta.core.pose.PDBPoseMap, chain : str, pdb_res : int) -> int   lookup pose numbering       chain id       pdb residue numbering       insertion code      pose numbering for residue, returns 0 if not found   2. find(self : rosetta.core.pose.PDBPoseMap, chain : str, pdb_res : int, ins_code : str) -> int   lookup pose numbering       chain id       pdb residue numbering       insertion code      pose numbering for residue, returns 0 if not found insert(...) from builtins.PyCapsule insert(self : rosetta.core.pose.PDBPoseMap, chain : str, pdb_res : int, ins_code : str, pose_res : int) -> NoneType   insert pdb -> pose number mapping       chain id       pdb residue numbering      insertion code, use ' ' if no insertion code       pose numbering for residue      if the chain is equal to the PDBInfo's empty record character,   the insertion will be skipped size(...) from builtins.PyCapsule size(rosetta.core.pose.PDBPoseMap) -> int   number of mappings   class Pose(builtins.object)     The Pose class represents a molecular system (protein-dna-ligand...) as a container of Rosetta Residue objects together with a Conformation object that defines how internal coordinate changes propagate through the system and an Energies object that stores information from the last energy evaluation.   The main responsibilities of the pose are:     Kinematic: (a) to update the xyz coordinates in response to changes to internal degrees of freedom, and (b) to update internal coordinates when the user modifes the xyz (Cartesian) coords,     Scoring: (a) to keep track of what parts of the structure have changed since the last score evaluation, and (b) to cache residue and residue-pair energies for efficient re-use    As a container: The pose provides a single object for passing a molecular system and for copying of entire molecules or stretches of molecules from one Pose object into another.   Output Methods: Common Methods: Pose.assign Pose.atom_tree Pose.conformation Pose.dump_pdb Pose.dump_cif Pose.dump_file Pose.energies Pose.fold_tree Pose.pdb_info Pose.residue Pose.sequence Pose.total_residue     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.pose.Pose) -> NoneType   2. __init__(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose) -> NoneType   3. __init__(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose, residue_begin : int, residue_end : int) -> NoneType __iter__ = _Pose_residue_iterator(obj) ############################################################################### # Modifications to Rosetta. # Add iter property to Pose. __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.pose.Pose) -> str aa(...) from builtins.PyCapsule aa(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.chemical.AA   Returns the chemical::AA of the residue at  <seqpos>    example(s):      pose.aa(17)  See also:      Pose  Pose.Residue      Pose.sequence      Residue add_constraint(...) from builtins.PyCapsule add_constraint(self : rosetta.core.pose.Pose, cst : core::scoring::constraints::Constraint) -> core::scoring::constraints::Constraint   adding a constraint is done by cloning the input constraint. A const copy is then returned add_constraints(...) from builtins.PyCapsule add_constraints(self : rosetta.core.pose.Pose, csts : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t alpha(...) from builtins.PyCapsule alpha(self : rosetta.core.pose.Pose, pos : int) -> float   Returns the alpha torsion angle of residue  <seqpos>      assumes the residue is an nucleic acid    example(s):      pose.alpha(1)  See also:      Pose      Pose.residue      Pose.set_alpha      Residue annotated_sequence(...) from builtins.PyCapsule annotated_sequence(*args, **kwargs) Overloaded function.   1. annotated_sequence(rosetta.core.pose.Pose) -> 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   2. annotated_sequence(self : rosetta.core.pose.Pose, show_all_variants : bool) -> str   Returns the variant-tagged string representing the  residue types that make up a conformation; e.g.  M[MET:N-Terminus-Variant]CDH[HIS_D]LLR[ARG:C-Terminus-Variant]    example(s):      pose.annotated_sequence()  See also:      Pose      Pose.sequence      Pose.total_residue  Residue append_polymer_residue_after_seqpos(...) from builtins.PyCapsule append_polymer_residue_after_seqpos(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, seqpos : int, build_ideal_geometry : bool) -> NoneType   glues to seqpos and perhaps also seqpos+1 append_pose_by_jump(...) from builtins.PyCapsule append_pose_by_jump(*args, **kwargs) Overloaded function.   1. append_pose_by_jump(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose, jump_anchor_residue : int) -> NoneType   Appends source pose conformation to pose by a new jump   2. append_pose_by_jump(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose, jump_anchor_residue : int, jump_anchor_atom : str) -> NoneType   Appends source pose conformation to pose by a new jump   3. append_pose_by_jump(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose, jump_anchor_residue : int, jump_anchor_atom : str, jump_root_atom : str) -> NoneType   Appends source pose conformation to pose by a new jump append_residue_by_atoms(...) from builtins.PyCapsule append_residue_by_atoms(*args, **kwargs) Overloaded function.   1. append_residue_by_atoms(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connect_atom : str, anchor_rsd_seqpos : int, anchor_connect_atom : str) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond to a given atom      This function effectively wraps append_residue_by_bond for an easier syntax. Instead  of having to know what the connection, anchor residue, and anchor connection are, we give the  atoms and query the ResidueType for the remaining information.    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved.   2. append_residue_by_atoms(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connect_atom : str, anchor_rsd_seqpos : int, anchor_connect_atom : str, start_new_chain : bool) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond to a given atom      This function effectively wraps append_residue_by_bond for an easier syntax. Instead  of having to know what the connection, anchor residue, and anchor connection are, we give the  atoms and query the ResidueType for the remaining information.    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved.   3. append_residue_by_atoms(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connect_atom : str, anchor_rsd_seqpos : int, anchor_connect_atom : str, start_new_chain : bool, lookup_bond_length : bool) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond to a given atom      This function effectively wraps append_residue_by_bond for an easier syntax. Instead  of having to know what the connection, anchor residue, and anchor connection are, we give the  atoms and query the ResidueType for the remaining information.    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved. append_residue_by_bond(...) from builtins.PyCapsule append_residue_by_bond(*args, **kwargs) Overloaded function.   1. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond      The default behavior is to append by a polymeric connection to the preceding residue  If we want to connect via a non-polymer connection, we give the connection number, anchor residue  and the connection number for the anchor residue. These connection numbers are wrt the connections_  arrays in Residue and ResidueType    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved.   2. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond      The default behavior is to append by a polymeric connection to the preceding residue  If we want to connect via a non-polymer connection, we give the connection number, anchor residue  and the connection number for the anchor residue. These connection numbers are wrt the connections_  arrays in Residue and ResidueType    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved.   3. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond      The default behavior is to append by a polymeric connection to the preceding residue  If we want to connect via a non-polymer connection, we give the connection number, anchor residue  and the connection number for the anchor residue. These connection numbers are wrt the connections_  arrays in Residue and ResidueType    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved.   4. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int, anchor_residue : int) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond      The default behavior is to append by a polymeric connection to the preceding residue  If we want to connect via a non-polymer connection, we give the connection number, anchor residue  and the connection number for the anchor residue. These connection numbers are wrt the connections_  arrays in Residue and ResidueType    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved.   5. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int, anchor_residue : int, anchor_connection : int) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond      The default behavior is to append by a polymeric connection to the preceding residue  If we want to connect via a non-polymer connection, we give the connection number, anchor residue  and the connection number for the anchor residue. These connection numbers are wrt the connections_  arrays in Residue and ResidueType    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved.   6. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int, anchor_residue : int, anchor_connection : int, start_new_chain : bool) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond      The default behavior is to append by a polymeric connection to the preceding residue  If we want to connect via a non-polymer connection, we give the connection number, anchor residue  and the connection number for the anchor residue. These connection numbers are wrt the connections_  arrays in Residue and ResidueType    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved.   7. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int, anchor_residue : int, anchor_connection : int, start_new_chain : bool, lookup_bond_length : bool) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new bond      The default behavior is to append by a polymeric connection to the preceding residue  If we want to connect via a non-polymer connection, we give the connection number, anchor residue  and the connection number for the anchor residue. These connection numbers are wrt the connections_  arrays in Residue and ResidueType    If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond  geometry of the new bond is ideal according to the icoor_internal data in the residues.    Otherwise the incoming coordinates of new_rsd are preserved. append_residue_by_jump(...) from builtins.PyCapsule append_residue_by_jump(*args, **kwargs) Overloaded function.   1. append_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, jump_anchor_residue : int) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new jump   2. append_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, jump_anchor_residue : int, jump_anchor_atom : str) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new jump   3. append_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, jump_anchor_residue : int, jump_anchor_atom : str, jump_root_atom : str) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new jump   4. append_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, jump_anchor_residue : int, jump_anchor_atom : str, jump_root_atom : str, start_new_chain : bool) -> NoneType   Appends  <new_rsd>  (a residue) to pose by a new jump apply_transform_Rx_plus_v(...) from builtins.PyCapsule apply_transform_Rx_plus_v(self : rosetta.core.pose.Pose, R : rosetta.numeric.xyzMatrix_double_t, v : rosetta.numeric.xyzVector_double_t) -> NoneType   Apply a transform of the Rx + v form, where R is a  rotation matrix and v is a translation vector. assign(...) from builtins.PyCapsule assign(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose) -> rosetta.core.pose.Pose   Copies <src> into the pose where it remains possible that two  Poses may point to each other in non-const ways or share non-bitwise  constant data between them (E.g. the AtomTree observer system).    example(s):      test_pose.assign(pose)  See also:      Pose atom_tree(...) from builtins.PyCapsule atom_tree(rosetta.core.pose.Pose) -> core::kinematics::AtomTree   Returns the pose AtomTree batch_get_xyz(...) from builtins.PyCapsule batch_get_xyz(self : rosetta.core.pose.Pose, ids : rosetta.utility.vector1_core_id_AtomID, points : rosetta.utility.vector1_numeric_xyzVector_double_t) -> NoneType   Gets the locations (xyz) of pose AtomIDs in  <ids> batch_set_xyz(...) from builtins.PyCapsule batch_set_xyz(self : rosetta.core.pose.Pose, ids : rosetta.utility.vector1_core_id_AtomID, points : rosetta.utility.vector1_numeric_xyzVector_double_t) -> NoneType   Sets the locations (xyz) of pose AtomIDs in  <ids>  to mathcing PointPositions in  <points> beta(...) from builtins.PyCapsule beta(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the beta torsion angle of residue  <seqpos>      assumes the residue is an nucleic acid    example(s):      pose.beta(2)  See also:      Pose      Pose.residue      Pose.set_beta      Residue center(...) from builtins.PyCapsule center(rosetta.core.pose.Pose) -> NoneType   Sets pose coordinates such that the pose center is at the Euclidean origin chain(...) from builtins.PyCapsule chain(self : rosetta.core.pose.Pose, seqpos : int) -> int   Returns the chain number of residue  <seqpos>    example(s):      pose.chain(3)  See also:      Pose      Pose.annotated_sequence  Pose.chain_sequence      Pose.fold_tree      Pose.sequence      FoldTree chain_sequence(...) from builtins.PyCapsule chain_sequence(self : rosetta.core.pose.Pose, chain_in : int) -> str   Returns the sequence for the chain <chain_in>    Example(s):      pose.chain_sequence(1)  See also:      Pose      Pose.chain      Pose.residue      Pose.sequence chi(...) from builtins.PyCapsule chi(*args, **kwargs) Overloaded function.   1. chi(self : rosetta.core.pose.Pose, chino : int, seqpos : int) -> float   Returns the  <chino>  chi torsion angle of residue  <seqpos>      assumes the residue is an amino acid or monosaccharide    example(s):      pose.chi(1,7)  See also:      Pose      Pose.set_chi      Pose.residue      Residue   2. chi(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the chi torsion angle of residue  <seqpos>      assumes the residue is an nucleic acid    example(s):      pose.chi(7)  See also:      Pose      Pose.residue      Pose.set_chi      Residue clear(...) from builtins.PyCapsule clear(rosetta.core.pose.Pose) -> NoneType   Empty the pose contents    example(s):      pose.clear()  See also:      Pose      Pose.assign      Pose.empty clear_sequence_constraints(...) from builtins.PyCapsule clear_sequence_constraints(rosetta.core.pose.Pose) -> NoneType   Remove all sequence constraints from this pose. clone(...) from builtins.PyCapsule clone(rosetta.core.pose.Pose) -> rosetta.core.pose.Pose   clone the conformation conformation(...) from builtins.PyCapsule conformation(*args, **kwargs) Overloaded function.   1. conformation(rosetta.core.pose.Pose) -> rosetta.core.conformation.Conformation   Returns the pose Conformation (const-access)    example(s):      pose.Conformation()  See also:      Pose      Conformation   2. conformation(rosetta.core.pose.Pose) -> rosetta.core.conformation.Conformation   Returns the pose Conformation (non-const access) conformation_ptr(...) from builtins.PyCapsule conformation_ptr(*args, **kwargs) Overloaded function.   1. conformation_ptr(rosetta.core.pose.Pose) -> rosetta.core.conformation.Conformation   Returns the pose Conformation pointer (const access)   2. conformation_ptr(rosetta.core.pose.Pose) -> rosetta.core.conformation.Conformation   Returns the pose Conformation pointer (const access)      WHOA: This is not cool.  The Pose cannot hand out access to the OP directly. Do not use. const_data_cache(...) from builtins.PyCapsule const_data_cache(rosetta.core.pose.Pose) -> rosetta.basic.datacache.ConstDataMap   Read access to the const data cache constraint_set(...) from builtins.PyCapsule constraint_set(*args, **kwargs) Overloaded function.   1. constraint_set(rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet   2. constraint_set(self : rosetta.core.pose.Pose,  : core::scoring::constraints::ConstraintSet) -> NoneType copy_segment(...) from builtins.PyCapsule copy_segment(self : rosetta.core.pose.Pose, size : int, src : rosetta.core.pose.Pose, begin : int, src_begin : int) -> NoneType   Copy a stretch of coordinates/torsions from  <src>  to pose corresponding_residue_in_current(...) from builtins.PyCapsule corresponding_residue_in_current(self : rosetta.core.pose.Pose, ref_residue_index : int, ref_pose_name : str) -> int   Returns the index of a residue in this pose corresponding to a residue in a reference pose.      Throws an error if the reference pose with the given name doesn't exist, or the residue number  doesn't exist in that reference pose.  Returns zero if no corresponding residue exists in this pose (e.g.  if the residue in question has been deleted. data(...) from builtins.PyCapsule data(*args, **kwargs) Overloaded function.   1. data(rosetta.core.pose.Pose) -> rosetta.basic.datacache.BasicDataCache   BasicDataCache indexed by enum in core/pose/datacache/CacheableDataType.hh   2. data(rosetta.core.pose.Pose) -> rosetta.basic.datacache.BasicDataCache   BasicDataCache indexed by enum in core/pose/datacache/CacheableDataType.hh decrement_reference_pose_mapping_after_seqpos(...) from builtins.PyCapsule decrement_reference_pose_mapping_after_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType   Find all mappings in the new pose after seqpos in all ReferencePose objects, and decrement them by 1.      If there is no ReferencePose object, do nothing. delete_polymer_residue(...) from builtins.PyCapsule delete_polymer_residue(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType   Delete a residue in the pose.   Update Observers.   Update any Reference Poses delete_residue_range_slow(...) from builtins.PyCapsule delete_residue_range_slow(self : rosetta.core.pose.Pose, start : int, end : int) -> NoneType   Delete a range of residues in the pose.      Calls confromation::delete_residue_range_slow().   Update Observers.   Update any Reference Poses delete_residue_slow(...) from builtins.PyCapsule delete_residue_slow(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType   Slow method that relies on FoldTree::delete_seqpos, rebuilds atomtree, can handle jumps/root residue.   Update Observers.   Update any Reference Poses delta(...) from builtins.PyCapsule delta(self : rosetta.core.pose.Pose, pos : int) -> float   Returns the delta torsion angle of residue  <seqpos>      assumes the residue is an nucleic acid    example(s):      pose.delta(4)  See also:      Pose      Pose.residue      Pose.set_delta      Residue detached_copy(...) from builtins.PyCapsule detached_copy(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose) -> NoneType   Performs a deep copy of the src Pose into this Pose in a way  that guarantees that no non-bitwise-constant data is shared between  them (such as the AtomTree's observer system) -- this Pose will be  effectively detached from any data that lives in other objects. dof(...) from builtins.PyCapsule dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID) -> float   Returns the value of the AtomTree DOF  <id>    See also:      Pose      DOF_ID dump_cif(...) from builtins.PyCapsule dump_cif(self : rosetta.core.pose.Pose, file_name : str) -> NoneType   Export pose data to the mmCIF file  <file_name>    example(s):      pose.dump_cif('new_01.cif')  See also:      Pose      pose_from_cif      dump_file dump_file(...) from builtins.PyCapsule dump_file(self : rosetta.core.pose.Pose, file_name : str) -> NoneType   Export pose data to a file, <file_name>, determining which type of file format to write based on the file extension    example(s):      pose.dump_file('new_01.pdb')      pose.dump_file('new_01.cif')  See also:      Pose      dump_cif      dump_file dump_pdb(...) from builtins.PyCapsule dump_pdb(*args, **kwargs) Overloaded function.   1. dump_pdb(self : rosetta.core.pose.Pose, file_name : str) -> bool   Export pose data to the PDB file  <file_name>    example(s):      pose.dump_pdb('new_01.pdb')  See also:      Pose      pose_from_pdb      dump_cif      dump_file   2. dump_pdb(self : rosetta.core.pose.Pose, file_name : str, tag : str) -> bool   Export pose data to the PDB file  <file_name>    example(s):      pose.dump_pdb('new_01.pdb')  See also:      Pose      pose_from_pdb      dump_cif      dump_file dump_scored_pdb(...) from builtins.PyCapsule dump_scored_pdb(*args, **kwargs) Overloaded function.   1. dump_scored_pdb(self : rosetta.core.pose.Pose, file_name : str, scorefxn : core::scoring::ScoreFunction) -> NoneType   Export pose data to the PDB file  <file_name>,  add some score output   2. dump_scored_pdb(self : rosetta.core.pose.Pose, file_name : str, scorefxn : core::scoring::ScoreFunction, tag : str) -> NoneType   Export pose data to the PDB file  <file_name>,  add some score output empty(...) from builtins.PyCapsule empty(rosetta.core.pose.Pose) -> bool   Returns true if there are no residues in the conformation    example(s):      pose.empty()  See also:      Pose      Pose.clear  Pose.sequence      Pose.total_residue energies(...) from builtins.PyCapsule energies(*args, **kwargs) Overloaded function.   1. energies(rosetta.core.pose.Pose) -> core::scoring::Energies   ////////////////////////////////////////      Returns the pose Energies (const-access)    example(s):      pose.energies()  See also:      Pose      Energies      PDBInfo      ScoreFunction      create_score_function   2. energies(rosetta.core.pose.Pose) -> core::scoring::Energies   Returns the pose Energies (non-const access) epsilon(...) from builtins.PyCapsule epsilon(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the epsilon torsion angle of residue  <seqpos>      assumes the residue is an nucleic acid    example(s):      pose.epsilon(5)  See also:      Pose      Pose.residue      Pose.set_epsilon      Residue fold_tree(...) from builtins.PyCapsule fold_tree(*args, **kwargs) Overloaded function.   1. fold_tree(rosetta.core.pose.Pose) -> rosetta.core.kinematics.FoldTree   Returns the pose FoldTree    example(s):      pose.fold_tree()  See also:      Pose      FoldTree   2. fold_tree(self : rosetta.core.pose.Pose, fold_tree_in : rosetta.core.kinematics.FoldTree) -> NoneType   Sets the pose FoldTree to  <fold_tree_in>    example(s):      pose.fold_tree( foldtree )  See also:      Pose      pose.fold_tree      FoldTree gamma(...) from builtins.PyCapsule gamma(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the gamma torsion angle of residue  <seqpos>      assumes the residue is an nucleic acid    example(s):      pose.gamma(3)  See also:      Pose      Pose.residue      Pose.set_gamma      Residue get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.core.pose.Pose) -> rosetta.core.pose.Pose   self pointers   2. get_self_ptr(rosetta.core.pose.Pose) -> rosetta.core.pose.Pose get_self_weak_ptr(...) from builtins.PyCapsule get_self_weak_ptr(*args, **kwargs) Overloaded function.   1. get_self_weak_ptr(rosetta.core.pose.Pose) -> rosetta.std.weak_ptr_const_core_pose_Pose_t   2. get_self_weak_ptr(rosetta.core.pose.Pose) -> rosetta.std.weak_ptr_core_pose_Pose_t has_dof(...) from builtins.PyCapsule has_dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID) -> bool   Returns true if pose has DOF  <id>    See also:      Pose      DOF_ID has_reference_pose(...) from builtins.PyCapsule has_reference_pose(rosetta.core.pose.Pose) -> bool   Returns true if a pose has at least one reference pose, false otherwise. increment_reference_pose_mapping_after_seqpos(...) from builtins.PyCapsule increment_reference_pose_mapping_after_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType   Find all mappings in the new pose after seqpos in all ReferencePose objects, and increment them by 1.      If there is no ReferencePose object, do nothing. insert_residue_by_bond(...) from builtins.PyCapsule insert_residue_by_bond(*args, **kwargs) Overloaded function.   1. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos>   2. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos>   3. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool, anchor_atom : str) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos>   4. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool, anchor_atom : str, root_atom : str) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos>   5. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool, anchor_atom : str, root_atom : str, new_chain : bool) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos>   6. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool, anchor_atom : str, root_atom : str, new_chain : bool, lookup_bond_length : bool) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos> insert_residue_by_jump(...) from builtins.PyCapsule insert_residue_by_jump(*args, **kwargs) Overloaded function.   1. insert_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos>   2. insert_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, anchor_atomno : str) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos>   3. insert_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, anchor_atomno : str, root_atomno : str) -> NoneType   This code sorely belongs in Pose.cc      Adds  <new_rsd_in>  to pose at  <seqpos> is_centroid(...) from builtins.PyCapsule is_centroid(rosetta.core.pose.Pose) -> bool   Returns true if pose is ResidueType centroid      convenience test for residue_type_set ( based on two  middle residue -- to avoid hitting on ligands or pseudos )    example(s):      pose.is_centroid()  See also:      Pose      Pose.is_fullatom      Residue      ResidueType      this is nt a good test --Doug is_fullatom(...) from builtins.PyCapsule is_fullatom(rosetta.core.pose.Pose) -> bool   Returns true if pose is ResidueType fullatom      convenience test for residue_type_set ( based on two  middle residue -- to avoid hitting on ligands or pseudos )    example(s):      pose.is_fullatom()  See also:      Pose      Pose.is_centroid      Residue      ResidueType      this is nt a good test --Doug jump(...) from builtins.PyCapsule jump(*args, **kwargs) Overloaded function.   1. jump(self : rosetta.core.pose.Pose, jump_number : int) -> rosetta.core.kinematics.Jump   Returns the pose FoldTree Jump  <jump_number>    example(s):      pose.jump(1)  See also:      Pose      Pose.fold_tree      Pose.set_jump      FoldTree      FoldTree.jump_edge      Jump   2. jump(self : rosetta.core.pose.Pose, id : rosetta.core.id.AtomID) -> rosetta.core.kinematics.Jump   Returns the pose FoldTree Jump  <id>    example(s):      pose.set_jump(R5N)  See also:      Pose      Pose.fold_tree      Pose.set_jump      FoldTree      FoldTree.jump_edge      AtomID metric(...) from builtins.PyCapsule metric(self : rosetta.core.pose.Pose, calculator_name : str, key : str, val : rosetta.basic.MetricValueBase) -> NoneType n_residue(...) from builtins.PyCapsule n_residue(rosetta.core.pose.Pose) -> int   Returns the number of residues in the pose conformation  example(s):      pose.n_residue()  See also:      Pose      Pose.sequence      Pose.total_residue num_jump(...) from builtins.PyCapsule num_jump(rosetta.core.pose.Pose) -> int   Returns the number of jumps in the pose FoldTree    example(s):      pose.num_jump()  See also:      Pose      Pose.jump      Pose.set_jump      FoldTree      Jump observer_cache(...) from builtins.PyCapsule observer_cache(*args, **kwargs) Overloaded function.   1. observer_cache(rosetta.core.pose.Pose) -> core::pose::datacache::ObserverCache   ObserverCache indexed by enum in core/pose/datacache/CacheableObserverType.hh   2. observer_cache(rosetta.core.pose.Pose) -> core::pose::datacache::ObserverCache   ObserverCache indexed by enum in core/pose/datacache/CacheableObserverType.hh omega(...) from builtins.PyCapsule omega(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the omega torsion angle of residue  <seqpos>      assumes the residue is an amino acid or monosaccharide    example(s):      pose.omega(3)  See also:      Pose      Pose.residue      Pose.set_omega      Residue pdb_info(...) from builtins.PyCapsule pdb_info(*args, **kwargs) Overloaded function.   1. pdb_info(rosetta.core.pose.Pose) -> core::pose::PDBInfo   Returns the pose PDBInfo (const)    example(s):      pose.pdb_info()  See also:      Pose      Energies      PDBInfo  ScoreFunction  pose_from_pdb      NULL if no PDBInfo instance exists, the pdb info instance otherwise   2. pdb_info(rosetta.core.pose.Pose) -> core::pose::PDBInfo   Returns the pose PDBInfo      NULL if no PDBInfo instance exists, the PDBInfo instance otherwise   3. pdb_info(self : rosetta.core.pose.Pose, new_info : core::pose::PDBInfo) -> core::pose::PDBInfo   Sets pose PDBInfo to <new_info>       the new PDBInfo to copy, pass NULL  if you want to zero the existence of PDBInfo inside this Pose      the prior PDBInfo instance phi(...) from builtins.PyCapsule phi(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the phi torsion angle of residue  <seqpos>      assumes the residue is an amino acid or monosaccharide    example(s):      pose.phi(1)  See also:      Pose      Pose.residue      Pose.set_phi      Residue prepend_polymer_residue_before_seqpos(...) from builtins.PyCapsule prepend_polymer_residue_before_seqpos(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, seqpos : int, build_ideal_geometry : bool) -> NoneType   glues to seqpos and perhaps also seqpos-1 print_metric(...) from builtins.PyCapsule print_metric(self : rosetta.core.pose.Pose, calculator_name : str, key : str) -> str psi(...) from builtins.PyCapsule psi(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the psi torsion angle of residue  <seqpos>  Note: assumes the residue is an amino acid or monosaccharide    example(s):      pose.psi(2)  See also:      Pose      Pose.residue      Pose.set_psi      Residue reference_pose_from_current(...) from builtins.PyCapsule reference_pose_from_current(*args, **kwargs) Overloaded function.   1. reference_pose_from_current(self : rosetta.core.pose.Pose, ref_pose_name : str) -> NoneType   Create a new reference pose from the current state of the pose.      If a ReferencePoseSet object does not exist, this function will create it.   If override_current is set to true, will override any currently set reference pose with the ref_pose_name.   2. reference_pose_from_current(self : rosetta.core.pose.Pose, ref_pose_name : str, override_current : bool) -> NoneType   Create a new reference pose from the current state of the pose.      If a ReferencePoseSet object does not exist, this function will create it.   If override_current is set to true, will override any currently set reference pose with the ref_pose_name. reference_pose_set(...) from builtins.PyCapsule reference_pose_set(rosetta.core.pose.Pose) -> core::pose::reference_pose::ReferencePoseSet   Access the ReferencePoseSet object (non-const).      If a ReferencePoseSet object does not exist, this function will create it. reference_pose_set_cop(...) from builtins.PyCapsule reference_pose_set_cop(rosetta.core.pose.Pose) -> core::pose::reference_pose::ReferencePoseSet   Const-access the ReferencePoseSet object.      If a ReferencePoseSet object does not exist, this function will throw an error. remove_constraint(...) from builtins.PyCapsule remove_constraint(*args, **kwargs) Overloaded function.   1. remove_constraint(self : rosetta.core.pose.Pose, cst : core::scoring::constraints::Constraint) -> bool   re object_comparison see comment for ConstraintSet::remove_constraint function   2. remove_constraint(self : rosetta.core.pose.Pose, cst : core::scoring::constraints::Constraint, object_comparison : bool) -> bool   re object_comparison see comment for ConstraintSet::remove_constraint function remove_constraints(...) from builtins.PyCapsule remove_constraints(*args, **kwargs) Overloaded function.   1. remove_constraints(self : rosetta.core.pose.Pose, csts : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> bool   re object_comparison see comment for ConstraintSet::remove_constraint function   2. remove_constraints(self : rosetta.core.pose.Pose, csts : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, object_comparison : bool) -> bool   re object_comparison see comment for ConstraintSet::remove_constraint function   3. remove_constraints(rosetta.core.pose.Pose) -> bool replace_residue(...) from builtins.PyCapsule replace_residue(*args, **kwargs) Overloaded function.   1. replace_residue(self : rosetta.core.pose.Pose, seqpos : int, new_rsd_in : rosetta.core.conformation.Residue, orient_backbone : bool) -> NoneType   Replaces the residue at  <seqpos>  with  <new_rsd_in>   2. replace_residue(self : rosetta.core.pose.Pose, seqpos : int, new_rsd_in : rosetta.core.conformation.Residue, atom_pairs : rosetta.utility.vector1_std_pair_std_string_std_string_t) -> NoneType   Replaces the residue at  <seqpos>  with  <new_rsd>  based on superposition on the specified input atom pairs  NOTE: at the moment, only superposition on 3 atoms works  This code sorely belongs in Pose.cc residue(...) from builtins.PyCapsule residue(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.conformation.Residue   Returns the Residue at position  <seqpos>  (read access)  Note: this method will trigger a refold if either the  torsions or the coordinates are out-of-date    example(s):      pose.residue(4)  See also:      Pose      Pose.sequence      Pose.total_residue      Residue      ResidueType residue_type(...) from builtins.PyCapsule residue_type(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.chemical.ResidueType   Returns the ResidueType at position  <seqpos>  (read access)  Note: this method NOT will trigger a refold if either  the torsions or the coordinates are out-of-date    example(s):      pose.residue_type(5)  See also:      Pose      Pose.residue      Pose.sequence      Pose.total_residue      Residue      ResidueType scoring_begin(...) from builtins.PyCapsule scoring_begin(self : rosetta.core.pose.Pose, info : core::scoring::ScoreFunction) -> NoneType   Called by ScoreFunction at the beginning of scoring scoring_end(...) from builtins.PyCapsule scoring_end(self : rosetta.core.pose.Pose, scorefxn : core::scoring::ScoreFunction) -> NoneType   Called by ScoreFunction at the end of scoring secstruct(...) from builtins.PyCapsule secstruct(*args, **kwargs) Overloaded function.   1. secstruct(self : rosetta.core.pose.Pose, seqpos : int) -> str   Returns the secondary structure of residue  <seqpos>  this usually comes from fragments. The conformation object  will not invoke DSSP to determine the secondary structure  if e.g. it has not been made from fragments.  'H' = helical  'S' = strand or sheet  'E' = loop  JKL: is this correct? DsspDesignOperations says that  H = helix, E = strand, and L = loop    example(s):      pose.secstruct(3)  See also:      Pose      Pose.residue      Pose.set_secstruct      Residue   2. secstruct(rosetta.core.pose.Pose) -> str   Returns a string representing pose secondary structure    example(s):      pose.secstruct()  See also:      Pose      Pose.residue      Pose.set_secstruct      Residue sequence(...) from builtins.PyCapsule sequence(*args, **kwargs) Overloaded function.   1. sequence(rosetta.core.pose.Pose) -> str   Returns a string representing the 1-letter-coded sequence of the pose conformation.    example(s):      pose.sequence()  See also:      Pose      Pose.annotated_sequence      Pose.chain      Pose.chain_sequence      Pose.residue      Pose.total_residue   2. sequence(self : rosetta.core.pose.Pose, resnum_start : int, resnum_end : int) -> str   Returns a string representing the 1-letter-coded sequence of the pose conformation. From start to end.    example(s):      pose.sequence()  See also:      Pose      Pose.annotated_sequence      Pose.chain      Pose.chain_sequence      Pose.residue      Pose.total_residue set_alpha(...) from builtins.PyCapsule set_alpha(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the alpha torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an nucleic acid    example(s):      pose.set_alpha(1)  See also:      Pose      Pose.alpha      Pose.residue      Residue set_beta(...) from builtins.PyCapsule set_beta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the beta torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an nucleic acid    example(s):      pose.set_beta(2)  See also:      Pose      Pose.beta      Pose.residue      Residue set_chi(...) from builtins.PyCapsule set_chi(*args, **kwargs) Overloaded function.   1. set_chi(self : rosetta.core.pose.Pose, chino : int, seqpos : int, setting : float) -> NoneType   Sets the  <chino>  chi torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an amino acid or monosaccharide    example(s):      pose.set_chi(1,7,120)  See also:      Pose      Pose.chi      Pose.residue      Residue   2. set_chi(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the chi torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an nucleic acid    example(s):      pose.set_chi(7)  See also:      Pose      Pose.chi      Pose.residue      Residue set_delta(...) from builtins.PyCapsule set_delta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the delta torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an nucleic acid    example(s):      pose.set_delta(4)  See also:      Pose      Pose.delta      Pose.residue      Residue set_dof(...) from builtins.PyCapsule set_dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID, setting : float) -> NoneType   Sets the value of the AtomTree DOF  <id>    See also:      Pose      DOF_ID set_epsilon(...) from builtins.PyCapsule set_epsilon(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the epsilon torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an nucleic acid    example(s):      pose.set_epsilon(5)  See also:      Pose      Pose.epsilon      Pose.residue      Residue set_gamma(...) from builtins.PyCapsule set_gamma(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the gamma torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an nucleic acid    example(s):      pose.set_gamma(3)  See also:      Pose      Pose.gamma      Pose.residue      Residue set_jump(...) from builtins.PyCapsule set_jump(*args, **kwargs) Overloaded function.   1. set_jump(self : rosetta.core.pose.Pose, jump_number : int, new_jump : rosetta.core.kinematics.Jump) -> NoneType   Sets the pose FoldTree Jump  <jump_number>  to  <new_jump>    example(s):      pose.set_jump(1,jump1)  See also:      Pose      Pose.fold_tree      Pose.jump      FoldTree      FoldTree.jump_edge      Jump   2. set_jump(self : rosetta.core.pose.Pose, id : rosetta.core.id.AtomID, new_jump : rosetta.core.kinematics.Jump) -> NoneType   Sets the pose FoldTree Jump  <id>  to  <new_jump>    example(s):      pose.set_jump(1,jump1)  See also:      Pose      Pose.fold_tree      Pose.jump      FoldTree      FoldTree.jump_edge      AtomID set_new_conformation(...) from builtins.PyCapsule set_new_conformation(self : rosetta.core.pose.Pose, new_conformation : rosetta.core.conformation.Conformation) -> NoneType   Now that the conformation_ member data is an owning pointer,  and we have derived classes of Conformation. set_new_energies_object(...) from builtins.PyCapsule set_new_energies_object(self : rosetta.core.pose.Pose, energies : core::scoring::Energies) -> NoneType   Now that the energies_ member data is an owning pointer,  and we have derived classes of Energies. set_omega(...) from builtins.PyCapsule set_omega(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the omega torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an amino acid or monosaccharide    example(s):      pose.set_omega(3, 180.0)  See also:      Pose      Pose.omega      Pose.residue      Residue set_phi(...) from builtins.PyCapsule set_phi(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the phi torsion angle of residue  <seqpos> to  <setting>       <setting>  must be in degrees, assumes residue is an amino acid or monosaccharide    example(s):      pose.set_phi(1, -23.7)  See also:      Pose      Pose.phi      Pose.residue      Residue set_psi(...) from builtins.PyCapsule set_psi(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the psi torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an amino acid or monosaccharide    example(s):      pose.set_psi(2, 45.3)  See also:      Pose      Pose.psi      Pose.residue      Residue set_ring_conformation(...) from builtins.PyCapsule set_ring_conformation(self : rosetta.core.pose.Pose, seqpos : int, ring_num : int, conformer : rosetta.core.chemical.rings.RingConformer) -> NoneType   Set the given residue and ring's ring conformation, if appropriate. set_secstruct(...) from builtins.PyCapsule set_secstruct(self : rosetta.core.pose.Pose, seqpos : int, setting : str) -> NoneType   Assign the secondary structure of residue  <seqpos> to  <setting>    example(s):      pose.set_secstruct(3,'H')  See also:      Pose      Pose.residue      Pose.secstruct      Residue set_theta(...) from builtins.PyCapsule set_theta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the theta torsion angle of beta-amino acid residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is a beta-amino acid.    example(s):      pose.set_theta(21, 58.9)  See also:      Pose      Pose.theta      Pose.residue      Residue      Vikram K. Mulligan (vmullig.edu) set_torsion(...) from builtins.PyCapsule set_torsion(self : rosetta.core.pose.Pose, id : core::id::TorsionID, setting : float) -> NoneType   Sets the Conformation torsion angle identified  by  <id>  to  <setting>    See also:      Pose      TorsionID set_xyz(...) from builtins.PyCapsule set_xyz(*args, **kwargs) Overloaded function.   1. set_xyz(self : rosetta.core.pose.Pose, id : rosetta.core.id.AtomID, point : rosetta.numeric.xyzVector_double_t) -> NoneType   Sets the location (xyz) of pose AtomID  <id>  to  the PointPosition  <point>    See also:      Pose      Pose.residue      Pose.xyz      Residue   2. set_xyz(self : rosetta.core.pose.Pose, id : rosetta.core.id.NamedAtomID, point : rosetta.numeric.xyzVector_double_t) -> NoneType   Sets the location (xyz) of pose NamedAtomID  <id>  to the PointPosition  <point>    See also:      Pose      Pose.residue      Pose.xyz      Residue set_zeta(...) from builtins.PyCapsule set_zeta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType   Sets the zeta torsion angle of residue  <seqpos>  to  <setting>       <setting>  must be in degrees, assumes residue is an nucleic acid    example(s):      pose.set_zeta(6)  See also:      Pose      Pose.zeta      Pose.residue      Residue split_by_chain(...) from builtins.PyCapsule split_by_chain(*args, **kwargs) Overloaded function.   1. split_by_chain(rosetta.core.pose.Pose) -> rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t   Returns a vector of poses with one element per chain of the original pose   2. split_by_chain(self : rosetta.core.pose.Pose, chain_id : int) -> rosetta.core.pose.Pose stub_from_id(...) from builtins.PyCapsule stub_from_id(self : rosetta.core.pose.Pose, id : core::id::NamedStubID) -> rosetta.core.kinematics.Stub theta(...) from builtins.PyCapsule theta(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the theta torsion angle of beta-amino acid residue  <seqpos>       assumes residue is a beta-amino acid.    example(s):      pose.theta(21)  See also:      Pose      Pose.set_theta      Pose.residue      Residue      Vikram K. Mulligan (vmullig.edu) torsion(...) from builtins.PyCapsule torsion(self : rosetta.core.pose.Pose, id : core::id::TorsionID) -> float   Returns the Conformation torsion angle identified by  <id>    See also:      Pose      TorsionID total_atoms(...) from builtins.PyCapsule total_atoms(*args, **kwargs) Overloaded function.   1. total_atoms(rosetta.core.pose.Pose) -> int   Returns the total number of atoms in the pose conformation  example:    pose.total_atoms()   2. total_atoms(self : rosetta.core.pose.Pose, nres : int) -> int   Returns the total number of atoms in the pose  up to a particular residue total_residue(...) from builtins.PyCapsule total_residue(rosetta.core.pose.Pose) -> int   Returns the number of residues in the pose conformation    example(s):      pose.total_residue()  See also:      Pose      Pose.n_residue      Pose.sequence transfer_constraint_set(...) from builtins.PyCapsule transfer_constraint_set(self : rosetta.core.pose.Pose, pose : rosetta.core.pose.Pose) -> NoneType update_actcoord(...) from builtins.PyCapsule update_actcoord(self : rosetta.core.pose.Pose, resid : int) -> NoneType   Updates the action coordinates for pose residue  <resid> update_actcoords(...) from builtins.PyCapsule update_actcoords(rosetta.core.pose.Pose) -> NoneType   Called by PairEPotential to update the action coordinates for all residues update_orbital_coords(...) from builtins.PyCapsule update_orbital_coords(self : rosetta.core.pose.Pose, resid : int) -> NoneType update_pose_chains_from_pdb_chains(...) from builtins.PyCapsule update_pose_chains_from_pdb_chains(rosetta.core.pose.Pose) -> NoneType   Updates the pose chain IDs to match the pdb chain IDs. update_residue_neighbors(...) from builtins.PyCapsule update_residue_neighbors(rosetta.core.pose.Pose) -> NoneType   Updates neighbor links in the pose Energies object xyz(...) from builtins.PyCapsule xyz(*args, **kwargs) Overloaded function.   1. xyz(self : rosetta.core.pose.Pose, id : rosetta.core.id.AtomID) -> rosetta.numeric.xyzVector_double_t   Returns the location (xyz) of pose AtomID  <id>    example(s):      atom = AtomID(1,1)      pose.xyz(atom)  See also:      Pose      Pose.residue      AtomID      Residue      Residue.xyz   2. xyz(self : rosetta.core.pose.Pose, id : rosetta.core.id.NamedAtomID) -> rosetta.numeric.xyzVector_double_t   Returns the location (xyz) of pose NamedAtomID  <id>    Tutorial soon...  See also:      Pose      Pose.residue      NamedAtomID      Residue      Residue.xyz zero_reference_pose_mapping_at_seqpos(...) from builtins.PyCapsule zero_reference_pose_mapping_at_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType   Find all mappings in the new pose to seqpos in all ReferencePose objects, and set them to point to residue 0 (deletion signal).      If there is no ReferencePose object, do nothing. zeta(...) from builtins.PyCapsule zeta(self : rosetta.core.pose.Pose, seqpos : int) -> float   Returns the zeta torsion angle of residue  <seqpos>      assumes the residue is an nucleic acid    example(s):      pose.zeta(6)  See also:      Pose      Pose.residue      Pose.set_zeta      Residue   class PoseCoordPickMode(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.pose.PoseCoordPickMode, rosetta.core.pose.PoseCoordPickMode) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.pose.PoseCoordPickMode) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.pose.PoseCoordPickMode, int) -> NoneType   2. __init__(rosetta.core.pose.PoseCoordPickMode, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.pose.PoseCoordPickMode) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.pose.PoseCoordPickMode, rosetta.core.pose.PoseCoordPickMode) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.pose.PoseCoordPickMode) -> str Data and other attributes defined here: PoseCoordPickMode_ALL = PoseCoordPickMode.PoseCoordPickMode_ALL PoseCoordPickMode_BB = PoseCoordPickMode.PoseCoordPickMode_BB PoseCoordPickMode_BNP = PoseCoordPickMode.PoseCoordPickMode_BNP PoseCoordPickMode_CA = PoseCoordPickMode.PoseCoordPickMode_CA PoseCoordPickMode_CB = PoseCoordPickMode.PoseCoordPickMode_CB PoseCoordPickMode_CB_else_CA = PoseCoordPickMode.PoseCoordPickMode_CB_else_CA PoseCoordPickMode_CBorCA = PoseCoordPickMode.PoseCoordPickMode_CBorCA PoseCoordPickMode_HVY = PoseCoordPickMode.PoseCoordPickMode_HVY PoseCoordPickMode_HVY_IF_NP = PoseCoordPickMode.PoseCoordPickMode_HVY_IF_NP PoseCoordPickMode_NBR = PoseCoordPickMode.PoseCoordPickMode_NBR PoseCoordPickMode_NUL = PoseCoordPickMode.PoseCoordPickMode_NUL PoseCoordPickMode_N_CA_C = PoseCoordPickMode.PoseCoordPickMode_N_CA_C PoseCoordPickMode_N_CA_C_CB = PoseCoordPickMode.PoseCoordPickMode_N_CA_C_CB PoseCoordPickMode_N_C_O = PoseCoordPickMode.PoseCoordPickMode_N_C_O   class ResidueIndexDescription(builtins.object)     a class which can represent one of many ways in which to describe a particular residue in a pose, and can, when given a pose, find its index. The object should be constructed with all its needed parameters, but, one instance may be copied from another.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, pose_index : int) -> NoneType   3. __init__(handle, str, int) -> NoneType   doc   4. __init__(self : handle, chain : str, resindex : int, insertion_code : str) -> NoneType   5. __init__(handle, rosetta.core.pose.ResidueIndexDescription) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.pose.ResidueIndexDescription,  : rosetta.core.pose.ResidueIndexDescription) -> rosetta.core.pose.ResidueIndexDescription chain(...) from builtins.PyCapsule chain(rosetta.core.pose.ResidueIndexDescription) -> str insertion_code(...) from builtins.PyCapsule insertion_code(rosetta.core.pose.ResidueIndexDescription) -> str pose_index(...) from builtins.PyCapsule pose_index(rosetta.core.pose.ResidueIndexDescription) -> int pose_numbered(...) from builtins.PyCapsule pose_numbered(rosetta.core.pose.ResidueIndexDescription) -> bool resindex(...) from builtins.PyCapsule resindex(rosetta.core.pose.ResidueIndexDescription) -> int resolve_index(...) from builtins.PyCapsule resolve_index(self : rosetta.core.pose.ResidueIndexDescription, p : rosetta.core.pose.Pose) -> int   Turn the internal data into a pose index (in the range from 1 to total residue)  or throw an exception if the index cannot be resolved. unassigned(...) from builtins.PyCapsule unassigned(rosetta.core.pose.ResidueIndexDescription) -> bool   class ResidueIndexDescriptionFromFile(ResidueIndexDescription)     %ResidueIndexDescriptionFromFile differs from its parent only in its error reporting when a residue index resolution fails: it prints the file name and the line number that the residue index data came from.     Method resolution order: ResidueIndexDescriptionFromFile ResidueIndexDescription builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, fname : str, linenum : int, pose_index : int) -> NoneType   3. __init__(handle, str, int, str, int) -> NoneType   doc   4. __init__(self : handle, fname : str, linenum : int, chain : str, resindex : int, insertion_code : str) -> NoneType   5. __init__(handle, rosetta.core.pose.ResidueIndexDescriptionFromFile) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.pose.ResidueIndexDescriptionFromFile,  : rosetta.core.pose.ResidueIndexDescriptionFromFile) -> rosetta.core.pose.ResidueIndexDescriptionFromFile fname(...) from builtins.PyCapsule fname(rosetta.core.pose.ResidueIndexDescriptionFromFile) -> str linenum(...) from builtins.PyCapsule linenum(rosetta.core.pose.ResidueIndexDescriptionFromFile) -> int resolve_index(...) from builtins.PyCapsule resolve_index(self : rosetta.core.pose.ResidueIndexDescriptionFromFile, p : rosetta.core.pose.Pose) -> int   Turn the internal data into a pose index (in the range from 1 to total residue)  or throw an exception if the index cannot be resolved; the exception thrown by this  class if the resolution fails includes a statement of the file name and the line  number in that file. Methods inherited from ResidueIndexDescription: chain(...) from builtins.PyCapsule chain(rosetta.core.pose.ResidueIndexDescription) -> str insertion_code(...) from builtins.PyCapsule insertion_code(rosetta.core.pose.ResidueIndexDescription) -> str pose_index(...) from builtins.PyCapsule pose_index(rosetta.core.pose.ResidueIndexDescription) -> int pose_numbered(...) from builtins.PyCapsule pose_numbered(rosetta.core.pose.ResidueIndexDescription) -> bool resindex(...) from builtins.PyCapsule resindex(rosetta.core.pose.ResidueIndexDescription) -> int unassigned(...) from builtins.PyCapsule unassigned(rosetta.core.pose.ResidueIndexDescription) -> bool   class UnrecognizedAtomRecord(builtins.object)     info about an atom in a unrecognized res (not in pose, but we want to remember it)     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.pose.UnrecognizedAtomRecord) -> NoneType   2. __init__(self : rosetta.core.pose.UnrecognizedAtomRecord, res_num : int, res_name : str, atom_name : str, coords : rosetta.numeric.xyzVector_double_t, temp : float) -> NoneType   3. __init__(self : rosetta.core.pose.UnrecognizedAtomRecord,  : rosetta.core.pose.UnrecognizedAtomRecord) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.pose.UnrecognizedAtomRecord) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.pose.UnrecognizedAtomRecord,  : rosetta.core.pose.UnrecognizedAtomRecord) -> rosetta.core.pose.UnrecognizedAtomRecord atom_name(...) from builtins.PyCapsule atom_name(rosetta.core.pose.UnrecognizedAtomRecord) -> str coords(...) from builtins.PyCapsule coords(rosetta.core.pose.UnrecognizedAtomRecord) -> rosetta.numeric.xyzVector_double_t res_name(...) from builtins.PyCapsule res_name(rosetta.core.pose.UnrecognizedAtomRecord) -> str res_num(...) from builtins.PyCapsule res_num(rosetta.core.pose.UnrecognizedAtomRecord) -> int temp(...) from builtins.PyCapsule temp(rosetta.core.pose.UnrecognizedAtomRecord) -> float   class xyzStripeHashPose(rosetta.numeric.geometry.hashing.xyzStripeHash)       Method resolution order: xyzStripeHashPose rosetta.numeric.geometry.hashing.xyzStripeHash builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.pose.xyzStripeHashPose) -> NoneType   doc   2. __init__(self : rosetta.core.pose.xyzStripeHashPose, radius : float) -> NoneType   3. __init__(rosetta.core.pose.xyzStripeHashPose, rosetta.core.pose.Pose) -> NoneType   doc   4. __init__(rosetta.core.pose.xyzStripeHashPose, rosetta.core.pose.Pose, rosetta.core.pose.PoseCoordPickMode) -> NoneType   doc   5. __init__(self : rosetta.core.pose.xyzStripeHashPose, p : rosetta.core.pose.Pose, m : rosetta.core.pose.PoseCoordPickMode, radius : float) -> NoneType   6. __init__(rosetta.core.pose.xyzStripeHashPose, rosetta.core.pose.Pose, rosetta.utility.vector1_int) -> NoneType   doc   7. __init__(rosetta.core.pose.xyzStripeHashPose, rosetta.core.pose.Pose, rosetta.utility.vector1_int, rosetta.core.pose.PoseCoordPickMode) -> NoneType   doc   8. __init__(self : rosetta.core.pose.xyzStripeHashPose, p : rosetta.core.pose.Pose, resmap : rosetta.utility.vector1_int, m : rosetta.core.pose.PoseCoordPickMode, radius : float) -> NoneType   9. __init__(rosetta.core.pose.xyzStripeHashPose, rosetta.core.pose.Pose, rosetta.core.id.AtomID_Map_double_t) -> NoneType   doc   10. __init__(self : rosetta.core.pose.xyzStripeHashPose, p : rosetta.core.pose.Pose, amap : rosetta.core.id.AtomID_Map_double_t, radius : float) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_pose(...) from builtins.PyCapsule add_pose(*args, **kwargs) Overloaded function.   1. add_pose(self : rosetta.core.pose.xyzStripeHashPose, p : rosetta.core.pose.Pose, amap : rosetta.core.id.AtomID_Map_double_t) -> NoneType   2. add_pose(self : rosetta.core.pose.xyzStripeHashPose, p : rosetta.core.pose.Pose) -> NoneType   3. add_pose(self : rosetta.core.pose.xyzStripeHashPose, p : rosetta.core.pose.Pose, m : rosetta.core.pose.PoseCoordPickMode) -> NoneType assign(...) from builtins.PyCapsule assign(self : rosetta.core.pose.xyzStripeHashPose,  : rosetta.core.pose.xyzStripeHashPose) -> rosetta.core.pose.xyzStripeHashPose extract_pose_balls(...) from builtins.PyCapsule extract_pose_balls(*args, **kwargs) Overloaded function.   1. extract_pose_balls(p : rosetta.core.pose.Pose, balls : rosetta.utility.vector1_numeric_geometry_hashing_Ball) -> NoneType   2. extract_pose_balls(p : rosetta.core.pose.Pose, balls : rosetta.utility.vector1_numeric_geometry_hashing_Ball, m : rosetta.core.pose.PoseCoordPickMode) -> NoneType   3. extract_pose_balls(p : rosetta.core.pose.Pose, balls : rosetta.utility.vector1_numeric_geometry_hashing_Ball, amap : rosetta.core.id.AtomID_Map_double_t) -> NoneType init_posehash(...) from builtins.PyCapsule init_posehash(rosetta.core.pose.xyzStripeHashPose) -> NoneType Methods inherited from rosetta.numeric.geometry.hashing.xyzStripeHash: ball(...) from builtins.PyCapsule ball(self : rosetta.numeric.geometry.hashing.xyzStripeHash, ib : int) -> rosetta.numeric.geometry.hashing.Ball begin(...) from builtins.PyCapsule begin(rosetta.numeric.geometry.hashing.xyzStripeHash) -> numeric::geometry::hashing::xyzStripeHash::const_iterator clash(...) from builtins.PyCapsule clash(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v_in : rosetta.numeric.xyzVector_float_t) -> bool clash_amount(...) from builtins.PyCapsule clash_amount(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v_in : rosetta.numeric.xyzVector_float_t) -> float clash_check_ball(...) from builtins.PyCapsule clash_check_ball(self : rosetta.numeric.geometry.hashing.xyzStripeHash, b : rosetta.numeric.geometry.hashing.Ball) -> int clash_check_residue_pairs(...) from builtins.PyCapsule clash_check_residue_pairs(self : rosetta.numeric.geometry.hashing.xyzStripeHash, test_balls : rosetta.utility.vector1_numeric_geometry_hashing_Ball, residue_pairs : rosetta.std.map_unsigned_long_unsigned_long) -> bool clash_not_resid(...) from builtins.PyCapsule clash_not_resid(*args, **kwargs) Overloaded function.   1. clash_not_resid(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v_in : rosetta.numeric.xyzVector_float_t, resid : int) -> bool   2. clash_not_resid(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v_in : rosetta.numeric.xyzVector_float_t, resid : int, resid2 : int) -> bool clash_raw(...) from builtins.PyCapsule clash_raw(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v : rosetta.numeric.xyzVector_float_t) -> bool debug_pdb(...) from builtins.PyCapsule debug_pdb(*args, **kwargs) Overloaded function.   1. debug_pdb(rosetta.numeric.geometry.hashing.xyzStripeHash) -> str   2. debug_pdb(self : rosetta.numeric.geometry.hashing.xyzStripeHash, x : rosetta.numeric.xyzTransform_double_t) -> str end(...) from builtins.PyCapsule end(rosetta.numeric.geometry.hashing.xyzStripeHash) -> numeric::geometry::hashing::xyzStripeHash::const_iterator fill_pairs(...) from builtins.PyCapsule fill_pairs(*args, **kwargs) Overloaded function.   1. fill_pairs(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v : rosetta.numeric.xyzVector_float_t, ir : int, pairs : rosetta.utility.vector1_std_pair_int_int_t) -> NoneType   2. fill_pairs(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v : rosetta.numeric.xyzVector_float_t, ir : int, pairs : rosetta.utility.vector1_std_pair_int_int_t, maxd2 : float) -> NoneType grid_atoms(...) from builtins.PyCapsule grid_atoms(rosetta.numeric.geometry.hashing.xyzStripeHash) -> rosetta.numeric.geometry.hashing.Ball grid_size(...) from builtins.PyCapsule grid_size(rosetta.numeric.geometry.hashing.xyzStripeHash) -> float grid_size2(...) from builtins.PyCapsule grid_size2(rosetta.numeric.geometry.hashing.xyzStripeHash) -> float grid_stripe(...) from builtins.PyCapsule grid_stripe(rosetta.numeric.geometry.hashing.xyzStripeHash) -> numeric::geometry::hashing::xyzStripeHash::ushort2 init(...) from builtins.PyCapsule init(self : rosetta.numeric.geometry.hashing.xyzStripeHash, balls : rosetta.utility.vector1_numeric_geometry_hashing_Ball) -> NoneType natom(...) from builtins.PyCapsule natom(rosetta.numeric.geometry.hashing.xyzStripeHash) -> int nbcount(...) from builtins.PyCapsule nbcount(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v_in : rosetta.numeric.xyzVector_float_t) -> int nbcount_raw(...) from builtins.PyCapsule nbcount_raw(self : rosetta.numeric.geometry.hashing.xyzStripeHash, v : rosetta.numeric.xyzVector_float_t) -> int resi(...) from builtins.PyCapsule resi(self : rosetta.numeric.geometry.hashing.xyzStripeHash, ib : int) -> int sanity_check(...) from builtins.PyCapsule sanity_check(rosetta.numeric.geometry.hashing.xyzStripeHash) -> bool size(...) from builtins.PyCapsule size(rosetta.numeric.geometry.hashing.xyzStripeHash) -> int translation(...) from builtins.PyCapsule translation(rosetta.numeric.geometry.hashing.xyzStripeHash) -> rosetta.numeric.xyzVector_float_t translation_real(...) from builtins.PyCapsule translation_real(rosetta.numeric.geometry.hashing.xyzStripeHash) -> rosetta.numeric.xyzVector_double_t xdim(...) from builtins.PyCapsule xdim(rosetta.numeric.geometry.hashing.xyzStripeHash) -> int xyz(...) from builtins.PyCapsule xyz(self : rosetta.numeric.geometry.hashing.xyzStripeHash, ib : int) -> rosetta.numeric.xyzVector_float_t ydim(...) from builtins.PyCapsule ydim(rosetta.numeric.geometry.hashing.xyzStripeHash) -> int zdim(...) from builtins.PyCapsule zdim(rosetta.numeric.geometry.hashing.xyzStripeHash) -> int

Functions
		addVirtualResAsRoot(...) method of builtins.PyCapsule instance addVirtualResAsRoot(*args, **kwargs) Overloaded function.   1. addVirtualResAsRoot(pose : rosetta.core.pose.Pose) -> NoneType   Adds a VRT res to the end of the pose at the center of mass.  Reroots the structure on this res.   2. addVirtualResAsRoot(xyz : rosetta.numeric.xyzVector_double_t, pose : rosetta.core.pose.Pose) -> NoneType   Adds a virtual residue to the end of the pose at the specified location.  Roots the structure on this residue. add_comment(...) method of builtins.PyCapsule instance add_comment(pose : rosetta.core.pose.Pose, key : str, val : str) -> NoneType   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. add_lower_terminus_type_to_pose_residue(...) method of builtins.PyCapsule instance add_lower_terminus_type_to_pose_residue(pose : rosetta.core.pose.Pose, seqpos : int) -> NoneType add_score_line_string(...) method of builtins.PyCapsule instance add_score_line_string(pose : rosetta.core.pose.Pose, key : str, val : str) -> NoneType   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. add_upper_terminus_type_to_pose_residue(...) method of builtins.PyCapsule instance add_upper_terminus_type_to_pose_residue(pose : rosetta.core.pose.Pose, seqpos : int) -> NoneType add_variant_type_to_pose_residue(...) method of builtins.PyCapsule instance add_variant_type_to_pose_residue(pose : rosetta.core.pose.Pose, variant_type : rosetta.core.chemical.VariantType, seqpos : int) -> NoneType   Construct a variant of an existing pose residue. add_variant_type_to_residue(...) method of builtins.PyCapsule instance add_variant_type_to_residue(old_rsd : rosetta.core.conformation.Residue, variant_type : rosetta.core.chemical.VariantType, pose : rosetta.core.pose.Pose) -> rosetta.core.conformation.Residue   Construct a variant of an existing residue. annotated_to_oneletter_sequence(...) method of builtins.PyCapsule instance annotated_to_oneletter_sequence(annotated_seq : str) -> str   Returns the oneletter_sequence that corresponds to the given  annotated sequence. append_pose_to_pose(...) method of builtins.PyCapsule instance append_pose_to_pose(*args, **kwargs) Overloaded function.   1. append_pose_to_pose(pose1 : rosetta.core.pose.Pose, pose2 : rosetta.core.pose.Pose) -> NoneType   Append residues of pose2 to pose1.   2. append_pose_to_pose(pose1 : rosetta.core.pose.Pose, pose2 : rosetta.core.pose.Pose, new_chain : bool) -> NoneType   Append residues of pose2 to pose1. append_pose_with_glycan_residues(...) method of builtins.PyCapsule instance append_pose_with_glycan_residues(pose : rosetta.core.pose.Pose, residue_types : rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t) -> NoneType   Append an empty or current Pose with saccharide residues, building branches as necessary. append_subpose_to_pose(...) method of builtins.PyCapsule instance append_subpose_to_pose(*args, **kwargs) Overloaded function.   1. append_subpose_to_pose(pose1 : rosetta.core.pose.Pose, pose2 : rosetta.core.pose.Pose, start_res : int, end_res : int) -> NoneType   Append specified residues of pose2 to pose1.   2. append_subpose_to_pose(pose1 : rosetta.core.pose.Pose, pose2 : rosetta.core.pose.Pose, start_res : int, end_res : int, new_chain : bool) -> NoneType   Append specified residues of pose2 to pose1. atom_id_to_named_atom_id(...) method of builtins.PyCapsule instance atom_id_to_named_atom_id(atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose) -> rosetta.core.id.NamedAtomID canonical_atom_count(...) method of builtins.PyCapsule instance canonical_atom_count(pose : rosetta.core.pose.Pose) -> int   count the number of canonical amino acid atoms in the pose canonical_residue_count(...) method of builtins.PyCapsule instance canonical_residue_count(pose : rosetta.core.pose.Pose) -> int   count the number of canonical residues in the pose center_of_mass(...) method of builtins.PyCapsule instance center_of_mass(*args, **kwargs) Overloaded function.   1. center_of_mass(pose : rosetta.core.pose.Pose, residues : rosetta.utility.vector1_bool) -> rosetta.numeric.xyzVector_double_t   2. center_of_mass(pose : rosetta.core.pose.Pose, start : int, stop : int) -> rosetta.numeric.xyzVector_double_t chain_end_res(...) method of builtins.PyCapsule instance chain_end_res(*args, **kwargs) Overloaded function.   1. chain_end_res(pose : rosetta.core.pose.Pose, chain : int) -> int   compute last residue number of a chain   2. chain_end_res(pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_unsigned_long   compute last residue numbers of all chains clearPoseExtraScore(...) method of builtins.PyCapsule instance clearPoseExtraScore(pose : rosetta.core.pose.Pose, name : str) -> NoneType clearPoseExtraScores(...) method of builtins.PyCapsule instance clearPoseExtraScores(pose : rosetta.core.pose.Pose) -> NoneType compare_atom_coordinates(...) method of builtins.PyCapsule instance compare_atom_coordinates(*args, **kwargs) Overloaded function.   1. compare_atom_coordinates(lhs : rosetta.core.pose.Pose, rhs : rosetta.core.pose.Pose) -> bool   this function compares pose atom coordinates for equality; it is not the == operator because it does not compare all pose data.      Steven Lewis smlewi.com      one pose to compare      one pose to compare      number of decimal places to compare for the coordinates (remember == doesn't work for float); defaults to 3 which is PDB accuracy   2. compare_atom_coordinates(lhs : rosetta.core.pose.Pose, rhs : rosetta.core.pose.Pose, n_dec_places : int) -> bool   this function compares pose atom coordinates for equality; it is not the == operator because it does not compare all pose data.      Steven Lewis smlewi.com      one pose to compare      one pose to compare      number of decimal places to compare for the coordinates (remember == doesn't work for float); defaults to 3 which is PDB accuracy compare_binary_protein_silent_struct(...) method of builtins.PyCapsule instance compare_binary_protein_silent_struct(lhs : rosetta.core.pose.Pose, rhs : rosetta.core.pose.Pose) -> bool   this function compares poses for equality up to the information stored in the binary protein silent struct format. compute_unique_chains(...) method of builtins.PyCapsule instance compute_unique_chains(pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_bool   Compute uniq chains in a complex      Returns a vector of pose length with true/false of uniq chain     true is unique, false is not conf2pdb_chain(...) method of builtins.PyCapsule instance conf2pdb_chain(pose : rosetta.core.pose.Pose) -> rosetta.std.map_int_char   get Conformation chain -> PDBInfo chain mapping      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 convert_from_std_map(...) method of builtins.PyCapsule instance convert_from_std_map(atom_map : rosetta.std.map_core_id_AtomID_core_id_AtomID, pose : rosetta.core.pose.Pose) -> rosetta.core.id.AtomID_Map_core_id_AtomID_t correctly_add_cutpoint_variants(...) method of builtins.PyCapsule instance correctly_add_cutpoint_variants(*args, **kwargs) Overloaded function.   1. correctly_add_cutpoint_variants(pose : rosetta.core.pose.Pose) -> NoneType   Add cutpoint variants to all residues annotated as cutpoints in the pose.   2. correctly_add_cutpoint_variants(pose : rosetta.core.pose.Pose, cutpoint_res : int) -> NoneType   3. correctly_add_cutpoint_variants(pose : rosetta.core.pose.Pose, cutpoint_res : int, check_fold_tree : bool) -> NoneType create_subpose(...) method of builtins.PyCapsule instance create_subpose(src : rosetta.core.pose.Pose, positions : rosetta.utility.vector1_unsigned_long, f : rosetta.core.kinematics.FoldTree, pose : rosetta.core.pose.Pose) -> NoneType   Create a subpose of the src pose.  PDBInfo is set as NULL. delete_comment(...) method of builtins.PyCapsule instance delete_comment(pose : rosetta.core.pose.Pose, key : str) -> NoneType   Deletes the entry in the STRING_MAP associated with the  given key. dump_comment_pdb(...) method of builtins.PyCapsule instance dump_comment_pdb(file_name : str, pose : rosetta.core.pose.Pose) -> NoneType   dumps pose+ comments to pdb file energy_from_pose(...) method of builtins.PyCapsule instance energy_from_pose(*args, **kwargs) Overloaded function.   1. energy_from_pose(pose : rosetta.core.pose.Pose, sc_type : rosetta.core.scoring.ScoreType) -> float   2. energy_from_pose(pose : rosetta.core.pose.Pose, sc_type : str) -> float extract_tag_from_pose(...) method of builtins.PyCapsule instance extract_tag_from_pose(pose : rosetta.core.pose.Pose) -> str   Returns a string giving the pose's tag if there is such a thing or "UnknownTag" otherwise. getPoseExtraScore(...) method of builtins.PyCapsule instance getPoseExtraScore(*args, **kwargs) Overloaded function.   1. getPoseExtraScore(pose : rosetta.core.pose.Pose, name : str, value : float) -> bool   getters/setters for things in the Pose DataCache   2. getPoseExtraScore(pose : rosetta.core.pose.Pose, name : str) -> float   3. getPoseExtraScore(pose : rosetta.core.pose.Pose, name : str, value : str) -> bool get_all_comments(...) method of builtins.PyCapsule instance get_all_comments(pose : rosetta.core.pose.Pose) -> rosetta.std.map_std_string_std_string   Gets a map< string, string > representing comments about the Pose in  the form of key-value pairs. get_all_score_line_strings(...) method of builtins.PyCapsule instance get_all_score_line_strings(pose : rosetta.core.pose.Pose) -> rosetta.std.map_std_string_std_string   Gets a map< string, string > representing score_line_strings about the Pose in  the form of key-value pairs. get_bb_torsion(...) method of builtins.PyCapsule instance get_bb_torsion(torsion_id : int, pose : rosetta.core.pose.Pose, sequence_position : int) -> float   Get a particular backbone torsion, phi, psi, omega (see core::types)  Works with carbohydrates.  Think about moving this to pose itself. get_center_of_mass(...) method of builtins.PyCapsule instance get_center_of_mass(pose : rosetta.core.pose.Pose) -> rosetta.numeric.xyzVector_double_t   Get center of mass of a pose. get_chain_from_chain_id(...) method of builtins.PyCapsule instance get_chain_from_chain_id(chain_id : int, pose : rosetta.core.pose.Pose) -> str get_chain_from_jump_id(...) method of builtins.PyCapsule instance get_chain_from_jump_id(jump_id : int, pose : rosetta.core.pose.Pose) -> str get_chain_id_from_chain(...) method of builtins.PyCapsule instance get_chain_id_from_chain(*args, **kwargs) Overloaded function.   1. get_chain_id_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> int   2. get_chain_id_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> int get_chain_id_from_jump_id(...) method of builtins.PyCapsule instance get_chain_id_from_jump_id(jump_id : int, pose : rosetta.core.pose.Pose) -> int get_chain_ids_from_chain(...) method of builtins.PyCapsule instance get_chain_ids_from_chain(*args, **kwargs) Overloaded function.   1. get_chain_ids_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_unsigned_long   2. get_chain_ids_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_unsigned_long get_chain_ids_from_chains(...) method of builtins.PyCapsule instance get_chain_ids_from_chains(chains : rosetta.utility.vector1_std_string, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_unsigned_long get_chain_residues(...) method of builtins.PyCapsule instance get_chain_residues(pose : rosetta.core.pose.Pose, chain_id : int) -> rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t get_chains(...) method of builtins.PyCapsule instance get_chains(pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_int   Get all the chains from conformation get_comment(...) method of builtins.PyCapsule instance get_comment(pose : rosetta.core.pose.Pose, key : str, val : str) -> bool   Attempts to access the entry in the STRING_MAP associated with the  given key. If an entry for the key exists, the value associated with the key  is put into val, and this function returns true. Otherwise, this function  returns false and val left unmodified. get_constraints_from_link_records(...) method of builtins.PyCapsule instance get_constraints_from_link_records(pose : rosetta.core.pose.Pose, sfr : rosetta.core.io.StructFileRep) -> NoneType get_hash_excluding_chain(...) method of builtins.PyCapsule instance get_hash_excluding_chain(chain : str, pose : rosetta.core.pose.Pose) -> int get_hash_from_chain(...) method of builtins.PyCapsule instance get_hash_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> int get_jump_id_from_chain(...) method of builtins.PyCapsule instance get_jump_id_from_chain(*args, **kwargs) Overloaded function.   1. get_jump_id_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> int   2. get_jump_id_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> int get_jump_id_from_chain_id(...) method of builtins.PyCapsule instance get_jump_id_from_chain_id(chain_id : int, pose : rosetta.core.pose.Pose) -> int get_jump_ids_from_chain(...) method of builtins.PyCapsule instance get_jump_ids_from_chain(*args, **kwargs) Overloaded function.   1. get_jump_ids_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_unsigned_long   2. get_jump_ids_from_chain(chain : str, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_unsigned_long get_jump_ids_from_chain_ids(...) method of builtins.PyCapsule instance get_jump_ids_from_chain_ids(chain_ids : rosetta.std.set_unsigned_long_std_less_unsigned_long_std_allocator_unsigned_long_t, pose : rosetta.core.pose.Pose) -> rosetta.std.set_unsigned_long_std_less_unsigned_long_std_allocator_unsigned_long_t get_resnum(...) method of builtins.PyCapsule instance get_resnum(*args, **kwargs) Overloaded function.   1. get_resnum(tag_ptr : rosetta.utility.tag.Tag, pose : rosetta.core.pose.Pose) -> int   2. get_resnum(tag_ptr : rosetta.utility.tag.Tag, pose : rosetta.core.pose.Pose, prefix : str) -> int get_resnum_list(...) method of builtins.PyCapsule instance get_resnum_list(*args, **kwargs) Overloaded function.   1. get_resnum_list(tag_ptr : rosetta.utility.tag.Tag, tag : str, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_unsigned_long   Extracts a list of residue numbers from a tag.      The tag should contain a comma-separated list of numbers, in either    pdb or rosetta format (    parse_resnum for details)   2. get_resnum_list(str : str, pose : rosetta.core.pose.Pose) -> rosetta.std.set_unsigned_long_std_less_unsigned_long_std_allocator_unsigned_long_t   returns a resnum list directly from a string get_resnum_list_ordered(...) method of builtins.PyCapsule instance get_resnum_list_ordered(str : str, pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_unsigned_long   returns a resnum list directly from a string, preserving order get_resnumber_from_reference_pose(...) method of builtins.PyCapsule instance get_resnumber_from_reference_pose(refpose_name : str, refpose_number : int, refpose_offset : int, pose : rosetta.core.pose.Pose) -> int   Given the name of a ReferencePose object in the pose, a residue number in that reference pose, and a residue offset,  this function returns the Rosetta number of the corresponding residue in the pose.  Should throw an error if the ReferencePose  doesn't exist in the pose, or 0 if no corresponding residue exists in the pose.      Vikram K. Mulligan, Baker laboratory (vmullig.edu) get_rsd_type_from_aa(...) method of builtins.PyCapsule instance get_rsd_type_from_aa(residue_set : rosetta.core.chemical.ResidueTypeSet, my_aa : rosetta.core.chemical.AA, is_lower_terminus : bool, is_upper_terminus : bool) -> rosetta.core.chemical.ResidueType   use efficient residue type finder to find simplest residue type with this AA & requested termini. get_score_line_string(...) method of builtins.PyCapsule instance get_score_line_string(pose : rosetta.core.pose.Pose, key : str, val : str) -> bool get_sequence_len(...) method of builtins.PyCapsule instance get_sequence_len(sequence_in : str) -> int   Get the real length of a annotated sequence get_sha1_hash_excluding_chain(...) method of builtins.PyCapsule instance get_sha1_hash_excluding_chain(chain : str, pose : rosetta.core.pose.Pose) -> str hasPoseExtraScore(...) method of builtins.PyCapsule instance hasPoseExtraScore(pose : rosetta.core.pose.Pose, name : str) -> bool has_chain(...) method of builtins.PyCapsule instance has_chain(*args, **kwargs) Overloaded function.   1. has_chain(chain : str, pose : rosetta.core.pose.Pose) -> bool   2. has_chain(chain : str, pose : rosetta.core.pose.Pose) -> bool   3. has_chain(chain_id : int, pose : rosetta.core.pose.Pose) -> bool initialize_atomid_map_AtomID(...) method of builtins.PyCapsule instance initialize_atomid_map_AtomID(*args, **kwargs) Overloaded function.   1. initialize_atomid_map_AtomID(atom_map : rosetta.core.id.AtomID_Map_core_id_AtomID_t, pose : rosetta.core.pose.Pose) -> NoneType   2. initialize_atomid_map_AtomID(atom_map : rosetta.core.id.AtomID_Map_core_id_AtomID_t, pose : rosetta.core.pose.Pose, value : rosetta.core.id.AtomID) -> NoneType   3. initialize_atomid_map_AtomID(atom_map : rosetta.core.id.AtomID_Map_core_id_AtomID_t, conformation : rosetta.core.conformation.Conformation) -> NoneType   4. initialize_atomid_map_AtomID(atom_map : rosetta.core.id.AtomID_Map_core_id_AtomID_t, conformation : rosetta.core.conformation.Conformation, value : rosetta.core.id.AtomID) -> NoneType initialize_atomid_map_core_id_AtomID_t(...) method of builtins.PyCapsule instance initialize_atomid_map_core_id_AtomID_t(*args, **kwargs) Overloaded function.   1. initialize_atomid_map_core_id_AtomID_t(atom_map : rosetta.core.id.AtomID_Map_core_id_AtomID_t, pose : rosetta.core.pose.Pose) -> NoneType   2. initialize_atomid_map_core_id_AtomID_t(atom_map : rosetta.core.id.AtomID_Map_core_id_AtomID_t, pose : rosetta.core.pose.Pose, value : rosetta.core.id.AtomID) -> NoneType   3. initialize_atomid_map_core_id_AtomID_t(atom_map : rosetta.core.id.AtomID_Map_core_id_AtomID_t, conformation : rosetta.core.conformation.Conformation) -> NoneType   4. initialize_atomid_map_core_id_AtomID_t(atom_map : rosetta.core.id.AtomID_Map_core_id_AtomID_t, conformation : rosetta.core.conformation.Conformation, value : rosetta.core.id.AtomID) -> NoneType initialize_disulfide_bonds(...) method of builtins.PyCapsule instance initialize_disulfide_bonds(*args, **kwargs) Overloaded function.   1. initialize_disulfide_bonds(pose : rosetta.core.pose.Pose) -> NoneType   detect and fix disulfide bonds   2. initialize_disulfide_bonds(pose : rosetta.core.pose.Pose, fd : rosetta.core.io.StructFileRep) -> NoneType   detect and fix disulfide bonds is_atom_axial_or_equatorial_to_ring(...) method of builtins.PyCapsule instance is_atom_axial_or_equatorial_to_ring(pose : rosetta.core.pose.Pose, seqpos : int, query_atom : int, ring_atoms : rosetta.utility.vector1_unsigned_long) -> rosetta.core.chemical.rings.AxEqDesignation   Is the query atom in this pose residue axial or equatorial to the given ring or neither? is_ideal_pose(...) method of builtins.PyCapsule instance is_ideal_pose(pose : rosetta.core.pose.Pose) -> bool   Returns true if the  <pose>  geometry is ideal      The Pose to check.      true if all pose positions have ideal bond lengths and angles   up to some very small epsilon is_ideal_position(...) method of builtins.PyCapsule instance is_ideal_position(seqpos : int, pose : rosetta.core.pose.Pose) -> bool   Returns true if the  <pose> geometry is ideal in position  <seqpos>      The Pose to check.      true if position seqpos has ideal bond lengths and angles   up to some very small epsilon is_lower_terminus(...) method of builtins.PyCapsule instance is_lower_terminus(pose : rosetta.core.pose.Pose, resid : int) -> bool   checks to see if this is a lower chain ending more intelligently than just checking residue variants is_position_conserved_residue(...) method of builtins.PyCapsule instance is_position_conserved_residue(pose : rosetta.core.pose.Pose, residue : int) -> bool   Returns true if <residue> is positionally conserved, false otherwise is_referencepose_number(...) method of builtins.PyCapsule instance is_referencepose_number(str : str, refpose_string : str, refpose_resnumber : int, refpose_offset : int) -> bool   Is a string of the format "refpose(<refposename>,<refposenumber>)" or "refpose(<refposename>,<refposenumber>)+/-<number>"?       If this successfully determines that this is a string of this format, it populates the refpose_string, refpose_resnumber,  and refpose_offset variables with the name of the ReferencePose, the number of the residue in the reference pose, and the +/- offset  number parsed from this string.      Vikram K. Mulligan, Baker laboratory (vmullig.edu) is_upper_terminus(...) method of builtins.PyCapsule instance is_upper_terminus(pose : rosetta.core.pose.Pose, resid : int) -> bool   checks to see if this is a lower chain ending more intelligently than just checking residue variants jumps_from_pose(...) method of builtins.PyCapsule instance jumps_from_pose(pose : rosetta.core.pose.Pose, jumps : rosetta.std.set_int_std_less_int_std_allocator_int_t) -> NoneType   Retrieves jump information from <pose>, storing the result in <jumps>.  Jumps are keyed by their jump id. make_atom_map(...) method of builtins.PyCapsule instance make_atom_map(p : rosetta.core.pose.Pose, m : rosetta.core.pose.PoseCoordPickMode) -> rosetta.core.id.AtomID_Map_double_t make_pose_from_saccharide_sequence(...) method of builtins.PyCapsule instance make_pose_from_saccharide_sequence(*args, **kwargs) Overloaded function.   1. make_pose_from_saccharide_sequence(pose : rosetta.core.pose.Pose, sequence : str, residue_set : rosetta.core.chemical.ResidueTypeSet) -> NoneType   Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with ResidueTypeSet  <residue_set> and store it in <pose>.   2. make_pose_from_saccharide_sequence(pose : rosetta.core.pose.Pose, sequence : str, residue_set : rosetta.core.chemical.ResidueTypeSet, auto_termini : bool) -> NoneType   Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with ResidueTypeSet  <residue_set> and store it in <pose>.   3. make_pose_from_saccharide_sequence(pose : rosetta.core.pose.Pose, sequence : str, residue_set : rosetta.core.chemical.ResidueTypeSet, auto_termini : bool, idealize_linkages : bool) -> NoneType   Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with ResidueTypeSet  <residue_set> and store it in <pose>.   4. make_pose_from_saccharide_sequence(pose : rosetta.core.pose.Pose, sequence : str) -> NoneType   Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name  <type_set_name> and store it in <pose>.   5. make_pose_from_saccharide_sequence(pose : rosetta.core.pose.Pose, sequence : str, type_set_name : str) -> NoneType   Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name  <type_set_name> and store it in <pose>.   6. make_pose_from_saccharide_sequence(pose : rosetta.core.pose.Pose, sequence : str, type_set_name : str, auto_termini : bool) -> NoneType   Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name  <type_set_name> and store it in <pose>.   7. make_pose_from_saccharide_sequence(pose : rosetta.core.pose.Pose, sequence : str, type_set_name : str, auto_termini : bool, idealize_linkages : bool) -> NoneType   Create a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name  <type_set_name> and store it in <pose>. make_pose_from_sequence(...) method of builtins.PyCapsule instance make_pose_from_sequence(*args, **kwargs) Overloaded function.   1. make_pose_from_sequence(pose : rosetta.core.pose.Pose, requested_types : rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t) -> NoneType   Creates a Pose from the annotated protein sequence  <sequence>  with ResidueTypeSet  <residue_set>  and stores it in  <pose>     : any existing data in  <pose>  is cleared, auto_termini  mark position 1, last_residue with lower, upper termini; default true    example(s):      make_pose_from_sequence(pose,"THANKSEVAN",core::chemical::FA_STANDARD)  See also:      Pose      PDBInfo      pose_from_pdb      pose_from_rcsb      pose_from_sequence   2. make_pose_from_sequence(pose : rosetta.core.pose.Pose, requested_types : rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t, auto_termini : bool) -> NoneType   Creates a Pose from the annotated protein sequence  <sequence>  with ResidueTypeSet  <residue_set>  and stores it in  <pose>     : any existing data in  <pose>  is cleared, auto_termini  mark position 1, last_residue with lower, upper termini; default true    example(s):      make_pose_from_sequence(pose,"THANKSEVAN",core::chemical::FA_STANDARD)  See also:      Pose      PDBInfo      pose_from_pdb      pose_from_rcsb      pose_from_sequence   3. make_pose_from_sequence(pose : rosetta.core.pose.Pose, sequence : str, residue_set : rosetta.core.chemical.ResidueTypeSet) -> NoneType   4. make_pose_from_sequence(pose : rosetta.core.pose.Pose, sequence : str, residue_set : rosetta.core.chemical.ResidueTypeSet, auto_termini : bool) -> NoneType   5. make_pose_from_sequence(pose : rosetta.core.pose.Pose, sequence : str, residue_set : rosetta.core.chemical.ResidueTypeSet) -> NoneType   6. make_pose_from_sequence(pose : rosetta.core.pose.Pose, sequence : str, residue_set : rosetta.core.chemical.ResidueTypeSet, auto_termini : bool) -> NoneType   7. make_pose_from_sequence(pose : rosetta.core.pose.Pose, sequence : str, type_set_name : str) -> NoneType   Creates a Pose from the annotated protein sequence  <sequence>  with the desired  <type_set_name>  and stores it in  <pose>     : any existing data in  <pose>  is cleared, auto_termini  mark position 1, last_residue with lower, upper termini; default true   8. make_pose_from_sequence(pose : rosetta.core.pose.Pose, sequence : str, type_set_name : str, auto_termini : bool) -> NoneType   Creates a Pose from the annotated protein sequence  <sequence>  with the desired  <type_set_name>  and stores it in  <pose>     : any existing data in  <pose>  is cleared, auto_termini  mark position 1, last_residue with lower, upper termini; default true mass(...) method of builtins.PyCapsule instance mass(begin : int, end : int, pose : rosetta.core.pose.Pose) -> float named_atom_id_to_atom_id(...) method of builtins.PyCapsule instance named_atom_id_to_atom_id(*args, **kwargs) Overloaded function.   1. named_atom_id_to_atom_id(named_atom_id : rosetta.core.id.NamedAtomID, pose : rosetta.core.pose.Pose) -> rosetta.core.id.AtomID   2. named_atom_id_to_atom_id(named_atom_id : rosetta.core.id.NamedAtomID, pose : rosetta.core.pose.Pose, raise_exception : bool) -> rosetta.core.id.AtomID named_stub_id_to_stub_id(...) method of builtins.PyCapsule instance named_stub_id_to_stub_id(named_stub_id : rosetta.core.id.NamedStubID, pose : rosetta.core.pose.Pose) -> rosetta.core.id.StubID noncanonical_atom_count(...) method of builtins.PyCapsule instance noncanonical_atom_count(pose : rosetta.core.pose.Pose) -> int   count the number of non-canonical amino acids in thepose noncanonical_chi_count(...) method of builtins.PyCapsule instance noncanonical_chi_count(pose : rosetta.core.pose.Pose) -> int   count the number of non-canonical chi angles in the pose noncanonical_residue_count(...) method of builtins.PyCapsule instance noncanonical_residue_count(pose : rosetta.core.pose.Pose) -> int   count the number of non-canonical residues in the pose nres_protein(...) method of builtins.PyCapsule instance nres_protein(pose : rosetta.core.pose.Pose) -> int   Number of protein residues in the pose      No virtuals, membrane residues or embedding residues counted num_atoms(...) method of builtins.PyCapsule instance num_atoms(begin : int, end : int, pose : rosetta.core.pose.Pose) -> int num_chi_angles(...) method of builtins.PyCapsule instance num_chi_angles(begin : int, end : int, pose : rosetta.core.pose.Pose) -> int num_hbond_acceptors(...) method of builtins.PyCapsule instance num_hbond_acceptors(begin : int, end : int, pose : rosetta.core.pose.Pose) -> int num_hbond_donors(...) method of builtins.PyCapsule instance num_hbond_donors(begin : int, end : int, pose : rosetta.core.pose.Pose) -> int num_heavy_atoms(...) method of builtins.PyCapsule instance num_heavy_atoms(begin : int, end : int, pose : rosetta.core.pose.Pose) -> int parse_PDBnum_icode(...) method of builtins.PyCapsule instance parse_PDBnum_icode(token : str, fname : str, lineno : int, PDBnum : int, icode : str) -> NoneType   Take the string "token" and try to interpret it as a PDB identifier in the form of an  integer as well as an optional insertion code.  For example the string "25A" would be  interpretted as the residue 25 with the insertion code "A."  Throws an exception if  the input string is misformatted. parse_resnum(...) method of builtins.PyCapsule instance parse_resnum(*args, **kwargs) Overloaded function.   1. parse_resnum(resnum : str, pose : rosetta.core.pose.Pose) -> int   Extracts a residue number from a string.      Recognizes three forms of numbering:    - Rosetta residue numbers (numbered sequentially from 1 to the last residue      in the pose). These have the form [0-9]+    - PDB numbers. These have the form [0-9]+[A-Z], where the trailing letter      is the chain ID.   - Reference pose numbers.  These have the form refpose([refpose name], [refpose number]).  In addition, relative numbers are permitted (of the form +[number] or -[number]) in conjunction  with reference pose numbering.  For example, one might say "refpose(state1,17)+3", which means  three residues past the residue correpsonding to residue 17 in the reference pose called "state1".      the rosetta residue number for the string, or 0 upon an error   2. parse_resnum(resnum : str, pose : rosetta.core.pose.Pose, check_for_refpose : bool) -> int   Extracts a residue number from a string.      Recognizes three forms of numbering:    - Rosetta residue numbers (numbered sequentially from 1 to the last residue      in the pose). These have the form [0-9]+    - PDB numbers. These have the form [0-9]+[A-Z], where the trailing letter      is the chain ID.   - Reference pose numbers.  These have the form refpose([refpose name], [refpose number]).  In addition, relative numbers are permitted (of the form +[number] or -[number]) in conjunction  with reference pose numbering.  For example, one might say "refpose(state1,17)+3", which means  three residues past the residue correpsonding to residue 17 in the reference pose called "state1".      the rosetta residue number for the string, or 0 upon an error parse_sequence(...) method of builtins.PyCapsule instance parse_sequence(sequence_in : str, fullname_list : rosetta.utility.vector1_std_string, oneletter_to_fullname_index : rosetta.std.vector_unsigned_long, one_letter_sequence : str) -> NoneType   Parse the input annotated sequence partition_pose_by_jump(...) method of builtins.PyCapsule instance partition_pose_by_jump(src : rosetta.core.pose.Pose, jump_number : int, partner1 : rosetta.core.pose.Pose, partner2 : rosetta.core.pose.Pose) -> NoneType pdb_to_pose(...) method of builtins.PyCapsule instance pdb_to_pose(*args, **kwargs) Overloaded function.   1. pdb_to_pose(pose : rosetta.core.pose.Pose, pdb_res : rosetta.utility.vector1_int) -> rosetta.utility.vector1_unsigned_long   Convert PDB numbering to pose numbering. Must exist somewhere else, but I couldn't find it. -- rhiju   2. pdb_to_pose(pose : rosetta.core.pose.Pose, pdb_res : (rosetta.utility.vector1_int, rosetta.utility.vector1_char)) -> rosetta.utility.vector1_unsigned_long   Convert PDB numbering/chain to pose numbering. Must exist somewhere else, but I couldn't find it. -- rhiju   3. pdb_to_pose(pose : rosetta.core.pose.Pose, res_num : int) -> int   Convert PDB numbering to pose numbering. Must exist somewhere else, but I couldn't find it. -- rhiju   4. pdb_to_pose(pose : rosetta.core.pose.Pose, res_num : int, chain : str) -> int   Convert PDB numbering to pose numbering. Must exist somewhere else, but I couldn't find it. -- rhiju pdbslice(...) method of builtins.PyCapsule instance pdbslice(*args, **kwargs) Overloaded function.   1. pdbslice(new_pose : rosetta.core.pose.Pose, pose : rosetta.core.pose.Pose, slice_res : rosetta.utility.vector1_unsigned_long) -> NoneType   Create a subpose of the src pose -- figures out a reasonable fold tree.   2. pdbslice(pose : rosetta.core.pose.Pose, slice_res : rosetta.utility.vector1_unsigned_long) -> NoneType   Create a subpose of the src pose -- figures out a reasonable fold tree. pose_from_saccharide_sequence(...) method of builtins.PyCapsule instance pose_from_saccharide_sequence(*args, **kwargs) Overloaded function.   1. pose_from_saccharide_sequence(sequence : str) -> rosetta.core.pose.Pose   Return a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name  <type_set_name>.   2. pose_from_saccharide_sequence(sequence : str, type_set_name : str) -> rosetta.core.pose.Pose   Return a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name  <type_set_name>.   3. pose_from_saccharide_sequence(sequence : str, type_set_name : str, auto_termini : bool) -> rosetta.core.pose.Pose   Return a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name  <type_set_name>.   4. pose_from_saccharide_sequence(sequence : str, type_set_name : str, auto_termini : bool, idealize_linkages : bool) -> rosetta.core.pose.Pose   Return a Pose from an annotated, linear, IUPAC polysaccharide sequence <sequence> with residue type set name  <type_set_name>. pose_max_nbr_radius(...) method of builtins.PyCapsule instance pose_max_nbr_radius(pose : rosetta.core.pose.Pose) -> float   returns a Distance pose_residue_is_terminal(...) method of builtins.PyCapsule instance pose_residue_is_terminal(pose : rosetta.core.pose.Pose, resid : int) -> bool   returns true if the given residue in the pose is a chain ending or has upper/lower terminal variants pose_to_pdb(...) method of builtins.PyCapsule instance pose_to_pdb(pose : rosetta.core.pose.Pose, pose_res : rosetta.utility.vector1_unsigned_long) -> rosetta.utility.vector1_unsigned_long   Convert pose numbering to pdb numbering. Must exist somewhere else, but I couldn't find it. -- rhiju read_comment_pdb(...) method of builtins.PyCapsule instance read_comment_pdb(file_name : str, pose : rosetta.core.pose.Pose) -> NoneType   Reads the comments from the pdb file and adds it into comments read_psipred_ss2_file(...) method of builtins.PyCapsule instance read_psipred_ss2_file(pose : rosetta.core.pose.Pose) -> rosetta.utility.vector1_char remove_ligand_canonical_residues(...) method of builtins.PyCapsule instance remove_ligand_canonical_residues(pose : rosetta.core.pose.Pose) -> NoneType   this function removes all residues with both UPPER and LOWER terminus types.  This is intended for removing ligands that are canonical residues. remove_lower_terminus_type_from_pose_residue(...) method of builtins.PyCapsule instance remove_lower_terminus_type_from_pose_residue(pose : rosetta.core.pose.Pose, seqpos : int) -> NoneType remove_nonprotein_residues(...) method of builtins.PyCapsule instance remove_nonprotein_residues(pose : rosetta.core.pose.Pose) -> NoneType   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). remove_upper_terminus_type_from_pose_residue(...) method of builtins.PyCapsule instance remove_upper_terminus_type_from_pose_residue(pose : rosetta.core.pose.Pose, seqpos : int) -> NoneType remove_variant_type_from_pose_residue(...) method of builtins.PyCapsule instance remove_variant_type_from_pose_residue(pose : rosetta.core.pose.Pose, variant_type : rosetta.core.chemical.VariantType, seqpos : int) -> NoneType   Construct a non-variant of an existing pose residue. remove_variant_type_from_residue(...) method of builtins.PyCapsule instance remove_variant_type_from_residue(old_rsd : rosetta.core.conformation.Residue, variant_type : rosetta.core.chemical.VariantType, pose : rosetta.core.pose.Pose) -> rosetta.core.conformation.Residue   Remove variant from an existing residue. remove_virtual_residues(...) method of builtins.PyCapsule instance remove_virtual_residues(pose : rosetta.core.pose.Pose) -> NoneType   Removes all virtual residues from <pose> renumber_pdbinfo_based_on_conf_chains(...) method of builtins.PyCapsule instance renumber_pdbinfo_based_on_conf_chains(*args, **kwargs) Overloaded function.   1. renumber_pdbinfo_based_on_conf_chains(pose : rosetta.core.pose.Pose) -> bool   renumber PDBInfo based on Conformation chains; each chain starts from 1      The Pose to modify.      If true, the procedure will attempt to fix any empty record   characters it finds in the PDBInfo. (default true)      If true, will attempt to start each   chain from the existing numbering in the PDBInfo.  E.g. if the first residue   of chain 2 in the Conformation is 27, then the renumbering of the chain in   PDBInfo will start from 27. (default true)      If true, will maintain insertion codes and   will not increment the pdb residue numbering for those residues.  This means   new numbering with insertion codes will only reflect properly if the   old numbering included the base numbering of the insertion code residues,   i.e. 100 100A 100B and not just 100A 100B (with 100 never appearing).   (default false)      If true, allows support for more than 26 pdb chains   by rotating [A,Z] continuously.  WARNING: This will break the assumption   made by the PDBPoseMap that each pdb chain id is unique, so make sure you   are not using the PDBPoseMap feature downstream in your code path without   corrections! (default false)      If fixing chains and there is only one chain and the PDBInfo exists   but all records are marked as empty, will renumber and set the PDBInfo chain   to 'A'.      true if renumbering successful, false otherwise   2. renumber_pdbinfo_based_on_conf_chains(pose : rosetta.core.pose.Pose, fix_chains : bool) -> bool   renumber PDBInfo based on Conformation chains; each chain starts from 1      The Pose to modify.      If true, the procedure will attempt to fix any empty record   characters it finds in the PDBInfo. (default true)      If true, will attempt to start each   chain from the existing numbering in the PDBInfo.  E.g. if the first residue   of chain 2 in the Conformation is 27, then the renumbering of the chain in   PDBInfo will start from 27. (default true)      If true, will maintain insertion codes and   will not increment the pdb residue numbering for those residues.  This means   new numbering with insertion codes will only reflect properly if the   old numbering included the base numbering of the insertion code residues,   i.e. 100 100A 100B and not just 100A 100B (with 100 never appearing).   (default false)      If true, allows support for more than 26 pdb chains   by rotating [A,Z] continuously.  WARNING: This will break the assumption   made by the PDBPoseMap that each pdb chain id is unique, so make sure you   are not using the PDBPoseMap feature downstream in your code path without   corrections! (default false)      If fixing chains and there is only one chain and the PDBInfo exists   but all records are marked as empty, will renumber and set the PDBInfo chain   to 'A'.      true if renumbering successful, false otherwise   3. renumber_pdbinfo_based_on_conf_chains(pose : rosetta.core.pose.Pose, fix_chains : bool, start_from_existing_numbering : bool) -> bool   renumber PDBInfo based on Conformation chains; each chain starts from 1      The Pose to modify.      If true, the procedure will attempt to fix any empty record   characters it finds in the PDBInfo. (default true)      If true, will attempt to start each   chain from the existing numbering in the PDBInfo.  E.g. if the first residue   of chain 2 in the Conformation is 27, then the renumbering of the chain in   PDBInfo will start from 27. (default true)      If true, will maintain insertion codes and   will not increment the pdb residue numbering for those residues.  This means   new numbering with insertion codes will only reflect properly if the   old numbering included the base numbering of the insertion code residues,   i.e. 100 100A 100B and not just 100A 100B (with 100 never appearing).   (default false)      If true, allows support for more than 26 pdb chains   by rotating [A,Z] continuously.  WARNING: This will break the assumption   made by the PDBPoseMap that each pdb chain id is unique, so make sure you   are not using the PDBPoseMap feature downstream in your code path without   corrections! (default false)      If fixing chains and there is only one chain and the PDBInfo exists   but all records are marked as empty, will renumber and set the PDBInfo chain   to 'A'.      true if renumbering successful, false otherwise   4. renumber_pdbinfo_based_on_conf_chains(pose : rosetta.core.pose.Pose, fix_chains : bool, start_from_existing_numbering : bool, keep_insertion_codes : bool) -> bool   renumber PDBInfo based on Conformation chains; each chain starts from 1      The Pose to modify.      If true, the procedure will attempt to fix any empty record   characters it finds in the PDBInfo. (default true)      If true, will attempt to start each   chain from the existing numbering in the PDBInfo.  E.g. if the first residue   of chain 2 in the Conformation is 27, then the renumbering of the chain in   PDBInfo will start from 27. (default true)      If true, will maintain insertion codes and   will not increment the pdb residue numbering for those residues.  This means   new numbering with insertion codes will only reflect properly if the   old numbering included the base numbering of the insertion code residues,   i.e. 100 100A 100B and not just 100A 100B (with 100 never appearing).   (default false)      If true, allows support for more than 26 pdb chains   by rotating [A,Z] continuously.  WARNING: This will break the assumption   made by the PDBPoseMap that each pdb chain id is unique, so make sure you   are not using the PDBPoseMap feature downstream in your code path without   corrections! (default false)      If fixing chains and there is only one chain and the PDBInfo exists   but all records are marked as empty, will renumber and set the PDBInfo chain   to 'A'.      true if renumbering successful, false otherwise   5. renumber_pdbinfo_based_on_conf_chains(pose : rosetta.core.pose.Pose, fix_chains : bool, start_from_existing_numbering : bool, keep_insertion_codes : bool, rotate_chain_ids : bool) -> bool   renumber PDBInfo based on Conformation chains; each chain starts from 1      The Pose to modify.      If true, the procedure will attempt to fix any empty record   characters it finds in the PDBInfo. (default true)      If true, will attempt to start each   chain from the existing numbering in the PDBInfo.  E.g. if the first residue   of chain 2 in the Conformation is 27, then the renumbering of the chain in   PDBInfo will start from 27. (default true)      If true, will maintain insertion codes and   will not increment the pdb residue numbering for those residues.  This means   new numbering with insertion codes will only reflect properly if the   old numbering included the base numbering of the insertion code residues,   i.e. 100 100A 100B and not just 100A 100B (with 100 never appearing).   (default false)      If true, allows support for more than 26 pdb chains   by rotating [A,Z] continuously.  WARNING: This will break the assumption   made by the PDBPoseMap that each pdb chain id is unique, so make sure you   are not using the PDBPoseMap feature downstream in your code path without   corrections! (default false)      If fixing chains and there is only one chain and the PDBInfo exists   but all records are marked as empty, will renumber and set the PDBInfo chain   to 'A'.      true if renumbering successful, false otherwise reorder_saccharide_residue_types(...) method of builtins.PyCapsule instance reorder_saccharide_residue_types(residue_types : rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t) -> NoneType   This is a subroutine/helper function to reorder saccharide ResidueTypes generated from an IUPAC sequence. replace_pose_residue_copying_existing_coordinates(...) method of builtins.PyCapsule instance replace_pose_residue_copying_existing_coordinates(pose : rosetta.core.pose.Pose, seqpos : int, new_rsd_type : rosetta.core.chemical.ResidueType) -> NoneType res_in_chain(...) method of builtins.PyCapsule instance res_in_chain(pose : rosetta.core.pose.Pose, resnum : int, chain : str) -> bool   Is residue number in this chain? residue_center_of_mass(...) method of builtins.PyCapsule instance residue_center_of_mass(*args, **kwargs) Overloaded function.   1. residue_center_of_mass(pose : rosetta.core.pose.Pose, residues : rosetta.utility.vector1_bool) -> int   2. residue_center_of_mass(pose : rosetta.core.pose.Pose, start : int, stop : int) -> int residue_types_from_saccharide_sequence(...) method of builtins.PyCapsule instance residue_types_from_saccharide_sequence(sequence : str, residue_set : rosetta.core.chemical.ResidueTypeSet) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   Return a list of carbohydrate ResidueTypes corresponding to an annotated, linear, IUPAC polysaccharide  sequence. residue_types_from_sequence(...) method of builtins.PyCapsule instance residue_types_from_sequence(*args, **kwargs) Overloaded function.   1. residue_types_from_sequence(sequence_in : str, residue_set : rosetta.core.chemical.ResidueTypeSet) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   return a list of ResidueTypes corresponding to an annotated protein sequence      an annotated sequence      the desired residue set      mark position 1, last_residue with lower, upper termini; default true   2. residue_types_from_sequence(sequence_in : str, residue_set : rosetta.core.chemical.ResidueTypeSet, auto_termini : bool) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   return a list of ResidueTypes corresponding to an annotated protein sequence      an annotated sequence      the desired residue set      mark position 1, last_residue with lower, upper termini; default true return_nearest_residue(...) method of builtins.PyCapsule instance return_nearest_residue(*args, **kwargs) Overloaded function.   1. return_nearest_residue(pose : rosetta.core.pose.Pose, residues : rosetta.utility.vector1_bool, center : rosetta.numeric.xyzVector_double_t) -> int   2. return_nearest_residue(pose : rosetta.core.pose.Pose, begin : int, end : int, center : rosetta.numeric.xyzVector_double_t) -> int sequence_map_from_pdbinfo(...) method of builtins.PyCapsule instance sequence_map_from_pdbinfo(first : rosetta.core.pose.Pose, second : rosetta.core.pose.Pose) -> rosetta.core.id.SequenceMapping   Create a sequence map of first pose onto the second, matching the PDBInfo     If the PDBInfo of either Pose is missing or invalid, do a simple sequence alignment matching. setPoseExtraScore(...) method of builtins.PyCapsule instance setPoseExtraScore(*args, **kwargs) Overloaded function.   1. setPoseExtraScore(pose : rosetta.core.pose.Pose, name : str, value : float) -> NoneType   2. setPoseExtraScore(pose : rosetta.core.pose.Pose, name : str, value : str) -> NoneType set_bb_torsion(...) method of builtins.PyCapsule instance set_bb_torsion(torsion_id : int, pose : rosetta.core.pose.Pose, sequence_position : int, new_angle : float) -> NoneType   Set the BB torsion, phi, psi, omega (see core::types).  Works with carbohydrates.  Think about moving this to pose itself. set_bfactors_from_atom_id_map(...) method of builtins.PyCapsule instance set_bfactors_from_atom_id_map(pose : rosetta.core.pose.Pose, bfactors : rosetta.core.id.AtomID_Map_double_t) -> NoneType   Set bfactors in a pose PDBInfo set_reasonable_fold_tree(...) method of builtins.PyCapsule instance set_reasonable_fold_tree(pose : rosetta.core.pose.Pose) -> NoneType set_ss_from_phipsi(...) method of builtins.PyCapsule instance set_ss_from_phipsi(pose : rosetta.core.pose.Pose) -> NoneType   Analyzes  <pose>  residue phi/psi sets and guesses the secondary  structure, ideally dssp should be used for that setup_dof_mask_from_move_map(...) method of builtins.PyCapsule instance setup_dof_mask_from_move_map(mm : core::kinematics::MoveMap, pose : rosetta.core.pose.Pose, dof_mask : rosetta.core.id.DOF_ID_Map_bool_t) -> NoneType   convert from allow-bb/allow-chi MoveMap to simple DOF_ID boolean mask needed by the minimizer setup_dof_to_torsion_map(...) method of builtins.PyCapsule instance setup_dof_to_torsion_map(pose : rosetta.core.pose.Pose, dof_map : rosetta.core.id.DOF_ID_Map_core_id_TorsionID_t) -> NoneType   set up a map to look up TORSION_ID by DOF_ID (Map[DOF_ID] = TORISION_ID) sort_pose_by_score(...) method of builtins.PyCapsule instance sort_pose_by_score(pose1 : rosetta.core.pose.Pose, pose2 : rosetta.core.pose.Pose) -> bool stub_id_to_named_stub_id(...) method of builtins.PyCapsule instance stub_id_to_named_stub_id(stub_id : rosetta.core.id.StubID, pose : rosetta.core.pose.Pose) -> rosetta.core.id.NamedStubID swap_transform(...) method of builtins.PyCapsule instance swap_transform(jump_num : int, xform : rosetta.core.kinematics.RT, pose : rosetta.core.pose.Pose) -> NoneType   Updates the rigid-body transform of the specified jump in <pose> tag_from_pose(...) method of builtins.PyCapsule instance tag_from_pose(pose : rosetta.core.pose.Pose) -> str   //////////////////////////////////////////////////////////////// tag_into_pose(...) method of builtins.PyCapsule instance tag_into_pose(pose : rosetta.core.pose.Pose, tag : str) -> NoneType total_energy_from_pose(...) method of builtins.PyCapsule instance total_energy_from_pose(pose : rosetta.core.pose.Pose) -> float transfer_jumps(...) method of builtins.PyCapsule instance transfer_jumps(srcpose : rosetta.core.pose.Pose, tgtpose : rosetta.core.pose.Pose) -> NoneType transfer_phi_psi(...) method of builtins.PyCapsule instance transfer_phi_psi(*args, **kwargs) Overloaded function.   1. transfer_phi_psi(srcpose : rosetta.core.pose.Pose, tgtpose : rosetta.core.pose.Pose, ir : int, jr : int) -> NoneType   2. transfer_phi_psi(srcpose : rosetta.core.pose.Pose, tgtpose : rosetta.core.pose.Pose) -> NoneType