Top

rosetta.core.chemical._core_chemical_ module

Module variables

var ACETYLAMINO_SUGAR

var ACETYLATED_NTERMINUS

var ACETYLATED_NTERMINUS_VARIANT

var ACETYLATION

var ACETYL_SUGAR

var ADDUCT

var ADDUCT_VARIANT

var ALDONIC_ACID

var ALDONIC_ACID_VARIANT

var ALDOSE

var ALPHA_AA

var ALPHA_SUGAR

var ALTERNATIVE_PROTONATION

var AMINO_SUGAR

var AROMATIC

var AromaticBond

var BETA_AA

var BETA_SUGAR

var BRANCH_LOWER_TERMINUS

var BRANCH_LOWER_TERMINUS_VARIANT

var BRANCH_POINT

var BULGE

var BondInRing

var BondNotInRing

var C1_ACETYLAMINO_SUGAR

var C1_AMINO_SUGAR

var C1_BRANCH_POINT

var C1_DEOXY_SUGAR

var C1_MODIFIED

var C1_PHOSPHATE

var C2_ACETYLAMINO_SUGAR

var C2_AMINO_SUGAR

var C2_BRANCH_POINT

var C2_DEOXY_SUGAR

var C2_KETOALDONIC_ACID

var C2_MODIFIED

var C2_PHOSPHATE

var C3_ACETYLAMINO_SUGAR

var C3_AMINO_SUGAR

var C3_BRANCH_POINT

var C3_DEOXY_SUGAR

var C3_KETOALDONIC_ACID

var C3_MODIFIED

var C3_PHOSPHATE

var C4_ACETYLAMINO_SUGAR

var C4_AMINO_SUGAR

var C4_BRANCH_POINT

var C4_DEOXY_SUGAR

var C4_KETOALDONIC_ACID

var C4_MODIFIED

var C4_PHOSPHATE

var C5_ACETYLAMINO_SUGAR

var C5_AMINO_SUGAR

var C5_BRANCH_POINT

var C5_DEOXY_SUGAR

var C5_KETOALDONIC_ACID

var C5_MODIFIED

var C5_PHOSPHATE

var C6_ACETYLAMINO_SUGAR

var C6_AMINO_SUGAR

var C6_BRANCH_POINT

var C6_DEOXY_SUGAR

var C6_KETOALDONIC_ACID

var C6_MODIFIED

var C6_PHOSPHATE

var C7_ACETYLAMINO_SUGAR

var C7_AMINO_SUGAR

var C7_BRANCH_POINT

var C7_DEOXY_SUGAR

var C7_KETOALDONIC_ACID

var C7_MODIFIED

var C7_PHOSPHATE

var C8_ACETYLAMINO_SUGAR

var C8_AMINO_SUGAR

var C8_BRANCH_POINT

var C8_DEOXY_SUGAR

var C8_KETOALDONIC_ACID

var C8_MODIFIED

var C8_PHOSPHATE

var C9_ACETYLAMINO_SUGAR

var C9_AMINO_SUGAR

var C9_BRANCH_POINT

var C9_DEOXY_SUGAR

var C9_MODIFIED

var C9_PHOSPHATE

var CARBOHYDRATE

var CARBOXYLATION

var CENTROID_HA

var CHARGED

var COARSE

var CTERM_CONNECT

var CUTPOINT_LOWER

var CUTPOINT_UPPER

var CYCLIC

var C_METHYLAMIDATION

var ConjugableBond

var DEOXY_SUGAR

var DEPROTONATED

var DIIODINATION

var DIMETHYLATION

var DISULFIDE

var DISULFIDE_BONDED

var DNA

var D_AA

var D_SUGAR

var DoubleBond

var DoubleBondOrder

var EIsometry

var FIRST_PROPERTY

var FIRST_VARIANT

var FIVE_PRIME_END_OH

var FIVE_PRIME_END_PHOSPHATE

var FIVE_PRIME_PACKABLE_PHOSPHATE

var FIVE_PRIME_PHOSPHATE

var FORMS_DISULFIDE_BOND

var FURANOSE

var GAMMA_AA

var GLYCOSIDE

var HBS_POST

var HBS_PRE

var HYBRID_MAX

var HYDROXYLATION

var HYDROXYLATION1

var HYDROXYLATION2

var IsAromaticBond

var KETOSE

var LIGAND

var LIPID

var LOWERTERM_TRUNC

var LOWERTERM_TRUNC_VARIANT

var LOWER_TERMINUS

var LOWER_TERMINUS_VARIANT

var L_AA

var L_SUGAR

var MEMBRANE

var METAL

var METALBINDING

var METHYLATED_CTERMINUS

var METHYLATED_CTERMINUS_VARIANT

var METHYLATED_NTERM_VARIANT

var METHYLATION

var METHYL_GLYCOSIDE

var NE2_CONNECT

var NTERM_CONNECT

var N_ACETYLATION

var N_PROPERTIES

var N_VARIANTS

var NoBondIsometry

var NonaromaticBond

var NotConjugableBond

var OOP_POST

var OOP_PRE

var OXETOSE

var OXIROSE

var OrbitalBond

var OrbitalBondOrder

var PEPTOID

var PHI

var PHOSPHATE

var PHOSPHONATE

var PHOSPHONATE_UPPER

var PHOSPHONATE_UPPER_VARIANT

var PHOSPHORYLATION

var POLAR

var POLYMER

var PROTEIN

var PROTONATED

var PROTONATED_H1_ADENOSINE

var PYRANOSE

var PseudoBondOrder

var REPLONLY

var RING_HYBRID

var RNA

var SC_BRANCH_POINT

var SC_FRAGMENT

var SC_ORBITALS

var SEPTANOSE

var SG_CONNECT

var SHOVE_BB

var SIALIC_ACID

var SIDECHAIN_CONJUGATION

var SP2_HYBRID

var SP3_HYBRID

var SPECIAL_ROT

var SRI

var SULFATION

var SURFACE

var SingleBond

var SingleBondOrder

var TAUTOMER

var THETA

var THREE_PRIME_END_OH

var THREE_PRIME_PACKABLE_PHOSPHATE

var THREE_PRIME_PHOSPHATE

var TRIAZOLEMER

var TRIMETHYLATION

var TripleBond

var TripleBondOrder

var UNKNOWN_HYBRID

var UPPERTERM_TRUNC

var UPPERTERM_TRUNC_VARIANT

var UPPER_TERMINUS

var UPPER_TERMINUS_VARIANT

var URONIC_ACID

var URONIC_ACID_VARIANT

var UnknownAromaticity

var UnknownBond

var UnknownBondOrder

var UnknownConjugability

var UnknownIsometry

var UnknownRingness

var VIRTUAL_BACKBONE_EXCEPT_C1PRIME

var VIRTUAL_BASE

var VIRTUAL_BASE_HEAVY_ATOM

var VIRTUAL_BB

var VIRTUAL_DNA_PHOSPHATE

var VIRTUAL_NTERM

var VIRTUAL_O2PRIME_HYDROGEN

var VIRTUAL_PHOSPHATE

var VIRTUAL_RESIDUE

var VIRTUAL_RESIDUE_VARIANT

var VIRTUAL_RIBOSE

var VIRTUAL_RNA_RESIDUE

var VIRTUAL_RNA_RESIDUE_EXCLUDE_PHOSPHATE

var VIRTUAL_SIDE_CHAIN

var WATER

var ZIsometry

var ZN_CONNECT

var aa_ala

var aa_arg

var aa_asn

var aa_asp

var aa_b3a

var aa_b3c

var aa_b3cisACHC

var aa_b3cisACPC

var aa_b3cisACPrC

var aa_b3d

var aa_b3e

var aa_b3f

var aa_b3g

var aa_b3h

var aa_b3i

var aa_b3k

var aa_b3l

var aa_b3m

var aa_b3n

var aa_b3p

var aa_b3q

var aa_b3r

var aa_b3s

var aa_b3t

var aa_b3v

var aa_b3w

var aa_b3y

var aa_cys

var aa_dal

var aa_dan

var aa_dar

var aa_das

var aa_dcs

var aa_dgn

var aa_dgu

var aa_dhi

var aa_dil

var aa_dle

var aa_dly

var aa_dme

var aa_dph

var aa_dpr

var aa_dse

var aa_dth

var aa_dtr

var aa_dty

var aa_dva

var aa_gln

var aa_glu

var aa_gly

var aa_h2o

var aa_his

var aa_ile

var aa_leu

var aa_lys

var aa_met

var aa_phe

var aa_pro

var aa_ser

var aa_thr

var aa_trp

var aa_tyr

var aa_unk

var aa_unp

var aa_val

var aa_vrt

var first_DNA_aa

var first_D_aa

var first_beta3_aa

var last_DNA_aa

var last_D_aa

var last_beta3_aa

var na_ade

var na_cyt

var na_gua

var na_rad

var na_rcy

var na_rgu

var na_thy

var na_ura

var num_aa_types

var num_canonical_aas

var q

Functions

def aa_from_name(

...)

aa_from_name( (str)name) -> AA : /////////////////////////////////////////////////////// Give an AA string name, return its enum type. ///////////////////////////////////////////////////////

C++ signature : core::chemical::AA aa_from_name(std::string)

def aa_from_oneletter_code(

...)

aa_from_oneletter_code( (str)onelettercode) -> AA : //////////////////////////////////////////////////////// give a 1 letter code and return the string name ////////////////////////////////////////////////////////

C++ signature : core::chemical::AA aa_from_oneletter_code(char)

def add_atom_type_set_parameters_from_command_line(

...)

add_atom_type_set_parameters_from_command_line( (str)atom_type_set_tag, (AtomTypeSet)atom_type_set) -> None : Add additional parameter files not present in /extras.txt.

C++ signature : void add_atom_type_set_parameters_from_command_line(std::string,core::chemical::AtomTypeSet {lvalue})

def apply_adducts_to_residue(

...)

apply_adducts_to_residue( (ResidueType)rsd, (vector1_bool)add_mask) -> ResidueType : Apply adducts to residue using a boolean mask

C++ signature : boost::shared_ptr apply_adducts_to_residue(core::chemical::ResidueType,utility::vector1 > {lvalue})

def calculate_rigid_matrix(

...)

calculate_rigid_matrix( (ResidueType)res, (vec1_vec1_Real)distances) -> None : Calculate the rigid matrix for neighbor atom finding Assume that distances has been initialized to some really large value, and is square

C++ signature : void calculate_rigid_matrix(core::chemical::ResidueType,utility::vector1 >, std::allocator > > > {lvalue})

def convert_residuetype_to_light_graph(

...)

convert_residuetype_to_light_graph( (ResidueType)res) -> object : core/chemical/residue_support.hh:35

C++ signature : boost::adjacency_list, boost::property, boost::no_property>, boost::no_property, boost::listS> convert_residuetype_to_light_graph(core::chemical::ResidueType)

def convert_to_BondName(

...)

convert_to_BondName( (str)id) -> BondName : core/chemical/Bond.hh:33

C++ signature : core::chemical::BondName convert_to_BondName(std::string)

def create_bond_length(

...)

create_bond_length( (object)atom1, (object)atom2, (BondName)bond_type) -> float : core/chemical/bond_support.hh:34

C++ signature : double create_bond_length(core::chemical::gasteiger::GasteigerAtomTypeData,core::chemical::gasteiger::GasteigerAtomTypeData,core::chemical::BondName)

def define_mainchain_atoms(

...)

define_mainchain_atoms( (ResidueType)rsd) -> vector1_Size : If polymer, determine a list of main chain atoms by shortest path from LOWER to UPPER.

C++ signature : utility::vector1 > define_mainchain_atoms(boost::shared_ptr)

def enlarge_h_lj_wdepth(

...)

enlarge_h_lj_wdepth( (AtomTypeSet)atom_type_set) -> None : core/chemical/util.hh:73

C++ signature :
    void enlarge_h_lj_wdepth(core::chemical::AtomTypeSet {lvalue})

enlarge_h_lj_wdepth( (vector1_Real)lj_wdepth, (AtomTypeSet)atom_type_set) -> None : core/chemical/util.hh:70

C++ signature :
    void enlarge_h_lj_wdepth(utility::vector1<double, std::allocator<double> > {lvalue},core::chemical::AtomTypeSet)

def error_check_requested_adducts(

...)

error_check_requested_adducts( (map_string_int)add_map, (object)rsd_types) -> None : Make sure requested adducts exist in some residue

C++ signature : void error_check_requested_adducts(std::map, std::allocator > >,utility::vector1, std::allocator > >)

def fill_ideal_xyz_from_icoor(

...)

fill_ideal_xyz_from_icoor( (ResidueType)restype, (object)graph) -> None : core/chemical/icoor_support.hh:44

C++ signature : void fill_ideal_xyz_from_icoor(core::chemical::ResidueType {lvalue},boost::undirected_graph)

def find_bonds_in_rings(

...)

find_bonds_in_rings( (ResidueType)res) -> None : Determine which bonds are in rings, and set the BondRingness property of each

C++ signature : void find_bonds_in_rings(core::chemical::ResidueType {lvalue})

def find_chi_bonds(

...)

find_chi_bonds( (ResidueType)restype) -> object : Find which bonds are rotatatable (chi) bonds Returns a list of four vds representing the chi

C++ signature : utility::vector1 >, std::allocator > > > find_chi_bonds(core::chemical::ResidueType)

def find_nbr_dist(

...)

find_nbr_dist( (ResidueType)res, (object)nbr_atom) -> float : Find the neighbor distance to the given neighbor atom. If nbr_atom is null_vertex, give the smallest neighbor distance, and set nbr_atom to the atom for that distance. The neighbor distance here is adjusted for rotatable bonds - It should be at least as large as the maximum neighbor distance in any torsional rotamer If the neighbor atom is not provided, the atom chosen will be a multiply-bonded heavy atom. Assumes: * All atoms and bond are present * All ideal_xyz coordinates have been set * All elements have been set * All ring bonds have been annotated

C++ signature : double find_nbr_dist(core::chemical::ResidueType,void* {lvalue})

def fixup_patches(

...)

fixup_patches( (str)string_in) -> str : Replaces the deprecated "_p:" linker connecting ResidueType base names with their patch names with ":".

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

def formatted_icoord_tree(

...)

formatted_icoord_tree( (ResidueType)restype) -> str : Return a string representing the internal coordinates tree of this ResidueType.

C++ signature : std::string formatted_icoord_tree(core::chemical::ResidueType)

def get_D_equivalent(

...)

get_D_equivalent( (AA)aa) -> AA : /////////////////////////////////////////////////////// Given an enum type for a L-amino acid with a canonical side-chain, return the enum type for the corresponding D-amino acid (or aa_unk if the corresponding D-amino acid cannot be determined). ///////////////////////////////////////////////////////

C++ signature : core::chemical::AA get_D_equivalent(core::chemical::AA)

def get_L_equivalent(

...)

get_L_equivalent( (AA)aa) -> AA : /////////////////////////////////////////////////////// Given an enum type for a D-amino acid with a canonical side-chain, return the enum type for the corresponding L-amino acid (or aa_unk if the corresponding L-amino acid cannot be determined). ///////////////////////////////////////////////////////

C++ signature : core::chemical::AA get_L_equivalent(core::chemical::AA)

def get_bond(

...)

get_bond( (ResidueType)res, (object)source, (object)target) -> object : core/chemical/bond_support.hh:30

C++ signature : boost::detail::edge_desc_impl get_bond(core::chemical::ResidueType,void,void)

def get_connecting_atoms(

...)

get_connecting_atoms( (object)res, (object)edge) -> object : core/chemical/bond_support.hh:29

C++ signature :
    utility::vector1<void*, std::allocator<void*> > get_connecting_atoms(boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>,boost::detail::edge_desc_impl<boost::undirected_tag, void*>)

get_connecting_atoms( (ResidueType)res, (object)edge) -> object : core/chemical/bond_support.hh:28

C++ signature :
    utility::vector1<void*, std::allocator<void*> > get_connecting_atoms(core::chemical::ResidueType,boost::detail::edge_desc_impl<boost::undirected_tag, void*>)

def get_residue_path_distances(

...)

get_residue_path_distances( (ResidueType)res) -> object : relies on class Graph to find all pairs shortest path information

C++ signature : ObjexxFCL::FArray2D get_residue_path_distances(core::chemical::ResidueType)

def get_rpp_charge(

...)

get_rpp_charge( (str)type) -> float : Get charge for atom type based on Rosetta++ aaproperties_pack.cc values

C++ signature : double get_rpp_charge(std::string)

def has(

...)

has( (object)graph, (object)ed) -> bool : Does a ResidueGraph have a given edge descriptor?

C++ signature :
    bool has(boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>,boost::detail::edge_desc_impl<boost::undirected_tag, void*>)

has( (object)graph, (object)vd) -> bool : ///////////////////////////////////////////// //////// Convenience Functions ////////////// Does a ResidueGraph have a given vertex descriptor?

C++ signature :
    bool has(boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>,void*)

def is_canonical_D_aa(

...)

is_canonical_D_aa( (AA)aa) -> bool : /////////////////////////////////////////////////////// Give an enum type, return true if and only if it is a D-amino acid that is the mirror image of a canonical alpha-L-amino acid. Vikram K. Mulligan (vmullig@uw.edu) ///////////////////////////////////////////////////////

C++ signature : bool is_canonical_D_aa(core::chemical::AA)

def is_sp2_proton_chi(

...)

is_sp2_proton_chi( (int)chi, (ResidueType)restype) -> bool : Is the given chi a proton chi with the proton attached to an atom attached to an non-sp3 atom? The use case is to see if the proton chi should flat or staggered with rotamers

C++ signature : bool is_sp2_proton_chi(unsigned long,core::chemical::ResidueType)

def modify_atom_properties_from_command_line(

...)

modify_atom_properties_from_command_line( (str)atom_type_set_tag, (AtomTypeSet)atom_type_set) -> None : Modify atom_type properties from the command line.

C++ signature : void modify_atom_properties_from_command_line(std::string,core::chemical::AtomTypeSet {lvalue})

def name_from_aa(

...)

name_from_aa( (AA)aa) -> str : //////////////////////////////////////////////////// give a enum type and return the string name ////////////////////////////////////////////////////

C++ signature : std::string name_from_aa(core::chemical::AA)

def nonadduct_variants_match(

...)

nonadduct_variants_match( (ResidueType)res1, (ResidueType)res2) -> bool : Similar to variants_match(), but allows different adduct-modified states.

C++ signature : bool nonadduct_variants_match(core::chemical::ResidueType,core::chemical::ResidueType)

def oneletter_code_from_aa(

...)

oneletter_code_from_aa( (AA)aa) -> str : //////////////////////////////////////////////////// give a enum type and return the string name ////////////////////////////////////////////////////

C++ signature : char oneletter_code_from_aa(core::chemical::AA)

def oneletter_code_specifies_aa(

...)

oneletter_code_specifies_aa( (str)onelettercode) -> bool : core/chemical/AA.hh:194

C++ signature : bool oneletter_code_specifies_aa(char)

def parse_adduct_string(

...)

parse_adduct_string( (object)add_vec) -> map_string_int : Convert input string to map of adducts->max usage

C++ signature : std::map, std::allocator > > parse_adduct_string(utility::options::StringVectorOption {lvalue})

def patch_operation_from_patch_file_line(

...)

patch_operation_from_patch_file_line( (str)line) -> PatchOperation : Virtual constructor, returns 0 if no match

C++ signature : boost::shared_ptr patch_operation_from_patch_file_line(std::string)

def pretty_print_atomicoor(

...)

pretty_print_atomicoor( (OStream)out, (AtomICoor)start, (ResidueType)rsd_type [, (int)indent=0]) -> None : core/chemical/AtomICoor.hh:385

C++ signature : void pretty_print_atomicoor(std::ostream {lvalue},core::chemical::AtomICoor,core::chemical::ResidueType [,unsigned long=0])

def print_chis(

...)

print_chis( (OStream)out, (ResidueType)res) -> None : Utility to examine chi output.

C++ signature : void print_chis(std::ostream {lvalue},core::chemical::ResidueType)

def read_conformers_from_database_file_for_ring_size(

...)

read_conformers_from_database_file_for_ring_size( (str)filename, (int)ring_size) -> object : Return a list of ring conformers, read from a database file.

C++ signature : utility::vector1 > read_conformers_from_database_file_for_ring_size(std::string,unsigned long)

def read_topology_file(

...)

read_topology_file( (object)istream, (AtomTypeSetCAP)atom_types, (ElementSetCAP)elements, (MMAtomTypeSetCAP)mm_atom_types, (OrbitalTypeSetCAP)orbital_atom_types, (ResidueTypeSetCAP)rsd_type_set) -> ResidueType : core/chemical/residue_io.hh:57

C++ signature :
    boost::shared_ptr<core::chemical::ResidueType> read_topology_file(utility::io::izstream {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>,boost::weak_ptr<core::chemical::ElementSet const>,boost::weak_ptr<core::chemical::MMAtomTypeSet const>,boost::weak_ptr<core::chemical::orbitals::OrbitalTypeSet const>,boost::weak_ptr<core::chemical::ResidueTypeSet const>)

read_topology_file( (str)filename, (AtomTypeSetCAP)atom_types, (ElementSetCAP)elements, (MMAtomTypeSetCAP)mm_atom_types, (OrbitalTypeSetCAP)orbital_atom_types, (ResidueTypeSetCAP)rsd_type_set) -> ResidueType : virtual constructor for ResidueType objects

C++ signature :
    boost::shared_ptr<core::chemical::ResidueType> read_topology_file(std::string,boost::weak_ptr<core::chemical::AtomTypeSet const>,boost::weak_ptr<core::chemical::ElementSet const>,boost::weak_ptr<core::chemical::MMAtomTypeSet const>,boost::weak_ptr<core::chemical::orbitals::OrbitalTypeSet const>,boost::weak_ptr<core::chemical::ResidueTypeSet const>)

def rename_atoms(

...)

rename_atoms( (ResidueType)res [, (bool)preserve=True]) -> None : Rename atoms in the residue type such that their names are unique. If preserve is true, only rename those which have no names or who have name conflicts. (Both of the conflicting atoms will be renamed.)

C++ signature : void rename_atoms(core::chemical::ResidueType {lvalue} [,bool=True])

def reroot_restype(

...)

reroot_restype( (ResidueType)restype, (object)graph, (object)root) -> None : core/chemical/icoor_support.hh:39

C++ signature : void reroot_restype(core::chemical::ResidueType {lvalue},boost::undirected_graph,void*)

def residue_selector_single_from_line(

...)

residue_selector_single_from_line( (str)line) -> ResidueSelectorSingle : ///////////////////////////////////////////////////////////////////////////////////// create a singe ResidueSelector from an input line.

C++ signature : boost::shared_ptr residue_selector_single_from_line(std::string)

def residue_type_all_patches_name(

...)

residue_type_all_patches_name( (ResidueType)rsd_type) -> str : helper function, returns the name of all added patches

C++ signature : std::string residue_type_all_patches_name(core::chemical::ResidueType)

def residue_type_base_name(

...)

residue_type_base_name( (ResidueType)rsd_type) -> str : helper function, returns the base residue name prior to any patching

C++ signature : std::string residue_type_base_name(core::chemical::ResidueType)

def retype_is_aromatic(

...)

retype_is_aromatic( (object)atom, (object)graph) -> bool : core/chemical/atomtype_support.hh:24

C++ signature : bool retype_is_aromatic(void*,boost::undirected_graph)

def rosetta_recharge_fullatom(

...)

rosetta_recharge_fullatom( (ResidueType)res) -> None : Apply molfile_to_params style partial charges to the ResidueType. These partial charges are based off of the Rosetta atom type, adjusted such that the net partial charge is equal to the net formal charge. These charges are almost certainly dodgy. If you have any other source of partial charges that are at all reasonable, you probably want to consider those instead. Assumes: * All atoms and bond are present. * All atom types have been set. * Formal charges (if any) have been set.

C++ signature : void rosetta_recharge_fullatom(core::chemical::ResidueType {lvalue})

def rosetta_retype_fullatom(

...)

rosetta_retype_fullatom( (ResidueType)restype [, (bool)preserve=False]) -> None : Reassign Rosetta atom types based on the current fullatom heuristics. If preserve is true, only retype those atoms which have an atom_type_index of zero.

C++ signature : void rosetta_retype_fullatom(core::chemical::ResidueType {lvalue} [,bool=False])

def rsd_set_from_cmd_line(

...)

rsd_set_from_cmd_line() -> ResidueTypeSetCAP : Return a constant access pointer to the ResidueTypeSet specified by the command-line options.

C++ signature : boost::weak_ptr rsd_set_from_cmd_line()

def setup_atom_type_reassignments_from_commandline(

...)

setup_atom_type_reassignments_from_commandline( (str)rsd_type_name, (str)rsd_type_set_name, (map_string_string)atom_type_reassignments) -> None : core/chemical/residue_io.hh:71

C++ signature : void setup_atom_type_reassignments_from_commandline(std::string,std::string,std::map, std::allocator > > {lvalue})

def setup_icoor_reassignments_from_commandline(

...)

setup_icoor_reassignments_from_commandline( (str)rsd_type_name, (str)rsd_type_set_name, (object)icoor_reassignments) -> None : core/chemical/residue_io.hh:79

C++ signature : void setup_icoor_reassignments_from_commandline(std::string,std::string,std::map >, std::less, std::allocator > > > > {lvalue})

def turn_off_hbonds_to_ester_oxygens(

...)

turn_off_hbonds_to_ester_oxygens( (AtomTypeSet)atom_type_set) -> None : core/chemical/util.hh:77

C++ signature : void turn_off_hbonds_to_ester_oxygens(core::chemical::AtomTypeSet {lvalue})

def variants_match(

...)

variants_match( (ResidueType)res1, (ResidueType)res2) -> bool : Are these two residues patched in exactly the same way?

C++ signature : bool variants_match(core::chemical::ResidueType,core::chemical::ResidueType)

def variants_match_with_exceptions(

...)

variants_match_with_exceptions( (ResidueType)res1, (ResidueType)res2, (object)list_of_variants_to_ignore) -> bool : Are these two residues patched in exactly the same way, ignoring any VariantTypes in the list of exceptions?

C++ signature : bool variants_match_with_exceptions(core::chemical::ResidueType,core::chemical::ResidueType,utility::vector1 >)

def write_topology_file(

...)

write_topology_file( (ResidueType)rsd [, (str)filename='']) -> None : writes a .params file from a given ResidueType object

C++ signature : void write_topology_file(core::chemical::ResidueType [,std::string=''])

Classes

class AA

//////////////////////////////////////////////////////////////////////// enumeration for amino acids and nucleotides types with the total number as num_aa_types ////////////////////////////////////////////////////////////////////////

Ancestors (in MRO)

  • AA
  • Boost.Python.enum
  • __builtin__.int
  • __builtin__.object

Class variables

var aa_ala

var aa_arg

var aa_asn

var aa_asp

var aa_b3a

var aa_b3c

var aa_b3cisACHC

var aa_b3cisACPC

var aa_b3cisACPrC

var aa_b3d

var aa_b3e

var aa_b3f

var aa_b3g

var aa_b3h

var aa_b3i

var aa_b3k

var aa_b3l

var aa_b3m

var aa_b3n

var aa_b3p

var aa_b3q

var aa_b3r

var aa_b3s

var aa_b3t

var aa_b3v

var aa_b3w

var aa_b3y

var aa_cys

var aa_dal

var aa_dan

var aa_dar

var aa_das

var aa_dcs

var aa_dgn

var aa_dgu

var aa_dhi

var aa_dil

var aa_dle

var aa_dly

var aa_dme

var aa_dph

var aa_dpr

var aa_dse

var aa_dth

var aa_dtr

var aa_dty

var aa_dva

var aa_gln

var aa_glu

var aa_gly

var aa_h2o

var aa_his

var aa_ile

var aa_leu

var aa_lys

var aa_met

var aa_phe

var aa_pro

var aa_ser

var aa_thr

var aa_trp

var aa_tyr

var aa_unk

var aa_unp

var aa_val

var aa_vrt

var denominator

var first_DNA_aa

var first_D_aa

var first_beta3_aa

var imag

var last_DNA_aa

var last_D_aa

var last_beta3_aa

var na_ade

var na_cyt

var na_gua

var na_rad

var na_rcy

var na_rgu

var na_thy

var na_ura

var name

var names

var num_aa_types

var num_canonical_aas

var numerator

var real

var values

class APolarHydrogenFilter

The filter responsible for all apolar hydrogens.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (APolarHydrogenFilter)) -> None : The filter responsible for all apolar hydrogens.

C++ signature :
    void __init__(_object*,core::chemical::APolarHydrogenFilter)

init( (object)arg1, (object)graph, (AtomTypeSetCAP)atom_types) -> None : core/chemical/ResidueGraphTypes.hh:304

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property> {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>)

class APolarHydrogenFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (APolarHydrogenFilterAP)arg1) -> APolarHydrogenFilter :

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

class APolarHydrogenFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (APolarHydrogenFilterCAP)arg1) -> APolarHydrogenFilter :

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

class AcceptorAtomFilter

///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for obtaining all acceptor atoms.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (AcceptorAtomFilter)) -> None : ///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for obtaining all acceptor atoms.

C++ signature :
    void __init__(_object*,core::chemical::AcceptorAtomFilter)

init( (object)arg1, (object)graph, (AtomTypeSetCAP)atom_types) -> None : core/chemical/ResidueGraphTypes.hh:192

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property> {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>)

class AcceptorAtomFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AcceptorAtomFilterAP)arg1) -> AcceptorAtomFilter :

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

class AcceptorAtomFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AcceptorAtomFilterCAP)arg1) -> AcceptorAtomFilter :

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

class AddAtom

core/chemical/PatchOperation.hh:305

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in, (str)atom_type_name_in, (str)mm_atom_type_name_in, (float)charge) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,std::string,std::string,double)

init( (object)arg1, (AddAtom)) -> None : core/chemical/PatchOperation.hh:305

C++ signature :
    void __init__(_object*,core::chemical::AddAtom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddAtom)arg1, (ResidueType)rsd) -> bool : add an atom

C++ signature :
    bool apply(core::chemical::AddAtom {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddAtom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddAtom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddAtomAP

Ancestors (in MRO)

  • AddAtomAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddAtomAP)arg1) -> AddAtom :

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

class AddAtomAlias

//////////////////////////////////////////////////////////////////////////// A patch operation for adding an atom alias to a ResidueType. See residue_io.cc for a description of atom aliases. @remarks Atom aliases were graciously added to Rosetta by Rocco Moretti. Labonte JWLabonte@jhu.edu

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)rosetta_atom_name_in, (str)alias_in) -> None : core/chemical/PatchOperation.hh:341

C++ signature :
    void __init__(_object*,std::string,std::string)

init( (object)arg1, (AddAtomAlias)) -> None : //////////////////////////////////////////////////////////////////////////// A patch operation for adding an atom alias to a ResidueType. See residue_io.cc for a description of atom aliases. @remarks Atom aliases were graciously added to Rosetta by Rocco Moretti. Labonte JWLabonte@jhu.edu

C++ signature :
    void __init__(_object*,core::chemical::AddAtomAlias)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddAtomAlias)arg1, (ResidueType)rsd) -> bool : Apply this patch to the given ResidueType.

C++ signature :
    bool apply(core::chemical::AddAtomAlias {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddAtomAlias)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddAtomAlias_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddAtomAliasAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddAtomAliasAP)arg1) -> AddAtomAlias :

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

class AddAtomAliasCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddAtomAliasCAP)arg1) -> AddAtomAlias :

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

class AddAtomCAP

Ancestors (in MRO)

  • AddAtomCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddAtomCAP)arg1) -> AddAtom :

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

class AddBond

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// add a bond to ResidueType

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom1_in, (str)atom2_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,std::string)

init( (object)arg1, (AddBond)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// add a bond to ResidueType

C++ signature :
    void __init__(_object*,core::chemical::AddBond)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddBond)arg1, (ResidueType)rsd) -> bool : add a bond

C++ signature :
    bool apply(core::chemical::AddBond {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddBond)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddBond_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddBondAP

Ancestors (in MRO)

  • AddBondAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddBondAP)arg1) -> AddBond :

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

class AddBondCAP

Ancestors (in MRO)

  • AddBondCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddBondCAP)arg1) -> AddBond :

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

class AddBondType

//////////////////////////////////////////////////////////////////////////// A patch operation for adding a specific type of bond to a ResidueType. See residue_io.cc for a description of bond types. Labonte JWLabonte@jhu.edu

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom1_in, (str)atom2_in, (str)bond_type_in) -> None : core/chemical/PatchOperation.hh:385

C++ signature :
    void __init__(_object*,std::string,std::string,std::string)

init( (object)arg1, (AddBondType)) -> None : //////////////////////////////////////////////////////////////////////////// A patch operation for adding a specific type of bond to a ResidueType. See residue_io.cc for a description of bond types. Labonte JWLabonte@jhu.edu

C++ signature :
    void __init__(_object*,core::chemical::AddBondType)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddBondType)arg1, (ResidueType)rsd) -> bool : Apply this patch to the given ResidueType.

C++ signature :
    bool apply(core::chemical::AddBondType {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddBondType)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddBondType_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddBondTypeAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddBondTypeAP)arg1) -> AddBondType :

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

class AddBondTypeCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddBondTypeCAP)arg1) -> AddBondType :

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

class AddChi

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Add a chi angle to ResidueType. Added by Andy M. Chen in June 2009 This is needed for PTMs, which often result in one or more extra chi angles.

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (int)chino_in, (str)atom1_in, (str)atom2_in, (str)atom3_in, (str)atom4_in) -> None : Constructor for when the chi index is specified.

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

init( (object)arg1, (AddChi)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Add a chi angle to ResidueType. Added by Andy M. Chen in June 2009 This is needed for PTMs, which often result in one or more extra chi angles.

C++ signature :
    void __init__(_object*,core::chemical::AddChi)

init( (object)arg1, (str)atom1_in, (str)atom2_in, (str)atom3_in, (str)atom4_in) -> None : Constructor for when the chi index is not specified.

C++ signature :
    void __init__(_object*,std::string,std::string,std::string,std::string)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddChi)arg1, (ResidueType)rsd) -> bool : Add a chi angle.

C++ signature :
    bool apply(core::chemical::AddChi {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddChi)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddChi_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddChiAP

Ancestors (in MRO)

  • AddChiAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddChiAP)arg1) -> AddChi :

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

class AddChiCAP

Ancestors (in MRO)

  • AddChiCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddChiCAP)arg1) -> AddChi :

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

class AddChiRotamer

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Add a rotamer sample to a chi angle of the ResidueType. Added by Andy M. Chen in June 2009 This is needed for PTMs.

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (int)chino_in, (float)mean_in, (float)sdev_in) -> None : Constructor for when the chi index is specified

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

init( (object)arg1, (AddChiRotamer)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Add a rotamer sample to a chi angle of the ResidueType. Added by Andy M. Chen in June 2009 This is needed for PTMs.

C++ signature :
    void __init__(_object*,core::chemical::AddChiRotamer)

init( (object)arg1, (float)mean_in, (float)sdev_in) -> None : Constructor for when the chi index is not specified

C++ signature :
    void __init__(_object*,double,double)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddChiRotamer)arg1, (ResidueType)rsd) -> bool : Add a rotamer sample.

C++ signature :
    bool apply(core::chemical::AddChiRotamer {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddChiRotamer)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddChiRotamer_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddChiRotamerAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddChiRotamerAP)arg1) -> AddChiRotamer :

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

class AddChiRotamerCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddChiRotamerCAP)arg1) -> AddChiRotamer :

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

class AddConnect

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)connect_atom, (float)phi, (float)theta, (float)d, (str)parent_atom, (str)angle_atom, (str)torsion_atom) -> None : core/chemical/PatchOperation.hh:108

C++ signature :
    void __init__(_object*,std::string,double,double,double,std::string,std::string,std::string)

init( (object)arg1, (AddConnect)) -> None : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

C++ signature :
    void __init__(_object*,core::chemical::AddConnect)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddConnect)arg1, (ResidueType)rsd) -> bool : add a property

C++ signature :
    bool apply(core::chemical::AddConnect {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddConnect)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddConnect_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddConnectAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddConnectAP)arg1) -> AddConnect :

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

class AddConnectCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddConnectCAP)arg1) -> AddConnect :

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

class AddProperty

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// add a property to ResidueType

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)property_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (AddProperty)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// add a property to ResidueType

C++ signature :
    void __init__(_object*,core::chemical::AddProperty)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddProperty)arg1, (ResidueType)rsd) -> bool : add a property

C++ signature :
    bool apply(core::chemical::AddProperty {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddProperty)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddProperty_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddPropertyAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddPropertyAP)arg1) -> AddProperty :

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

class AddPropertyCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddPropertyCAP)arg1) -> AddProperty :

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

class AddProtonChi

core/chemical/PatchOperation.hh:197

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (int)chino_in, (vector1_Real)samples, (vector1_Real)extrasamples) -> None : constructor

C++ signature :
    void __init__(_object*,unsigned long,utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >)

init( (object)arg1, (AddProtonChi)) -> None : core/chemical/PatchOperation.hh:197

C++ signature :
    void __init__(_object*,core::chemical::AddProtonChi)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AddProtonChi)arg1, (ResidueType)rsd) -> bool : add a proton chi angle

C++ signature :
    bool apply(core::chemical::AddProtonChi {lvalue},core::chemical::ResidueType {lvalue})

apply( (AddProtonChi)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AddProtonChi_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AddProtonChiAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddProtonChiAP)arg1) -> AddProtonChi :

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

class AddProtonChiCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AddProtonChiCAP)arg1) -> AddProtonChi :

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

class Adduct

Description of optional single-atom residue adducts

Ancestors (in MRO)

  • Adduct
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (Adduct)) -> None : Description of optional single-atom residue adducts

C++ signature :
    void __init__(_object*,core::chemical::Adduct)

init( (object)arg1, (str)adduct_name, (str)atom_name, (str)atom_type_name, (str)mm_atom_type_name, (float)atom_charge_in, (float)phi_in, (float)theta_in, (float)d_in, (str)stub_atom1_name, (str)stub_atom2_name, (str)stub_atom3_name) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,std::string,std::string,std::string,double,double,double,double,std::string,std::string,std::string)

def adduct_name(

...)

adduct_name( (Adduct)arg1) -> str : accessor to adduct_name string

C++ signature : std::string adduct_name(core::chemical::Adduct {lvalue})

def atom_charge(

...)

atom_charge( (Adduct)arg1) -> float : core/chemical/Adduct.hh:65

C++ signature : double atom_charge(core::chemical::Adduct {lvalue})

def atom_name(

...)

atom_name( (Adduct)arg1) -> str : accessor to atom_name string

C++ signature : std::string atom_name(core::chemical::Adduct {lvalue})

def atom_type_name(

...)

atom_type_name( (Adduct)arg1) -> str : accessor to atom type string

C++ signature : std::string atom_type_name(core::chemical::Adduct {lvalue})

def d(

...)

d( (Adduct)arg1) -> float : core/chemical/Adduct.hh:74

C++ signature : double d(core::chemical::Adduct {lvalue})

def mm_atom_type_name(

...)

mm_atom_type_name( (Adduct)arg1) -> str : accessor to mm type string

C++ signature : std::string mm_atom_type_name(core::chemical::Adduct {lvalue})

def phi(

...)

phi( (Adduct)arg1) -> float : accessor for Adduct geometric info

C++ signature : double phi(core::chemical::Adduct {lvalue})

def stub_atom(

...)

stub_atom( (Adduct)arg1, (int)atm) -> str : const accessor to stub_atom strings by index

C++ signature : std::string stub_atom(core::chemical::Adduct {lvalue},int)

def stub_atom1(

...)

stub_atom1( (Adduct)arg1) -> str : accessor to stub_atom1 name string

C++ signature : std::string stub_atom1(core::chemical::Adduct {lvalue})

def stub_atom2(

...)

stub_atom2( (Adduct)arg1) -> str : accessor to stub_atom2 name string

C++ signature : std::string stub_atom2(core::chemical::Adduct {lvalue})

def stub_atom3(

...)

stub_atom3( (Adduct)arg1) -> str : accessor to stub_atom3 name string

C++ signature : std::string stub_atom3(core::chemical::Adduct {lvalue})

def theta(

...)

theta( (Adduct)arg1) -> float : core/chemical/Adduct.hh:71

C++ signature : double theta(core::chemical::Adduct {lvalue})

class AdductAP

Ancestors (in MRO)

  • AdductAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AdductAP)arg1) -> Adduct :

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

class AdductCAP

Ancestors (in MRO)

  • AdductCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AdductCAP)arg1) -> Adduct :

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

class AppendInterchangeabilityGroup_String

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Append a string to the existing interchangeability_group string for a ResidueType

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)intgrp_addendum) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (AppendInterchangeabilityGroup_String)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Append a string to the existing interchangeability_group string for a ResidueType

C++ signature :
    void __init__(_object*,core::chemical::AppendInterchangeabilityGroup_String)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AppendInterchangeabilityGroup_String)arg1, (ResidueType)rsd) -> bool : core/chemical/PatchOperation.hh:503

C++ signature :
    bool apply(core::chemical::AppendInterchangeabilityGroup_String {lvalue},core::chemical::ResidueType {lvalue})

apply( (AppendInterchangeabilityGroup_String)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AppendInterchangeabilityGroup_String_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AppendInterchangeabilityGroup_StringAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AppendInterchangeabilityGroup_StringAP)arg1) -> AppendInterchangeabilityGroup_String :

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

class AppendInterchangeabilityGroup_StringCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AppendInterchangeabilityGroup_StringCAP)arg1) -> AppendInterchangeabilityGroup_String :

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

class AppendMainchainAtom

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// add a mainchain atom after the last mainchain atom

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (AppendMainchainAtom)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// add a mainchain atom after the last mainchain atom

C++ signature :
    void __init__(_object*,core::chemical::AppendMainchainAtom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (AppendMainchainAtom)arg1, (ResidueType)rsd) -> bool : set an atom to be the last mainchain atom

C++ signature :
    bool apply(core::chemical::AppendMainchainAtom {lvalue},core::chemical::ResidueType {lvalue})

apply( (AppendMainchainAtom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(AppendMainchainAtom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class AppendMainchainAtomAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AppendMainchainAtomAP)arg1) -> AppendMainchainAtom :

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

class AppendMainchainAtomCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AppendMainchainAtomCAP)arg1) -> AppendMainchainAtom :

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

class AromaticAtomFilter

///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for all aromatic atoms.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (AromaticAtomFilter)) -> None : ///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for all aromatic atoms.

C++ signature :
    void __init__(_object*,core::chemical::AromaticAtomFilter)

init( (object)arg1, (object)graph, (AtomTypeSetCAP)atom_types) -> None : core/chemical/ResidueGraphTypes.hh:270

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property> {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>)

class AromaticAtomFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AromaticAtomFilterAP)arg1) -> AromaticAtomFilter :

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

class AromaticAtomFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AromaticAtomFilterCAP)arg1) -> AromaticAtomFilter :

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

class Atom

This class contains the "chemical" information for atoms. This does not contain the actual xyz coordinates of the atom, (which are found in core/conformation/Atom.hh). The atom_type properties are assigned by the class AtomSet, which is initiated from the ChemicalManager. AtomType properties are currently read in from the file chemical/atom_type_sets/fa_standard/atom_properties.txt. These properties contain the the properties of LJ_RADIUS, LJ_WDEPTH, LK_DGRFREE, LK_LAMBDA, and LK_VOLUME and are used in the scoring methods fa_atr, fa_rep, and fa_sol, which are located in the Etable (core/scoring/etable/Etable.hh). Additional parameters are acceptor/donor, hybridization, and orbital paramaters. This class should not have information associated with the Conformation or ResidueType; it represents an atom divorced from a particular conformation or residue but not from things that affect it chemically. It is distinct from an Element, in that it can have a particular hybridization state, charge, etc. It is distinct from conformation::Atom in that it does not have coordinates. Everything stored here should be concerning the atom. Conformation information goes in core::conformation, while data for ResidueType is cached there. chemical::Atoms are stored in chemical::ResidueType (within its ResidueGraph); conformation::Atoms are stored in conformation::Residue

Ancestors (in MRO)

  • Atom
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (str)name_in, (str)mm_name, (int)mm_atom_type_index, (Element)element, (float)charge, (xyzVector_Real)ideal_xyz) -> None : Construct a new atom with the name, mm type, element, charge and position.

C++ signature :
    void __init__(_object*,std::string,std::string,unsigned long,boost::shared_ptr<core::chemical::Element const>,double,numeric::xyzVector<double>)

init( (object)arg1, (Atom)src) -> None : core/chemical/Atom.hh:79

C++ signature :
    void __init__(_object*,core::chemical::Atom)

def assign(

...)

assign( (Atom)arg1, (Atom)atom) -> Atom : core/chemical/Atom.hh:107

C++ signature : core::chemical::Atom {lvalue} assign(core::chemical::Atom {lvalue},core::chemical::Atom)

def atom_type_index(

...)

atom_type_index( (Atom)arg1) -> int : core/chemical/Atom.hh:113

C++ signature :
    unsigned long atom_type_index(core::chemical::Atom {lvalue})

atom_type_index( (Atom)arg1, (int)atom_type_index) -> None : You probably don't want to use this directly. Use ResidueType::set_atom_type() which correctly updates the internal state of the residuetype/atom

C++ signature :
    void atom_type_index(core::chemical::Atom {lvalue},unsigned long)

def bonded_orbitals(

...)

bonded_orbitals( (Atom)arg1) -> vector1_Size : core/chemical/Atom.hh:120

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > bonded_orbitals(core::chemical::Atom {lvalue})

bonded_orbitals( (Atom)arg1) -> vector1_Size : core/chemical/Atom.hh:121

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > {lvalue} bonded_orbitals(core::chemical::Atom {lvalue})

def charge(

...)

charge( (Atom)arg1) -> float : core/chemical/Atom.hh:118

C++ signature :
    double charge(core::chemical::Atom {lvalue})

charge( (Atom)arg1, (float)charge) -> None : core/chemical/Atom.hh:143

C++ signature :
    void charge(core::chemical::Atom {lvalue},double)

def element_type(

...)

element_type( (Atom)arg1) -> Element : core/chemical/Atom.hh:115

C++ signature :
    boost::shared_ptr<core::chemical::Element const> element_type(core::chemical::Atom {lvalue})

element_type( (Atom)arg1, (Element)element) -> None : core/chemical/Atom.hh:140

C++ signature :
    void element_type(core::chemical::Atom {lvalue},boost::shared_ptr<core::chemical::Element const>)

def formal_charge(

...)

formal_charge( (Atom)arg1) -> int : core/chemical/Atom.hh:117

C++ signature :
    int formal_charge(core::chemical::Atom {lvalue})

formal_charge( (Atom)arg1, (int)charge) -> None : core/chemical/Atom.hh:142

C++ signature :
    void formal_charge(core::chemical::Atom {lvalue},int)

def gasteiger_atom_type(

...)

gasteiger_atom_type( (Atom)arg1) -> object : core/chemical/Atom.hh:116

C++ signature :
    boost::shared_ptr<core::chemical::gasteiger::GasteigerAtomTypeData const> gasteiger_atom_type(core::chemical::Atom {lvalue})

gasteiger_atom_type( (Atom)arg1, (object)gasteiger_atom_type) -> None : core/chemical/Atom.hh:141

C++ signature :
    void gasteiger_atom_type(core::chemical::Atom {lvalue},boost::shared_ptr<core::chemical::gasteiger::GasteigerAtomTypeData const>)

def has_orbitals(

...)

has_orbitals( (Atom)arg1) -> bool : core/chemical/Atom.hh:128

C++ signature :
    bool has_orbitals(core::chemical::Atom {lvalue})

has_orbitals( (Atom)arg1, (bool)orbitals) -> None : core/chemical/Atom.hh:151

C++ signature :
    void has_orbitals(core::chemical::Atom {lvalue},bool)

def heavyatom_has_polar_hydrogens(

...)

heavyatom_has_polar_hydrogens( (Atom)arg1) -> bool : core/chemical/Atom.hh:122

C++ signature :
    bool heavyatom_has_polar_hydrogens(core::chemical::Atom {lvalue})

heavyatom_has_polar_hydrogens( (Atom)arg1, (bool)heavyatom_has_polar_hydrogens) -> None : core/chemical/Atom.hh:145

C++ signature :
    void heavyatom_has_polar_hydrogens(core::chemical::Atom {lvalue},bool)

def ideal_xyz(

...)

ideal_xyz( (Atom)arg1) -> xyzVector_Real : core/chemical/Atom.hh:119

C++ signature :
    numeric::xyzVector<double> ideal_xyz(core::chemical::Atom {lvalue})

ideal_xyz( (Atom)arg1, (xyzVector_Real)ideal_xyz) -> None : core/chemical/Atom.hh:144

C++ signature :
    void ideal_xyz(core::chemical::Atom {lvalue},numeric::xyzVector<double>)

def is_acceptor(

...)

is_acceptor( (Atom)arg1) -> bool : core/chemical/Atom.hh:123

C++ signature :
    bool is_acceptor(core::chemical::Atom {lvalue})

is_acceptor( (Atom)arg1, (bool)acceptor) -> None : core/chemical/Atom.hh:149

C++ signature :
    void is_acceptor(core::chemical::Atom {lvalue},bool)

def is_fake(

...)

is_fake( (Atom)arg1) -> bool : Return true if this represents a fake/mock atom.

C++ signature : bool is_fake(core::chemical::Atom {lvalue})

def is_haro(

...)

is_haro( (Atom)arg1) -> bool : core/chemical/Atom.hh:126

C++ signature :
    bool is_haro(core::chemical::Atom {lvalue})

is_haro( (Atom)arg1, (bool)haro) -> None : core/chemical/Atom.hh:148

C++ signature :
    void is_haro(core::chemical::Atom {lvalue},bool)

def is_hydrogen(

...)

is_hydrogen( (Atom)arg1) -> bool : core/chemical/Atom.hh:125

C++ signature :
    bool is_hydrogen(core::chemical::Atom {lvalue})

is_hydrogen( (Atom)arg1, (bool)hydrogen) -> None : core/chemical/Atom.hh:147

C++ signature :
    void is_hydrogen(core::chemical::Atom {lvalue},bool)

def is_polar_hydrogen(

...)

is_polar_hydrogen( (Atom)arg1) -> bool : core/chemical/Atom.hh:124

C++ signature :
    bool is_polar_hydrogen(core::chemical::Atom {lvalue})

is_polar_hydrogen( (Atom)arg1, (bool)polar) -> None : core/chemical/Atom.hh:146

C++ signature :
    void is_polar_hydrogen(core::chemical::Atom {lvalue},bool)

def is_virtual(

...)

is_virtual( (Atom)arg1) -> bool : core/chemical/Atom.hh:127

C++ signature :
    bool is_virtual(core::chemical::Atom {lvalue})

is_virtual( (Atom)arg1, (bool)is_virtual) -> None : core/chemical/Atom.hh:150

C++ signature :
    void is_virtual(core::chemical::Atom {lvalue},bool)

def mm_atom_type_index(

...)

mm_atom_type_index( (Atom)arg1) -> int : core/chemical/Atom.hh:114

C++ signature :
    unsigned long mm_atom_type_index(core::chemical::Atom {lvalue})

mm_atom_type_index( (Atom)arg1, (int)mm_atom_type_index) -> None : core/chemical/Atom.hh:139

C++ signature :
    void mm_atom_type_index(core::chemical::Atom {lvalue},unsigned long)

def mm_name(

...)

mm_name( (Atom)arg1) -> str : core/chemical/Atom.hh:112

C++ signature :
    std::string mm_name(core::chemical::Atom {lvalue})

mm_name( (Atom)arg1, (str)name) -> None : core/chemical/Atom.hh:133

C++ signature :
    void mm_name(core::chemical::Atom {lvalue},std::string)

def name(

...)

name( (Atom)arg1) -> str : core/chemical/Atom.hh:110

C++ signature :
    std::string name(core::chemical::Atom {lvalue})

name( (Atom)arg1, (str)name) -> None : core/chemical/Atom.hh:132

C++ signature :
    void name(core::chemical::Atom {lvalue},std::string)

def show(

...)

show( (Atom)arg1, (OStream)out) -> None : Generate string representation of chemical::Atom for debugging purposes.

C++ signature : void show(core::chemical::Atom {lvalue},std::ostream {lvalue})

class AtomAP

Ancestors (in MRO)

  • AtomAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomAP)arg1) -> Atom :

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

class AtomCAP

Ancestors (in MRO)

  • AtomCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomCAP)arg1) -> Atom :

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

class AtomICoor

A basic class containing info of internal coordinates needed for building an atom within a ResidueType

Ancestors (in MRO)

  • AtomICoor
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (AtomICoor)) -> None : A basic class containing info of internal coordinates needed for building an atom within a ResidueType

C++ signature :
    void __init__(_object*,core::chemical::AtomICoor)

init( (object)arg1, (str)built_atom_name, (float)phi_in, (float)theta_in, (float)d_in, (str)stub_atom1_name, (str)stub_atom2_name, (str)stub_atom3_name, (ResidueType)rsd_type) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,double,double,double,std::string,std::string,std::string,core::chemical::ResidueType)

init( (object)arg1, (object)built_atom_vd, (float)phi_in, (float)theta_in, (float)d_in, (object)stub_atom1_vd, (object)stub_atom2_vd, (object)stub_atom3_vd, (ResidueType)rsd_type) -> None : Vertex descriptor version

C++ signature :
    void __init__(_object*,void*,double,double,double,void*,void*,void*,core::chemical::ResidueType)

def build(

...)

build( (AtomICoor)arg1, (Residue)rsd, (Conformation)conformation) -> xyzVector_Real : core/chemical/AtomICoor.hh:360

C++ signature :
    numeric::xyzVector<double> build(core::chemical::AtomICoor {lvalue},core::conformation::Residue,core::conformation::Conformation)

build( (AtomICoor)arg1, (ResidueType)rsd_type) -> xyzVector_Real : core/chemical/AtomICoor.hh:365

C++ signature :
    numeric::xyzVector<double> build(core::chemical::AtomICoor {lvalue},core::chemical::ResidueType)

build( (AtomICoor)arg1, (Residue)rsd) -> xyzVector_Real : WARNING: Slightly dangerous function intended for black magic use only. Rebuilds atom location from stub atoms. If stub atom are not internal atoms, their location will be rebuilt from their residue stub atom's locations, as opposed to being retrieved from connected residues via a conformation.

C++ signature :
    numeric::xyzVector<double> build(core::chemical::AtomICoor {lvalue},core::conformation::Residue)

def built_atom_vertex(

...)

built_atom_vertex( (AtomICoor)arg1, (object)vd) -> None : core/chemical/AtomICoor.hh:340

C++ signature :
    void built_atom_vertex(core::chemical::AtomICoor {lvalue},void*)

built_atom_vertex( (AtomICoor)arg1) -> object : The vertex descriptor of the atom being built by this icoor Can be null_vertex if this AtomICoor doesn't build a physical atom. (e.g. CONNECT, UPPER, LOWER)

C++ signature :
    void* built_atom_vertex(core::chemical::AtomICoor {lvalue})

def d(

...)

d( (AtomICoor)arg1) -> float : core/chemical/AtomICoor.hh:246

C++ signature : double d(core::chemical::AtomICoor {lvalue})

def depends_on_polymer_lower(

...)

depends_on_polymer_lower( (AtomICoor)arg1) -> bool : core/chemical/AtomICoor.hh:281

C++ signature : bool depends_on_polymer_lower(core::chemical::AtomICoor {lvalue})

def depends_on_polymer_upper(

...)

depends_on_polymer_upper( (AtomICoor)arg1) -> bool : core/chemical/AtomICoor.hh:288

C++ signature : bool depends_on_polymer_upper(core::chemical::AtomICoor {lvalue})

def depends_on_residue_connection(

...)

depends_on_residue_connection( (AtomICoor)arg1, (int)connid) -> bool : Returns true if any of the stub atoms is the specified connection ID.

C++ signature :
    bool depends_on_residue_connection(core::chemical::AtomICoor {lvalue},unsigned long)

depends_on_residue_connection( (AtomICoor)arg1) -> bool : Returns true if any of the stub atoms is a connection ID. Vikram K. Mulligan (vmullig@uw.edu)

C++ signature :
    bool depends_on_residue_connection(core::chemical::AtomICoor {lvalue})

def is_internal(

...)

is_internal( (AtomICoor)arg1) -> bool : core/chemical/AtomICoor.hh:274

C++ signature : bool is_internal(core::chemical::AtomICoor {lvalue})

def phi(

...)

phi( (AtomICoor)arg1) -> float : accessor to stub_atom1 ICoorAtomID

C++ signature : double phi(core::chemical::AtomICoor {lvalue})

def stub_atom(

...)

stub_atom( (AtomICoor)arg1, (int)atm) -> ICoorAtomID : accessor to stub_atom ICoorAtomID

C++ signature :
    core::chemical::ICoorAtomID {lvalue} stub_atom(core::chemical::AtomICoor {lvalue},int)

stub_atom( (AtomICoor)arg1, (int)atm) -> ICoorAtomID : constant accessor to stub_atom ICoorAtomID

C++ signature :
    core::chemical::ICoorAtomID stub_atom(core::chemical::AtomICoor {lvalue},int)

def stub_atom1(

...)

stub_atom1( (AtomICoor)arg1) -> ICoorAtomID : core/chemical/AtomICoor.hh:253

C++ signature : core::chemical::ICoorAtomID stub_atom1(core::chemical::AtomICoor {lvalue})

def stub_atom2(

...)

stub_atom2( (AtomICoor)arg1) -> ICoorAtomID : accessor to stub_atom2 ICoorAtomID

C++ signature : core::chemical::ICoorAtomID stub_atom2(core::chemical::AtomICoor {lvalue})

def stub_atom3(

...)

stub_atom3( (AtomICoor)arg1) -> ICoorAtomID : accessor to stub_atom3 ICoorAtomID

C++ signature : core::chemical::ICoorAtomID stub_atom3(core::chemical::AtomICoor {lvalue})

def theta(

...)

theta( (AtomICoor)arg1) -> float : core/chemical/AtomICoor.hh:239

C++ signature : double theta(core::chemical::AtomICoor {lvalue})

class AtomICoorAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomICoorAP)arg1) -> AtomICoor :

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

class AtomICoorCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomICoorCAP)arg1) -> AtomICoor :

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

class AtomType

basic atom type name, element, certain properties and parameters

Ancestors (in MRO)

  • AtomType
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1, (str)name_in, (str)element_in) -> None : Construct a new atom type with its name and element. All its properties are unset by default.

C++ signature :
    void __init__(_object*,std::string,std::string)

init( (object)arg1, (AtomType)src) -> None : core/chemical/AtomType.hh:79

C++ signature :
    void __init__(_object*,core::chemical::AtomType)

def add_property(

...)

add_property( (AtomType)arg1, (str)property) -> None : set standard property to true, or set the specified hybridization

C++ signature : void add_property(core::chemical::AtomType {lvalue},std::string)

def atom_has_orbital(

...)

atom_has_orbital( (AtomType)arg1) -> bool : atom has an orbital attached

C++ signature : bool atom_has_orbital(core::chemical::AtomType {lvalue})

def atom_type_name(

...)

atom_type_name( (AtomType)arg1) -> str : core/chemical/AtomType.hh:254

C++ signature : std::string atom_type_name(core::chemical::AtomType {lvalue})

def clear_properties(

...)

clear_properties( (AtomType)arg1) -> None : set all standard properties to false, set hybridization to UNKNOWN_HYBRID, and clear extra properties

C++ signature : void clear_properties(core::chemical::AtomType {lvalue})

def element(

...)

element( (AtomType)arg1) -> str : returns the one- or two-letter element type

C++ signature : std::string element(core::chemical::AtomType {lvalue})

def extra_parameter(

...)

extra_parameter( (AtomType)arg1, (int)index) -> float : return an additional, non-hardcoded property

C++ signature : double extra_parameter(core::chemical::AtomType {lvalue},unsigned long)

def get_all_properties(

...)

get_all_properties( (AtomType)arg1) -> vector1_string : core/chemical/AtomType.hh:244

C++ signature : utility::vector1 > get_all_properties(core::chemical::AtomType {lvalue})

def hybridization(

...)

hybridization( (AtomType)arg1) -> Hybridization : retrieve an atom's hybridization status.

C++ signature : core::chemical::Hybridization hybridization(core::chemical::AtomType {lvalue})

def is_acceptor(

...)

is_acceptor( (AtomType)arg1) -> bool : whether atom is a hydrogen bond acceptor

C++ signature : bool is_acceptor(core::chemical::AtomType {lvalue})

def is_aromatic(

...)

is_aromatic( (AtomType)arg1) -> bool : whether atom is aromatic

C++ signature : bool is_aromatic(core::chemical::AtomType {lvalue})

def is_donor(

...)

is_donor( (AtomType)arg1) -> bool : whether atom is a hydrogen bond donor

C++ signature : bool is_donor(core::chemical::AtomType {lvalue})

def is_h2o(

...)

is_h2o( (AtomType)arg1) -> bool : whether atom is a water

C++ signature : bool is_h2o(core::chemical::AtomType {lvalue})

def is_haro(

...)

is_haro( (AtomType)arg1) -> bool : is the H atom aromatic?

C++ signature : bool is_haro(core::chemical::AtomType {lvalue})

def is_heavyatom(

...)

is_heavyatom( (AtomType)arg1) -> bool : whether atom is a heavy atom

C++ signature : bool is_heavyatom(core::chemical::AtomType {lvalue})

def is_hydrogen(

...)

is_hydrogen( (AtomType)arg1) -> bool : whether atom is a hydrogen atom

C++ signature : bool is_hydrogen(core::chemical::AtomType {lvalue})

def is_polar_hydrogen(

...)

is_polar_hydrogen( (AtomType)arg1) -> bool : whether atom is a polar hydrogen atom

C++ signature : bool is_polar_hydrogen(core::chemical::AtomType {lvalue})

def is_virtual(

...)

is_virtual( (AtomType)arg1) -> bool : is atom type virtual?

C++ signature : bool is_virtual(core::chemical::AtomType {lvalue})

def lj_radius(

...)

lj_radius( (AtomType)arg1) -> float : Lennard-Jones 6-12 potential parameter -- atom radius

C++ signature : double lj_radius(core::chemical::AtomType {lvalue})

def lj_wdepth(

...)

lj_wdepth( (AtomType)arg1) -> float : Lennard-Jones 6-12 potential parameter -- well depth

C++ signature : double lj_wdepth(core::chemical::AtomType {lvalue})

def lk_dgfree(

...)

lk_dgfree( (AtomType)arg1) -> float : Lazaridis and Karplus solvation parameter -- dgfree

C++ signature : double lk_dgfree(core::chemical::AtomType {lvalue})

def lk_lambda(

...)

lk_lambda( (AtomType)arg1) -> float : Lazaridis and Karplus solvation parameter -- lambda

C++ signature : double lk_lambda(core::chemical::AtomType {lvalue})

def lk_volume(

...)

lk_volume( (AtomType)arg1) -> float : Lazaridis and Karplus solvation parameter -- volume

C++ signature : double lk_volume(core::chemical::AtomType {lvalue})

def name(

...)

name( (AtomType)arg1, (str)setting) -> None : core/chemical/AtomType.hh:280

C++ signature :
    void name(core::chemical::AtomType {lvalue},std::string)

name( (AtomType)arg1) -> str : core/chemical/AtomType.hh:285

C++ signature :
    std::string name(core::chemical::AtomType {lvalue})

def print(

...)

print( (AtomType)arg1, (OStream)out) -> None : core/chemical/AtomType.hh:99

C++ signature : void print(core::chemical::AtomType {lvalue},std::ostream {lvalue})

def set_all_extra_parameters(

...)

set_all_extra_parameters( (AtomType)arg1, (vector1_Real)extra_parameters) -> None : @set all the extra parameters at once

C++ signature : void set_all_extra_parameters(core::chemical::AtomType {lvalue},utility::vector1 >)

def set_extra_parameter(

...)

set_extra_parameter( (AtomType)arg1, (int)index, (float)setting) -> None : return an additional, non-hardcoded property

C++ signature : void set_extra_parameter(core::chemical::AtomType {lvalue},unsigned long,double)

def set_parameter(

...)

set_parameter( (AtomType)arg1, (str)param, (float)setting) -> None : set LJ and LK solvation parameter for this atom type

C++ signature : void set_parameter(core::chemical::AtomType {lvalue},std::string,double)

def set_property(

...)

set_property( (AtomType)arg1, (str)property, (bool)setting) -> None : set relevant properties for this atom type hh

C++ signature : void set_property(core::chemical::AtomType {lvalue},std::string,bool)

class AtomTypeAP

Ancestors (in MRO)

  • AtomTypeAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomTypeAP)arg1) -> AtomType :

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

class AtomTypeCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomTypeCAP)arg1) -> AtomType :

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

class AtomTypeDatabaseIO

core/chemical/AtomTypeDatabaseIO.hh:29

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (AtomTypeDatabaseIO)) -> None : core/chemical/AtomTypeDatabaseIO.hh:29

C++ signature :
    void __init__(_object*,core::chemical::AtomTypeDatabaseIO)

def get_all_atom_types_in_database(

...)

get_all_atom_types_in_database( (AtomTypeDatabaseIO)arg1, (object)db_session) -> vector1_string : core/chemical/AtomTypeDatabaseIO.hh:74

C++ signature : utility::vector1 > get_all_atom_types_in_database(core::chemical::AtomTypeDatabaseIO {lvalue},boost::shared_ptr)

def initialize(

...)

initialize( (AtomTypeDatabaseIO)arg1, (object)db_session) -> None : write the schema

C++ signature : void initialize(core::chemical::AtomTypeDatabaseIO {lvalue},boost::shared_ptr)

def write_atom_type_set_to_database(

...)

write_atom_type_set_to_database( (AtomTypeDatabaseIO)arg1, (AtomTypeSet)atom_type_set, (object)db_session) -> None : core/chemical/AtomTypeDatabaseIO.hh:70

C++ signature : void write_atom_type_set_to_database(core::chemical::AtomTypeDatabaseIO {lvalue},core::chemical::AtomTypeSet,boost::shared_ptr)

def write_schema_to_db(

...)

write_schema_to_db( (AtomTypeDatabaseIO)arg1, (object)db_session) -> None : generate the table schemas and write them to the database

C++ signature : void write_schema_to_db(core::chemical::AtomTypeDatabaseIO {lvalue},boost::shared_ptr)

class AtomTypeDatabaseIOAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomTypeDatabaseIOAP)arg1) -> AtomTypeDatabaseIO :

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

class AtomTypeDatabaseIOCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomTypeDatabaseIOCAP)arg1) -> AtomTypeDatabaseIO :

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

class AtomTypeSet

a set of AtomTypes a vector of pointers each of which points to an AtomType and the vector index is looked up by an atom_name string in a map

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1, (str)directory) -> None : c-tor from directory in the rosetta_database This will go through the directory, usually "$ROSETTA3_DB/chemical/atom_type_sets/" and initialize all the atom types defined in atom_properties.txt and the extra parameters specified in extras.txt

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (AtomTypeSet)) -> None : a set of AtomTypes a vector of pointers each of which points to an AtomType and the vector index is looked up by an atom_name string in a map

C++ signature :
    void __init__(_object*,core::chemical::AtomTypeSet)

init( (object)arg1, (str)name, (object)db_session) -> None : core/chemical/AtomTypeSet.hh:70

C++ signature :
    void __init__(_object*,std::string,boost::shared_ptr<utility::sql_database::session>)

def add_parameters_from_file(

...)

add_parameters_from_file( (AtomTypeSet)arg1, (str)filename) -> None : additional file I/O

C++ signature : void add_parameters_from_file(core::chemical::AtomTypeSet {lvalue},std::string)

def atom_type_index(

...)

atom_type_index( (AtomTypeSet)arg1, (str)atom_type_name) -> int : lookup the atom_type by the atom_type_name string

C++ signature : int atom_type_index(core::chemical::AtomTypeSet {lvalue},std::string)

def directory(

...)

directory( (AtomTypeSet)arg1) -> str : Get the source directory, eg to open an additional file in that directory

C++ signature : std::string directory(core::chemical::AtomTypeSet {lvalue})

def extra_parameter_index(

...)

extra_parameter_index( (AtomTypeSet)arg1, (str)name) -> int : SLOW

C++ signature : int extra_parameter_index(core::chemical::AtomTypeSet {lvalue},std::string)

def extra_parameter_indices(

...)

extra_parameter_indices( (AtomTypeSet)arg1) -> map_string_int : core/chemical/AtomTypeSet.hh:137

C++ signature : std::map, std::allocator > > extra_parameter_indices(core::chemical::AtomTypeSet {lvalue})

def has_atom(

...)

has_atom( (AtomTypeSet)arg1, (str)atom_type_name) -> bool : Check if atom is present

C++ signature : bool has_atom(core::chemical::AtomTypeSet {lvalue},std::string)

def has_extra_parameter(

...)

has_extra_parameter( (AtomTypeSet)arg1, (str)name) -> bool : core/chemical/AtomTypeSet.hh:142

C++ signature : bool has_extra_parameter(core::chemical::AtomTypeSet {lvalue},std::string)

def n_atomtypes(

...)

n_atomtypes( (AtomTypeSet)arg1) -> int : number of atom types in the set

C++ signature : unsigned long n_atomtypes(core::chemical::AtomTypeSet {lvalue})

def name(

...)

name( (AtomTypeSet)arg1) -> str : the name of the AtomTypeSet

C++ signature : std::string name(core::chemical::AtomTypeSet {lvalue})

def read_file(

...)

read_file( (AtomTypeSet)arg1, (str)filename) -> None : file I/O

C++ signature : void read_file(core::chemical::AtomTypeSet {lvalue},std::string)

class AtomTypeSetAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomTypeSetAP)arg1) -> AtomTypeSet :

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

class AtomTypeSetCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AtomTypeSetCAP)arg1) -> AtomTypeSet :

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

class AutomorphismIterator

Enumerates the automorphisms of a residue, which are basically chemical symmetries that affect RMSD calculations. Common automorphisms include flipping a phenyl ring (think Phe chi2) or rotating a methyl group (or CF3, if you don't care about H). However, they can be much more complicated than that, and some cannot be imitated by rotation about a bond. Examples include labeling a -CF3 clockwise vs. counterclockwise, or swapping the -CF3 branches of -C(CF3)2R. See the ligand of PDB 1PQC for a reasonably complex example. Formally, a graph automorphism is an isomorphism of that graph with itself: given a graph G(V,E) and a mapping M that relabels the vertices according to M(v) -> v', then M is an automorphism iff (M(u),M(v)) is an edge if and only if (u,v) is an edge. If the vertices are "colored" (in our case, have atom types), it must also be true that M(v) and v have the same color, for all v in V. Thus you can re-label a phenyl ring 2 3 6 5 6 3 1 4 or 1 4 but not 1 4 6 5 2 3 2 5 because in the last case, there are new bonds 6-3 and 2-5, and missing bonds 6-5 and 2-3. See also: OpenEye's OEChem library and its OERMSD() function.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1, (ResidueType)restype [, (bool)includeH=False]) -> None : Including H will lead to many, many more automorphisms!

C++ signature :
    void __init__(_object*,core::chemical::ResidueType [,bool=False])

init( (object)arg1, (AutomorphismIterator)) -> None : Enumerates the automorphisms of a residue, which are basically chemical symmetries that affect RMSD calculations. Common automorphisms include flipping a phenyl ring (think Phe chi2) or rotating a methyl group (or CF3, if you don't care about H). However, they can be much more complicated than that, and some cannot be imitated by rotation about a bond. Examples include labeling a -CF3 clockwise vs. counterclockwise, or swapping the -CF3 branches of -C(CF3)2R. See the ligand of PDB 1PQC for a reasonably complex example. Formally, a graph automorphism is an isomorphism of that graph with itself: given a graph G(V,E) and a mapping M that relabels the vertices according to M(v) -> v', then M is an automorphism iff (M(u),M(v)) is an edge if and only if (u,v) is an edge. If the vertices are "colored" (in our case, have atom types), it must also be true that M(v) and v have the same color, for all v in V. Thus you can re-label a phenyl ring 2 3 6 5 6 3 1 4 or 1 4 but not 1 4 6 5 2 3 2 5 because in the last case, there are new bonds 6-3 and 2-5, and missing bonds 6-5 and 2-3. See also: OpenEye's OEChem library and its OERMSD() function.

C++ signature :
    void __init__(_object*,core::chemical::AutomorphismIterator)

init( (object)arg1, (ResidueType)restype, (ResidueType)restype2 [, (bool)includeH=False]) -> None : The mapping returned will be from restype to restype2 Including H will lead to many, many more automorphisms!

C++ signature :
    void __init__(_object*,core::chemical::ResidueType,core::chemical::ResidueType [,bool=False])

def next(

...)

next( (AutomorphismIterator)arg1) -> vector1_Size : Returns the next automorphism for this residue type as a vector that maps "old" atom indices to "new" atom indices. Returns an empty vector when no more automorphisms remain.

C++ signature : utility::vector1 > next(core::chemical::AutomorphismIterator {lvalue})

class AutomorphismIteratorAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AutomorphismIteratorAP)arg1) -> AutomorphismIterator :

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

class AutomorphismIteratorCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (AutomorphismIteratorCAP)arg1) -> AutomorphismIterator :

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

class Bond

basic chemical Bond name, element, certain properties and parameters from .params file

Ancestors (in MRO)

  • Bond
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (Bond)) -> None : basic chemical Bond name, element, certain properties and parameters from .params file

C++ signature :
    void __init__(_object*,core::chemical::Bond)

init( (object)arg1, (float)d, (BondName)name [, (bool)cut_bond=False]) -> None : core/chemical/Bond.hh:44

C++ signature :
    void __init__(_object*,double,core::chemical::BondName [,bool=False])

init( (object)arg1, (float)d, (BondOrder)order, (BondConjugability)conj, (BondAromaticity)aroma [, (BondRingness)ring=rosetta.core.chemical.core_chemical.BondRingness.UnknownRingness [, (BondIsometry)isom=rosetta.core.chemical.core_chemical.BondIsometry.UnknownIsometry [, (bool)cut_bond=False]]]) -> None : core/chemical/Bond.hh:45

C++ signature :
    void __init__(_object*,double,core::chemical::BondOrder,core::chemical::BondConjugability,core::chemical::BondAromaticity [,core::chemical::BondRingness=rosetta.core.chemical._core_chemical_.BondRingness.UnknownRingness [,core::chemical::BondIsometry=rosetta.core.chemical._core_chemical_.BondIsometry.UnknownIsometry [,bool=False]]])

def GetMaximumElectrons(

...)

GetMaximumElectrons( (Bond)arg1) -> int : core/chemical/Bond.hh:113

C++ signature : unsigned long GetMaximumElectrons(core::chemical::Bond {lvalue})

def GetMinimumElectrons(

...)

GetMinimumElectrons( (Bond)arg1) -> int : core/chemical/Bond.hh:112

C++ signature : unsigned long GetMinimumElectrons(core::chemical::Bond {lvalue})

def GetNumberOfElectrons(

...)

GetNumberOfElectrons( (Bond)arg1) -> int : core/chemical/Bond.hh:111

C++ signature : unsigned long GetNumberOfElectrons(core::chemical::Bond {lvalue})

def GetSDAltFileID(

...)

GetSDAltFileID( (Bond)arg1) -> int : core/chemical/Bond.hh:120

C++ signature : unsigned long GetSDAltFileID(core::chemical::Bond {lvalue})

def GetSDFileID(

...)

GetSDFileID( (Bond)arg1) -> int : core/chemical/Bond.hh:119

C++ signature : unsigned long GetSDFileID(core::chemical::Bond {lvalue})

def IsBondInRing(

...)

IsBondInRing( (Bond)arg1) -> bool : core/chemical/Bond.hh:117

C++ signature : bool IsBondInRing(core::chemical::Bond {lvalue})

def IsBondOrderKnown(

...)

IsBondOrderKnown( (Bond)arg1) -> bool : core/chemical/Bond.hh:115

C++ signature : bool IsBondOrderKnown(core::chemical::Bond {lvalue})

def SetSDFType(

...)

SetSDFType( (Bond)arg1, (int)SDF_ID) -> None : Reset the internal data such that it matches the appropriate value for the SDF datatype. Substitution (taken from) for BCL's FindBondTypeFromSDFInfo( const std::size_t &SDF_ID)

C++ signature : void SetSDFType(core::chemical::Bond {lvalue},unsigned long)

def aromaticity(

...)

aromaticity( (Bond)arg1, (BondAromaticity)aroma) -> None : core/chemical/Bond.hh:61

C++ signature :
    void aromaticity(core::chemical::Bond {lvalue},core::chemical::BondAromaticity)

aromaticity( (Bond)arg1) -> BondAromaticity : core/chemical/Bond.hh:87

C++ signature :
    core::chemical::BondAromaticity aromaticity(core::chemical::Bond {lvalue})

def bond_name(

...)

bond_name( (Bond)arg1, (BondName)bond_name) -> None : core/chemical/Bond.hh:51

C++ signature :
    void bond_name(core::chemical::Bond {lvalue},core::chemical::BondName)

bond_name( (Bond)arg1) -> BondName : core/chemical/Bond.hh:75

C++ signature :
    core::chemical::BondName bond_name(core::chemical::Bond {lvalue})

def conjugability(

...)

conjugability( (Bond)arg1, (BondConjugability)conjug) -> None : core/chemical/Bond.hh:58

C++ signature :
    void conjugability(core::chemical::Bond {lvalue},core::chemical::BondConjugability)

conjugability( (Bond)arg1) -> BondConjugability : core/chemical/Bond.hh:84

C++ signature :
    core::chemical::BondConjugability conjugability(core::chemical::Bond {lvalue})

def cut_bond(

...)

cut_bond( (Bond)arg1, (bool)cut_bond) -> None : core/chemical/Bond.hh:53

C++ signature :
    void cut_bond(core::chemical::Bond {lvalue},bool)

cut_bond( (Bond)arg1) -> bool : core/chemical/Bond.hh:78

C++ signature :
    bool cut_bond(core::chemical::Bond {lvalue})

def distance(

...)

distance( (Bond)arg1, (float)distance) -> None : core/chemical/Bond.hh:48

C++ signature :
    void distance(core::chemical::Bond {lvalue},double)

distance( (Bond)arg1) -> float : core/chemical/Bond.hh:72

C++ signature :
    double distance(core::chemical::Bond {lvalue})

def is_fake(

...)

is_fake( (Bond)arg1) -> bool : Return true if this bond represents a non-physical bond

C++ signature : bool is_fake(core::chemical::Bond {lvalue})

def isometry(

...)

isometry( (Bond)arg1, (BondIsometry)isom) -> None : core/chemical/Bond.hh:66

C++ signature :
    void isometry(core::chemical::Bond {lvalue},core::chemical::BondIsometry)

isometry( (Bond)arg1) -> BondIsometry : core/chemical/Bond.hh:93

C++ signature :
    core::chemical::BondIsometry isometry(core::chemical::Bond {lvalue})

def order(

...)

order( (Bond)arg1, (BondOrder)order) -> None : core/chemical/Bond.hh:56

C++ signature :
    void order(core::chemical::Bond {lvalue},core::chemical::BondOrder)

order( (Bond)arg1) -> BondOrder : core/chemical/Bond.hh:81

C++ signature :
    core::chemical::BondOrder order(core::chemical::Bond {lvalue})

def print(

...)

print( (Bond)arg1, (OStream)out) -> None : core/chemical/Bond.hh:99

C++ signature : void print(core::chemical::Bond {lvalue},std::ostream {lvalue})

def ringness(

...)

ringness( (Bond)arg1, (BondRingness)ring) -> None : core/chemical/Bond.hh:63

C++ signature :
    void ringness(core::chemical::Bond {lvalue},core::chemical::BondRingness)

ringness( (Bond)arg1) -> BondRingness : core/chemical/Bond.hh:90

C++ signature :
    core::chemical::BondRingness ringness(core::chemical::Bond {lvalue})

class BondAP

Ancestors (in MRO)

  • BondAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (BondAP)arg1) -> Bond :

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

class BondAromaticity

Proper aromaticity implies participation in a 4n+2 electron ring system. For simple single-double alternation, see conjugatable bond.

Ancestors (in MRO)

Class variables

var IsAromaticBond

var NonaromaticBond

var UnknownAromaticity

var denominator

var imag

var name

var names

var numerator

var real

var values

class BondCAP

Ancestors (in MRO)

  • BondCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (BondCAP)arg1) -> Bond :

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

class BondConjugability

As with the BCL, bond conjugability is more about the atom types on either end of the bond than about the bond itself. A conjugatable bond is one where it is known that the atoms on both sides of the bond can participate in a conjugated system. Double, triple and aromatic bonds are always conjugatable, and single bonds are conjugatable if both atoms are in other triple, double, or aromatic systems

Ancestors (in MRO)

Class variables

var ConjugableBond

var NotConjugableBond

var UnknownConjugability

var denominator

var imag

var name

var names

var numerator

var real

var values

class BondIsometry

core/chemical/Bond.fwd.hh:74

Ancestors (in MRO)

  • BondIsometry
  • Boost.Python.enum
  • __builtin__.int
  • __builtin__.object

Class variables

var EIsometry

var NoBondIsometry

var UnknownIsometry

var ZIsometry

var denominator

var imag

var name

var names

var numerator

var real

var values

class BondName

core/chemical/Bond.fwd.hh:23

Ancestors (in MRO)

  • BondName
  • Boost.Python.enum
  • __builtin__.int
  • __builtin__.object

Class variables

var AromaticBond

var DoubleBond

var OrbitalBond

var SingleBond

var TripleBond

var UnknownBond

var denominator

var imag

var name

var names

var numerator

var real

var values

class BondOrder

core/chemical/Bond.fwd.hh:33

Ancestors (in MRO)

  • BondOrder
  • Boost.Python.enum
  • __builtin__.int
  • __builtin__.object

Class variables

var DoubleBondOrder

var OrbitalBondOrder

var PseudoBondOrder

var SingleBondOrder

var TripleBondOrder

var UnknownBondOrder

var denominator

var imag

var name

var names

var numerator

var real

var values

class BondRingness

core/chemical/Bond.fwd.hh:57

Ancestors (in MRO)

  • BondRingness
  • Boost.Python.enum
  • __builtin__.int
  • __builtin__.object

Class variables

var BondInRing

var BondNotInRing

var UnknownRingness

var denominator

var imag

var name

var names

var numerator

var real

var values

class CPParameter

Enumerators for the three Cremer-Pople "ring-puckering" parameters used to describe 4-, 5-, and 6-membered ring conformers

Ancestors (in MRO)

  • CPParameter
  • Boost.Python.enum
  • __builtin__.int
  • __builtin__.object

Class variables

var PHI

var THETA

var denominator

var imag

var name

var names

var numerator

var q

var real

var values

class ChemicalManager

a class managing different sets of atom_type_set and residue_type_set make it as a singleton class so that atom_type_set and residue_type_set are only input and initialized once. They can be later retrieved by querying this class.

Ancestors (in MRO)

Methods

def atom_type_set(

...)

atom_type_set( (ChemicalManager)arg1, (str)tag) -> AtomTypeSet : query atom_type_set by a name tag

C++ signature : boost::shared_ptr atom_type_set(core::chemical::ChemicalManager {lvalue},std::string)

def element_set(

...)

element_set( (ChemicalManager)arg1, (str)tag) -> ElementSet : query atom_type_set by a name tag

C++ signature : boost::shared_ptr element_set(core::chemical::ChemicalManager {lvalue},std::string)

def gasteiger_atom_type_set(

...)

gasteiger_atom_type_set( (ChemicalManager)arg1 [, (str)tag='default']) -> object : query gasteiger_atom_type_set by a name tag

C++ signature : boost::shared_ptr gasteiger_atom_type_set(core::chemical::ChemicalManager {lvalue} [,std::string='default'])

def has_residue_type_set(

...)

has_residue_type_set( (ChemicalManager)arg1, (str)tag) -> bool : Check if residue_type_set is instantiated...

C++ signature : bool has_residue_type_set(core::chemical::ChemicalManager {lvalue},std::string)

def ideal_bond_length_set(

...)

ideal_bond_length_set( (ChemicalManager)arg1, (str)tag) -> IdealBondLengthSet : query ideal_bond_lengths

C++ signature : boost::shared_ptr ideal_bond_length_set(core::chemical::ChemicalManager {lvalue},std::string)

def mm_atom_type_set(

...)

mm_atom_type_set( (ChemicalManager)arg1, (str)tag) -> MMAtomTypeSet : query mm_atom_type_set by a name tag

C++ signature : boost::shared_ptr mm_atom_type_set(core::chemical::ChemicalManager {lvalue},std::string)

def nonconst_residue_type_set(

...)

nonconst_residue_type_set( (ChemicalManager)arg1, (str)tag) -> ResidueTypeSet : query residue_type_set by a name tag

C++ signature : core::chemical::ResidueTypeSet {lvalue} nonconst_residue_type_set(core::chemical::ChemicalManager {lvalue},std::string)

def nonconst_residue_type_set_op(

...)

nonconst_residue_type_set_op( (ChemicalManager)arg1, (str)tag) -> ResidueTypeSet : core/chemical/ChemicalManager.hh:128

C++ signature : boost::shared_ptr nonconst_residue_type_set_op(core::chemical::ChemicalManager {lvalue},std::string)

def orbital_type_set(

...)

orbital_type_set( (ChemicalManager)arg1, (str)tag) -> OrbitalTypeSet : query orbital_type_set by a name tag

C++ signature : boost::shared_ptr orbital_type_set(core::chemical::ChemicalManager {lvalue},std::string)

def residue_type_set(

...)

residue_type_set( (ChemicalManager)arg1, (str)tag) -> ResidueTypeSet : query residue_type_set by a name tag

C++ signature : boost::shared_ptr residue_type_set(core::chemical::ChemicalManager {lvalue},std::string)

class ChemicalManagerAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ChemicalManagerAP)arg1) -> ChemicalManager :

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

class ChemicalManagerCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ChemicalManagerCAP)arg1) -> ChemicalManager :

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

class DeleteAtom

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// delete an atom

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (DeleteAtom)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// delete an atom

C++ signature :
    void __init__(_object*,core::chemical::DeleteAtom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (DeleteAtom)arg1, (ResidueType)rsd) -> bool : delete an atom from ResidueType rsd

C++ signature :
    bool apply(core::chemical::DeleteAtom {lvalue},core::chemical::ResidueType {lvalue})

apply( (DeleteAtom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(DeleteAtom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class DeleteAtomAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DeleteAtomAP)arg1) -> DeleteAtom :

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

class DeleteAtomCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DeleteAtomCAP)arg1) -> DeleteAtom :

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

class DeleteMetalbindingAtom

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Delete a metal binding atom Added by Andrew M. Watkins in April 2015

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (DeleteMetalbindingAtom)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Delete a metal binding atom Added by Andrew M. Watkins in April 2015

C++ signature :
    void __init__(_object*,core::chemical::DeleteMetalbindingAtom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (DeleteMetalbindingAtom)arg1, (ResidueType)rsd) -> bool : redefine a chi angle

C++ signature :
    bool apply(core::chemical::DeleteMetalbindingAtom {lvalue},core::chemical::ResidueType {lvalue})

apply( (DeleteMetalbindingAtom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(DeleteMetalbindingAtom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class DeleteMetalbindingAtomAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DeleteMetalbindingAtomAP)arg1) -> DeleteMetalbindingAtom :

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

class DeleteMetalbindingAtomCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DeleteMetalbindingAtomCAP)arg1) -> DeleteMetalbindingAtom :

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

class DeleteProperty

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// delete a property from ResidueType Added by Andy M. Chen in June 2009 This is needed for deleting properties, which occurs in certain PTM's (e.g. methylation)

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)property_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (DeleteProperty)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// delete a property from ResidueType Added by Andy M. Chen in June 2009 This is needed for deleting properties, which occurs in certain PTM's (e.g. methylation)

C++ signature :
    void __init__(_object*,core::chemical::DeleteProperty)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (DeleteProperty)arg1, (ResidueType)rsd) -> bool : delete a property

C++ signature :
    bool apply(core::chemical::DeleteProperty {lvalue},core::chemical::ResidueType {lvalue})

apply( (DeleteProperty)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(DeleteProperty_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class DeletePropertyAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DeletePropertyAP)arg1) -> DeleteProperty :

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

class DeletePropertyCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DeletePropertyCAP)arg1) -> DeleteProperty :

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

class DeleteTerminalChi

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Delete terminal chi angle Added by Andrew M. Watkins in April 2015

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (DeleteTerminalChi)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Delete terminal chi angle Added by Andrew M. Watkins in April 2015

C++ signature :
    void __init__(_object*,core::chemical::DeleteTerminalChi)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (DeleteTerminalChi)arg1, (ResidueType)rsd) -> bool : redefine a chi angle

C++ signature :
    bool apply(core::chemical::DeleteTerminalChi {lvalue},core::chemical::ResidueType {lvalue})

apply( (DeleteTerminalChi)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(DeleteTerminalChi_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class DeleteTerminalChiAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DeleteTerminalChiAP)arg1) -> DeleteTerminalChi :

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

class DeleteTerminalChiCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DeleteTerminalChiCAP)arg1) -> DeleteTerminalChi :

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

class ElectronConfiguration

///////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Ancestors (in MRO)

Class variables

var AngularMomentumQuantumNumber

var MaxAngularMomentumQuantumNumber

var MaxPrincipleQuantumNumber

var PrincipalQuantumNumber

var e_1

var e_2

var e_3

var e_4

var e_5

var e_6

var e_7

var e_D

var e_F

var e_P

var e_S

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ElectronConfiguration)) -> None : ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

C++ signature :
    void __init__(_object*,core::chemical::ElectronConfiguration)

init( (object)arg1, (int)VALENCE_ELECTRONS_SP, (int)VALENCE_ELECTRONS_SPD, (int)NUMBER_ELECTRONS_1S, (int)NUMBER_ELECTRONS_1P, (int)NUMBER_ELECTRONS_1D, (int)NUMBER_ELECTRONS_1F, (int)NUMBER_ELECTRONS_2S, (int)NUMBER_ELECTRONS_2P, (int)NUMBER_ELECTRONS_2D, (int)NUMBER_ELECTRONS_2F, (int)NUMBER_ELECTRONS_3S, (int)NUMBER_ELECTRONS_3P, (int)NUMBER_ELECTRONS_3D, (int)NUMBER_ELECTRONS_3F, (int)NUMBER_ELECTRONS_4S, (int)NUMBER_ELECTRONS_4P, (int)NUMBER_ELECTRONS_4D, (int)NUMBER_ELECTRONS_4F, (int)NUMBER_ELECTRONS_5S, (int)NUMBER_ELECTRONS_5P, (int)NUMBER_ELECTRONS_5D, (int)NUMBER_ELECTRONS_5F, (int)NUMBER_ELECTRONS_6S, (int)NUMBER_ELECTRONS_6P, (int)NUMBER_ELECTRONS_6D, (int)NUMBER_ELECTRONS_6F, (int)NUMBER_ELECTRONS_7S, (int)NUMBER_ELECTRONS_7P, (int)NUMBER_ELECTRONS_7D, (int)NUMBER_ELECTRONS_7F) -> None : core/chemical/ElectronConfiguration.hh:144

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

def max_valence_electrons_sp(

...)

max_valence_electrons_sp( (ElectronConfiguration)arg1) -> int : core/chemical/ElectronConfiguration.hh:179

C++ signature : unsigned long max_valence_electrons_sp(core::chemical::ElectronConfiguration {lvalue})

def read(

...)

read( (ElectronConfiguration)arg1, (std_istream)ISTREAM) -> std_istream : /////////////////// ///////////////////

C++ signature : std::istream {lvalue} read(core::chemical::ElectronConfiguration {lvalue},std::istream {lvalue})

def unpaired_valence_electrons_sp(

...)

unpaired_valence_electrons_sp( (ElectronConfiguration)arg1) -> int : core/chemical/ElectronConfiguration.hh:164

C++ signature : unsigned long unpaired_valence_electrons_sp(core::chemical::ElectronConfiguration {lvalue})

def valence_electrons_p(

...)

valence_electrons_p( (ElectronConfiguration)arg1) -> int : core/chemical/ElectronConfiguration.hh:170

C++ signature : unsigned long valence_electrons_p(core::chemical::ElectronConfiguration {lvalue})

def valence_electrons_s(

...)

valence_electrons_s( (ElectronConfiguration)arg1) -> int : core/chemical/ElectronConfiguration.hh:158

C++ signature : unsigned long valence_electrons_s(core::chemical::ElectronConfiguration {lvalue})

def valence_electrons_sp(

...)

valence_electrons_sp( (ElectronConfiguration)arg1) -> int : core/chemical/ElectronConfiguration.hh:176

C++ signature : unsigned long valence_electrons_sp(core::chemical::ElectronConfiguration {lvalue})

def valence_electrons_spd(

...)

valence_electrons_spd( (ElectronConfiguration)arg1) -> int : core/chemical/ElectronConfiguration.hh:182

C++ signature : unsigned long valence_electrons_spd(core::chemical::ElectronConfiguration {lvalue})

def write(

...)

write( (ElectronConfiguration)arg1, (OStream)OSTREAM) -> OStream : core/chemical/ElectronConfiguration.hh:227

C++ signature : std::ostream {lvalue} write(core::chemical::ElectronConfiguration {lvalue},std::ostream {lvalue})

class ElectronConfigurationAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ElectronConfigurationAP)arg1) -> ElectronConfiguration :

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

class ElectronConfigurationCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ElectronConfigurationCAP)arg1) -> ElectronConfiguration :

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

class Element

///////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Ancestors (in MRO)

  • Element
  • Boost.Python.instance
  • __builtin__.object

Class variables

var CovalentRadius

var Mass

var NumberOfProperties

var Properties

var VDWaalsRadius

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (Element)) -> None : ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

C++ signature :
    void __init__(_object*,core::chemical::Element)

init( (object)arg1, (int)ATOMIC_NUMBER, (int)PERIOD, (int)MAIN_GROUP, (str)CHEMICAL_SYMBOL, (str)CHEMICAL_NAME, (float)MASS, (float)COVALENT_RADIUS, (float)VDW_RADIUS, (ElectronConfiguration)ELECTRON_CONFIGURATION) -> None : core/chemical/Element.hh:103

C++ signature :
    void __init__(_object*,unsigned long,unsigned long,unsigned long,std::string,std::string,double,double,double,core::chemical::ElectronConfiguration)

def Clone(

...)

Clone( (Element)arg1) -> Element : core/chemical/Element.hh:106

C++ signature : boost::shared_ptr Clone(core::chemical::Element {lvalue})

def element(

...)

element( (Element)arg1) -> object : ////////////// //////////////

C++ signature : core::chemical::element::Elements element(core::chemical::Element {lvalue})

def get_atomic_number(

...)

get_atomic_number( (Element)arg1) -> int : core/chemical/Element.hh:119

C++ signature : unsigned long get_atomic_number(core::chemical::Element {lvalue})

def get_chemical_name(

...)

get_chemical_name( (Element)arg1) -> str : core/chemical/Element.hh:145

C++ signature : std::string get_chemical_name(core::chemical::Element {lvalue})

def get_chemical_symbol(

...)

get_chemical_symbol( (Element)arg1) -> str : core/chemical/Element.hh:138

C++ signature : std::string get_chemical_symbol(core::chemical::Element {lvalue})

def get_electron_configuration(

...)

get_electron_configuration( (Element)arg1) -> ElectronConfiguration : core/chemical/Element.hh:160

C++ signature : core::chemical::ElectronConfiguration get_electron_configuration(core::chemical::Element {lvalue})

def get_main_group(

...)

get_main_group( (Element)arg1) -> int : core/chemical/Element.hh:131

C++ signature : unsigned long get_main_group(core::chemical::Element {lvalue})

def get_period(

...)

get_period( (Element)arg1) -> int : core/chemical/Element.hh:125

C++ signature : unsigned long get_period(core::chemical::Element {lvalue})

def get_property(

...)

get_property( (Element)arg1, (Properties)PROPERTY) -> float : core/chemical/Element.hh:153

C++ signature : double get_property(core::chemical::Element {lvalue},core::chemical::Element::Properties)

def is_conjugatable(

...)

is_conjugatable( (Element)arg1) -> bool : core/chemical/Element.hh:169

C++ signature : bool is_conjugatable(core::chemical::Element {lvalue})

def is_fake(

...)

is_fake( (Element)arg1) -> bool : Return true unless the element actually exists in the periodic table.

C++ signature : bool is_fake(core::chemical::Element {lvalue})

def read(

...)

read( (Element)arg1, (std_istream)ISTREAM) -> std_istream : /////////////////// ///////////////////

C++ signature : std::istream {lvalue} read(core::chemical::Element {lvalue},std::istream {lvalue})

def weight(

...)

weight( (Element)arg1) -> float : This is legacy code from old element set Return the full name of the Element

C++ signature : double weight(core::chemical::Element {lvalue})

def write(

...)

write( (Element)arg1, (OStream)OSTREAM) -> OStream : core/chemical/Element.hh:200

C++ signature : std::ostream {lvalue} write(core::chemical::Element {lvalue},std::ostream {lvalue})

class ElementAP

Ancestors (in MRO)

  • ElementAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ElementAP)arg1) -> Element :

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

class ElementCAP

Ancestors (in MRO)

  • ElementCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ElementCAP)arg1) -> Element :

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

class ElementSet

A set of Bcl Elements This class contains a vector of pointers each of which points to an Element and the vector index is looked up by an element_name string in a map.

Ancestors (in MRO)

  • ElementSet
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ElementSet)) -> None : A set of Bcl Elements This class contains a vector of pointers each of which points to an Element and the vector index is looked up by an element_name string in a map.

C++ signature :
    void __init__(_object*,core::chemical::ElementSet)

def contains_element_type(

...)

contains_element_type( (ElementSet)arg1, (str)element_symbol) -> bool : Check if there is an element_type associated with an element_symbol string

C++ signature : bool contains_element_type(core::chemical::ElementSet {lvalue},std::string)

def element(

...)

element( (ElementSet)arg1, (str)element_symbol) -> Element : Lookup the element index by the element_symbol string

C++ signature : boost::shared_ptr element(core::chemical::ElementSet {lvalue},std::string)

def element_index(

...)

element_index( (ElementSet)arg1, (str)element_symbol) -> int : Lookup the element index by the element_symbol string

C++ signature : unsigned long element_index(core::chemical::ElementSet {lvalue},std::string)

def n_elements(

...)

n_elements( (ElementSet)arg1) -> int : Number of elements in the set

C++ signature : unsigned long n_elements(core::chemical::ElementSet {lvalue})

def read_file(

...)

read_file( (ElementSet)arg1, (str)filename) -> None : Load the ElementSet from a file

C++ signature : void read_file(core::chemical::ElementSet {lvalue},std::string)

class ElementSetAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ElementSetAP)arg1) -> ElementSet :

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

class ElementSetCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ElementSetCAP)arg1) -> ElementSet :

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

class HeavyAtomFilter

The filter responsible for obtaining all heavy atoms.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (HeavyAtomFilter)) -> None : The filter responsible for obtaining all heavy atoms.

C++ signature :
    void __init__(_object*,core::chemical::HeavyAtomFilter)

init( (object)arg1, (object)graph, (AtomTypeSetCAP)atom_types) -> None : core/chemical/ResidueGraphTypes.hh:169

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property> {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>)

class HeavyAtomFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HeavyAtomFilterAP)arg1) -> HeavyAtomFilter :

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

class HeavyAtomFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HeavyAtomFilterCAP)arg1) -> HeavyAtomFilter :

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

class HeavyAtomWithHydrogensFilter

///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for finding heavy atoms with hydrogens.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (HeavyAtomWithHydrogensFilter)) -> None : ///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for finding heavy atoms with hydrogens.

C++ signature :
    void __init__(_object*,core::chemical::HeavyAtomWithHydrogensFilter)

init( (object)arg1, (object)graph, (AtomTypeSetCAP)atom_types) -> None : core/chemical/ResidueGraphTypes.hh:228

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property> {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>)

class HeavyAtomWithHydrogensFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HeavyAtomWithHydrogensFilterAP)arg1) -> HeavyAtomWithHydrogensFilter :

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

class HeavyAtomWithHydrogensFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HeavyAtomWithHydrogensFilterCAP)arg1) -> HeavyAtomWithHydrogensFilter :

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

class HeavyAtomWithPolarHydrogensFilter

///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for obtaining all heavy atoms with polar hydrogens attached to them.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (HeavyAtomWithPolarHydrogensFilter)) -> None : ///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for obtaining all heavy atoms with polar hydrogens attached to them.

C++ signature :
    void __init__(_object*,core::chemical::HeavyAtomWithPolarHydrogensFilter)

init( (object)arg1, (object)graph, (AtomTypeSetCAP)atom_types) -> None : core/chemical/ResidueGraphTypes.hh:210

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property> {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>)

class HeavyAtomWithPolarHydrogensFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HeavyAtomWithPolarHydrogensFilterAP)arg1) -> HeavyAtomWithPolarHydrogensFilter :

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

class HeavyAtomWithPolarHydrogensFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HeavyAtomWithPolarHydrogensFilterCAP)arg1) -> HeavyAtomWithPolarHydrogensFilter :

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

class Hybridization

core/chemical/types.hh:33

Ancestors (in MRO)

  • Hybridization
  • Boost.Python.enum
  • __builtin__.int
  • __builtin__.object

Class variables

var HYBRID_MAX

var RING_HYBRID

var SP2_HYBRID

var SP3_HYBRID

var UNKNOWN_HYBRID

var denominator

var imag

var name

var names

var numerator

var real

var values

class HydrogenAtomFilter

///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for all hydrogens.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (HydrogenAtomFilter)) -> None : ///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for all hydrogens.

C++ signature :
    void __init__(_object*,core::chemical::HydrogenAtomFilter)

init( (object)arg1, (object)graph, (AtomTypeSetCAP)atom_types) -> None : core/chemical/ResidueGraphTypes.hh:247

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property> {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>)

class HydrogenAtomFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HydrogenAtomFilterAP)arg1) -> HydrogenAtomFilter :

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

class HydrogenAtomFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HydrogenAtomFilterCAP)arg1) -> HydrogenAtomFilter :

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

class ICoorAtomID

Atom 's ID in internal coordinates in a ResidueType

Ancestors (in MRO)

Class variables

var CONNECT

var INTERNAL

var POLYMER_LOWER

var POLYMER_UPPER

var Type

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ICoorAtomID)) -> None : Atom 's ID in internal coordinates in a ResidueType

C++ signature :
    void __init__(_object*,core::chemical::ICoorAtomID)

init( (object)arg1, (str)name, (ResidueType)rsd_type) -> None : construct ICoorAtomID by atom name and its ResidueType

C++ signature :
    void __init__(_object*,std::string,core::chemical::ResidueType)

init( (object)arg1, (object)vd, (ResidueType)rsd_type) -> None : construct ICoorAtomID by VD and its ResidueType

C++ signature :
    void __init__(_object*,void*,core::chemical::ResidueType)

def atom_id(

...)

atom_id( (ICoorAtomID)arg1, (int)seqpos, (Conformation)conformation) -> AtomID : core/chemical/AtomICoor.hh:178

C++ signature : core::id::AtomID atom_id(core::chemical::ICoorAtomID {lvalue},unsigned long,core::conformation::Conformation)

def atomno(

...)

atomno( (ICoorAtomID)arg1) -> int : get ICoorAtomID atomno

C++ signature :
    unsigned long atomno(core::chemical::ICoorAtomID {lvalue})

atomno( (ICoorAtomID)arg1, (int)atomno_in) -> None : set ICoorAtomID atomno

C++ signature :
    void atomno(core::chemical::ICoorAtomID {lvalue},int)

def is_connect(

...)

is_connect( (ICoorAtomID)arg1, (int)connid) -> bool : Returns true if this is the specified connection id

C++ signature :
    bool is_connect(core::chemical::ICoorAtomID {lvalue},unsigned long)

is_connect( (ICoorAtomID)arg1) -> bool : Returns true if this is a connection. Vikram K. Mulligan (vmullig@uw.edu)

C++ signature :
    bool is_connect(core::chemical::ICoorAtomID {lvalue})

def is_internal(

...)

is_internal( (ICoorAtomID)arg1) -> bool : core/chemical/AtomICoor.hh:123

C++ signature : bool is_internal(core::chemical::ICoorAtomID {lvalue})

def is_polymer_lower(

...)

is_polymer_lower( (ICoorAtomID)arg1) -> bool : core/chemical/AtomICoor.hh:130

C++ signature : bool is_polymer_lower(core::chemical::ICoorAtomID {lvalue})

def is_polymer_upper(

...)

is_polymer_upper( (ICoorAtomID)arg1) -> bool : core/chemical/AtomICoor.hh:137

C++ signature : bool is_polymer_upper(core::chemical::ICoorAtomID {lvalue})

def type(

...)

type( (ICoorAtomID)arg1) -> Type : get ICoordAtomID type

C++ signature : core::chemical::ICoorAtomID::Type type(core::chemical::ICoorAtomID {lvalue})

def vertex(

...)

vertex( (ICoorAtomID)arg1) -> object : core/chemical/AtomICoor.hh:105

C++ signature :
    void* vertex(core::chemical::ICoorAtomID {lvalue})

vertex( (ICoorAtomID)arg1, (object)vertex) -> None : core/chemical/AtomICoor.hh:110

C++ signature :
    void vertex(core::chemical::ICoorAtomID {lvalue},void*)

def xyz(

...)

xyz( (ICoorAtomID)arg1, (Residue)rsd, (Conformation)conformation) -> xyzVector_Real : core/chemical/AtomICoor.hh:163

C++ signature :
    numeric::xyzVector<double> xyz(core::chemical::ICoorAtomID {lvalue},core::conformation::Residue,core::conformation::Conformation)

xyz( (ICoorAtomID)arg1, (ResidueType)rsd_type) -> xyzVector_Real : core/chemical/AtomICoor.hh:167

C++ signature :
    numeric::xyzVector<double> xyz(core::chemical::ICoorAtomID {lvalue},core::chemical::ResidueType)

xyz( (ICoorAtomID)arg1, (Residue)rsd) -> xyzVector_Real : WARNING: Slightly dangerous function intended for black magic use only. Rebuilds atom location from stub atoms. If stub atom are not internal atoms, their location will be rebuilt from their residue stub atom's locations, as opposed to being retrieved from connected residues via a conformation.

C++ signature :
    numeric::xyzVector<double> xyz(core::chemical::ICoorAtomID {lvalue},core::conformation::Residue)

class ICoorAtomIDAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ICoorAtomIDAP)arg1) -> ICoorAtomID :

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

class ICoorAtomIDCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ICoorAtomIDCAP)arg1) -> ICoorAtomID :

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

class IdealBondLengthSet

A set of Elements This class contains a vector of pointers each of which points to an Element and the vector index is looked up by an element_name string in a map.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (IdealBondLengthSet)) -> None : A set of Elements This class contains a vector of pointers each of which points to an Element and the vector index is looked up by an element_name string in a map.

C++ signature :
    void __init__(_object*,core::chemical::IdealBondLengthSet)

def contains_bond_length(

...)

contains_bond_length( (IdealBondLengthSet)arg1, (str)atom_type_name1, (str)atom_type_name2) -> bool : Check if an ideal bond length is known for this pair of atom types...

C++ signature :
    bool contains_bond_length(core::chemical::IdealBondLengthSet {lvalue},std::string,std::string)

contains_bond_length( (IdealBondLengthSet)arg1, (int)atom_type_index1, (int)atom_type_index2) -> bool : core/chemical/IdealBondLengthSet.hh:56

C++ signature :
    bool contains_bond_length(core::chemical::IdealBondLengthSet {lvalue},int,int)

def get_bond_length(

...)

get_bond_length( (IdealBondLengthSet)arg1, (str)atom_type_name1, (str)atom_type_name2) -> float : Lookup the element index by the element_symbol string

C++ signature :
    double get_bond_length(core::chemical::IdealBondLengthSet {lvalue},std::string,std::string)

get_bond_length( (IdealBondLengthSet)arg1, (int)atom_type_index1, (int)atom_type_index2) -> float : core/chemical/IdealBondLengthSet.hh:60

C++ signature :
    double get_bond_length(core::chemical::IdealBondLengthSet {lvalue},int,int)

def print_all_bond_lengths(

...)

print_all_bond_lengths( (IdealBondLengthSet)arg1) -> None : Print all of the symbols of all of the Elements in the set. Usefull for debuging.

C++ signature : void print_all_bond_lengths(core::chemical::IdealBondLengthSet {lvalue})

def read_file(

...)

read_file( (IdealBondLengthSet)arg1, (str)filename) -> None : Load the IdealBondLengthSet from a file

C++ signature : void read_file(core::chemical::IdealBondLengthSet {lvalue},std::string)

class IdealBondLengthSetAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (IdealBondLengthSetAP)arg1) -> IdealBondLengthSet :

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

class IdealBondLengthSetCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (IdealBondLengthSetCAP)arg1) -> IdealBondLengthSet :

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

class MMAtomType

Basic MM atom type Simple class for holding the name and the LJ properties of a Charmm molecular mechanics atom type. Borrows heavily and functions similarly to the rosetta atom type class, AtomType

Ancestors (in MRO)

  • MMAtomType
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1, (str)name_in) -> None : Construct a new MMAtomType with its name

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (MMAtomType)) -> None : Basic MM atom type Simple class for holding the name and the LJ properties of a Charmm molecular mechanics atom type. Borrows heavily and functions similarly to the rosetta atom type class, AtomType

C++ signature :
    void __init__(_object*,core::chemical::MMAtomType)

def lj_radius(

...)

lj_radius( (MMAtomType)arg1) -> float : Return the LJ radius of the atom type

C++ signature : double lj_radius(core::chemical::MMAtomType {lvalue})

def lj_three_bond_radius(

...)

lj_three_bond_radius( (MMAtomType)arg1) -> float : Return the LJ radius for use when atoms types are seperated by 3 bonds

C++ signature : double lj_three_bond_radius(core::chemical::MMAtomType {lvalue})

def lj_three_bond_wdepth(

...)

lj_three_bond_wdepth( (MMAtomType)arg1) -> float : Return the LJ well depth for use when atoms types are seperated by 3 bonds

C++ signature : double lj_three_bond_wdepth(core::chemical::MMAtomType {lvalue})

def lj_wdepth(

...)

lj_wdepth( (MMAtomType)arg1) -> float : Return the LJ well depth of the atom type

C++ signature : double lj_wdepth(core::chemical::MMAtomType {lvalue})

def name(

...)

name( (MMAtomType)arg1) -> str : Return the name of the MMAtomType

C++ signature : std::string name(core::chemical::MMAtomType {lvalue})

def set_parameter(

...)

set_parameter( (MMAtomType)arg1, (str)param, (float)setting) -> None : set LJ and LK solvation parameter for this atom type

C++ signature : void set_parameter(core::chemical::MMAtomType {lvalue},std::string,double)

class MMAtomTypeAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (MMAtomTypeAP)arg1) -> MMAtomType :

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

class MMAtomTypeCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (MMAtomTypeCAP)arg1) -> MMAtomType :

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

class MMAtomTypeSet

A set of MMAtomTypes This class contains a vector of pointers each of which points to an MMAtomType and the vector index is looked up by an atom_name string in a map.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (MMAtomTypeSet)) -> None : A set of MMAtomTypes This class contains a vector of pointers each of which points to an MMAtomType and the vector index is looked up by an atom_name string in a map.

C++ signature :
    void __init__(_object*,core::chemical::MMAtomTypeSet)

def atom_type_index(

...)

atom_type_index( (MMAtomTypeSet)arg1, (str)atom_type_name) -> int : Lookup the atom_type by the atom_type_name string

C++ signature : int atom_type_index(core::chemical::MMAtomTypeSet {lvalue},std::string)

def contains_atom_type(

...)

contains_atom_type( (MMAtomTypeSet)arg1, (str)atom_type_name) -> bool : Check if there is an atom_type associated with an atom_type_name string

C++ signature : bool contains_atom_type(core::chemical::MMAtomTypeSet {lvalue},std::string)

def n_atomtypes(

...)

n_atomtypes( (MMAtomTypeSet)arg1) -> int : Number of MM atom types in the set

C++ signature : unsigned long n_atomtypes(core::chemical::MMAtomTypeSet {lvalue})

def print_all_types(

...)

print_all_types( (MMAtomTypeSet)arg1) -> None : Print all of the names of all of the MMAtomTypes in the set. Usefull for debuging.

C++ signature : void print_all_types(core::chemical::MMAtomTypeSet {lvalue})

def read_file(

...)

read_file( (MMAtomTypeSet)arg1, (str)filename) -> None : Load the MMAtomTypeSet from a file

C++ signature : void read_file(core::chemical::MMAtomTypeSet {lvalue},std::string)

class MMAtomTypeSetAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (MMAtomTypeSetAP)arg1) -> MMAtomTypeSet :

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

class MMAtomTypeSetCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (MMAtomTypeSetCAP)arg1) -> MMAtomTypeSet :

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

class NCAARotLibPath

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set the path to a rotamer library for an NCAA that is not in dunbrack

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)path_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (NCAARotLibPath)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set the path to a rotamer library for an NCAA that is not in dunbrack

C++ signature :
    void __init__(_object*,core::chemical::NCAARotLibPath)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (NCAARotLibPath)arg1, (ResidueType)rsd) -> bool : set the NCAA rotamer library path in the residue type

C++ signature :
    bool apply(core::chemical::NCAARotLibPath {lvalue},core::chemical::ResidueType {lvalue})

apply( (NCAARotLibPath)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(NCAARotLibPath_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class NCAARotLibPathAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (NCAARotLibPathAP)arg1) -> NCAARotLibPath :

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

class NCAARotLibPathCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (NCAARotLibPathCAP)arg1) -> NCAARotLibPath :

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

class Orbital

basic chemical atom name, element, certain properties and parameters from .params file

Ancestors (in MRO)

  • Orbital
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (str)name_in, (int)orbital_type_index, (xyzVector_Real)xyz) -> None : core/chemical/Orbital.hh:70

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

init( (object)arg1, (Orbital)src) -> None : core/chemical/Orbital.hh:78

C++ signature :
    void __init__(_object*,core::chemical::Orbital)

def icoor(

...)

icoor( (Orbital)arg1) -> ICoorOrbitalData : core/chemical/Orbital.hh:97

C++ signature :
    core::chemical::orbitals::ICoorOrbitalData icoor(core::chemical::Orbital {lvalue})

icoor( (Orbital)arg1) -> ICoorOrbitalData : core/chemical/Orbital.hh:100

C++ signature :
    core::chemical::orbitals::ICoorOrbitalData {lvalue} icoor(core::chemical::Orbital {lvalue})

icoor( (Orbital)arg1, (ICoorOrbitalData)icoor) -> None : core/chemical/Orbital.hh:106

C++ signature :
    void icoor(core::chemical::Orbital {lvalue},core::chemical::orbitals::ICoorOrbitalData)

def ideal_xyz(

...)

ideal_xyz( (Orbital)arg1) -> xyzVector_Real : core/chemical/Orbital.hh:96

C++ signature :
    numeric::xyzVector<double> ideal_xyz(core::chemical::Orbital {lvalue})

ideal_xyz( (Orbital)arg1, (xyzVector_Real)xyz) -> None : core/chemical/Orbital.hh:105

C++ signature :
    void ideal_xyz(core::chemical::Orbital {lvalue},numeric::xyzVector<double>)

def name(

...)

name( (Orbital)arg1) -> str : core/chemical/Orbital.hh:94

C++ signature :
    std::string name(core::chemical::Orbital {lvalue})

name( (Orbital)arg1, (str)name) -> None : core/chemical/Orbital.hh:103

C++ signature :
    void name(core::chemical::Orbital {lvalue},std::string)

def new_icoor(

...)

new_icoor( (Orbital)arg1) -> ICoorOrbitalData : core/chemical/Orbital.hh:98

C++ signature :
    core::chemical::orbitals::ICoorOrbitalData new_icoor(core::chemical::Orbital {lvalue})

new_icoor( (Orbital)arg1) -> ICoorOrbitalData : core/chemical/Orbital.hh:101

C++ signature :
    core::chemical::orbitals::ICoorOrbitalData {lvalue} new_icoor(core::chemical::Orbital {lvalue})

new_icoor( (Orbital)arg1, (ICoorOrbitalData)new_icoor) -> None : core/chemical/Orbital.hh:107

C++ signature :
    void new_icoor(core::chemical::Orbital {lvalue},core::chemical::orbitals::ICoorOrbitalData)

def orbital_type_index(

...)

orbital_type_index( (Orbital)arg1) -> int : core/chemical/Orbital.hh:95

C++ signature :
    unsigned long orbital_type_index(core::chemical::Orbital {lvalue})

orbital_type_index( (Orbital)arg1, (int)atom_type_index) -> None : core/chemical/Orbital.hh:104

C++ signature :
    void orbital_type_index(core::chemical::Orbital {lvalue},unsigned long)

def print(

...)

print( (Orbital)arg1, (OStream)out) -> None : core/chemical/Orbital.hh:87

C++ signature : void print(core::chemical::Orbital {lvalue},std::ostream {lvalue})

class OrbitalAP

Ancestors (in MRO)

  • OrbitalAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (OrbitalAP)arg1) -> Orbital :

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

class OrbitalCAP

Ancestors (in MRO)

  • OrbitalCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (OrbitalCAP)arg1) -> Orbital :

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

class Patch

///////////////////////////////////////////////////////////////////////////////////// A class patching basic ResidueType to create variant types, containing multiple PatchCase

Ancestors (in MRO)

  • Patch
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def applies_to(

...)

applies_to( (Patch)arg1, (ResidueType)rsd) -> bool : can I operate on this residue type?

C++ signature :
    bool applies_to(core::chemical::Patch {lvalue},core::chemical::ResidueType)

applies_to( (Patch)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool applies_to(Patch_exposer_callback {lvalue},core::chemical::ResidueType)

def apply(

...)

apply( (Patch)arg1, (ResidueType)rsd_type) -> ResidueType : returns patched residue, 0 if patch failed

C++ signature :
    boost::shared_ptr<core::chemical::ResidueType> apply(core::chemical::Patch {lvalue},core::chemical::ResidueType)

apply( (Patch)arg1, (ResidueType)rsd_type) -> ResidueType :

C++ signature :
    boost::shared_ptr<core::chemical::ResidueType> apply(Patch_exposer_callback {lvalue},core::chemical::ResidueType)

def name(

...)

name( (Patch)arg1) -> str : unique name of this patch, eg Nter-simple, Cter-full, Phospho, ... ?

C++ signature :
    std::string name(core::chemical::Patch {lvalue})

name( (Patch)arg1) -> str :

C++ signature :
    std::string name(Patch_exposer_callback {lvalue})

def read_file(

...)

read_file( (Patch)arg1, (str)filename) -> None : constructor from file

C++ signature : void read_file(core::chemical::Patch {lvalue},std::string)

def replaces(

...)

replaces( (Patch)arg1, (ResidueType)rsd) -> bool : do I replace this residue type?

C++ signature :
    bool replaces(core::chemical::Patch {lvalue},core::chemical::ResidueType)

replaces( (Patch)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool replaces(Patch_exposer_callback {lvalue},core::chemical::ResidueType)

def types(

...)

types( (Patch)arg1) -> vector1_string : the variant types created by applying this patch

C++ signature :
    utility::vector1<std::string, std::allocator<std::string> > types(core::chemical::Patch {lvalue})

types( (Patch)arg1) -> vector1_string :

C++ signature :
    utility::vector1<std::string, std::allocator<std::string> > types(Patch_exposer_callback {lvalue})

class PatchAP

Ancestors (in MRO)

  • PatchAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PatchAP)arg1) -> Patch :

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

class PatchCAP

Ancestors (in MRO)

  • PatchCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PatchCAP)arg1) -> Patch :

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

class PatchCase

A single case of a patch, eg proline Nterminus is a case of NtermProteinFull

Ancestors (in MRO)

  • PatchCase
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def add_operation(

...)

add_operation( (PatchCase)arg1, (CPP_PatchOperation)operation) -> None : add one more operation in this PatchCase

C++ signature : void add_operation(core::chemical::PatchCase {lvalue},boost::shared_ptr)

def applies_to(

...)

applies_to( (PatchCase)arg1, (ResidueType)rsd) -> bool : whether the PatchCase is applicable to this ResidueType?

C++ signature : bool applies_to(core::chemical::PatchCase {lvalue},core::chemical::ResidueType)

def apply(

...)

apply( (PatchCase)arg1, (ResidueType)rsd_in) -> ResidueType : returns patched residue, 0 if patch failed

C++ signature :
    boost::shared_ptr<core::chemical::ResidueType> apply(core::chemical::PatchCase {lvalue},core::chemical::ResidueType)

apply( (PatchCase)arg1, (ResidueType)rsd_in) -> ResidueType :

C++ signature :
    boost::shared_ptr<core::chemical::ResidueType> apply(PatchCase_exposer_callback {lvalue},core::chemical::ResidueType)

def selector(

...)

selector( (PatchCase)arg1) -> ResidueSelector : to which ResidueTypes this PatchCase applies to?

C++ signature : core::chemical::ResidueSelector {lvalue} selector(core::chemical::PatchCase {lvalue})

class PatchCaseAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PatchCaseAP)arg1) -> PatchCase :

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

class PatchCaseCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PatchCaseCAP)arg1) -> PatchCase :

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

class PatchOperation

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// A single operation that needs to be applied in a residue patch

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def apply(

...)

apply( (PatchOperation)arg1, (ResidueType)rsd) -> bool : Returns true to signal failure, false to indicate success.

C++ signature :
    bool apply(core::chemical::PatchOperation {lvalue},core::chemical::ResidueType {lvalue})

apply( (PatchOperation)arg1, (ResidueType)arg2) -> None :

C++ signature :
    void apply(boost::shared_ptr<PatchOperation_exposer_callback> {lvalue},core::chemical::ResidueType {lvalue})

class PatchOperationAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PatchOperationAP)arg1) -> PatchOperation :

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

class PatchOperationCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PatchOperationCAP)arg1) -> PatchOperation :

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

class PolarHydrogenFilter

///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for all polar hydrogens.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (PolarHydrogenFilter)) -> None : ///////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// The filter responsible for all polar hydrogens.

C++ signature :
    void __init__(_object*,core::chemical::PolarHydrogenFilter)

init( (object)arg1, (object)graph, (AtomTypeSetCAP)atom_types) -> None : core/chemical/ResidueGraphTypes.hh:289

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property> {lvalue},boost::weak_ptr<core::chemical::AtomTypeSet const>)

class PolarHydrogenFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PolarHydrogenFilterAP)arg1) -> PolarHydrogenFilter :

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

class PolarHydrogenFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PolarHydrogenFilterCAP)arg1) -> PolarHydrogenFilter :

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

class PrependMainchainAtom

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// add a mainchain atom before the first mainchain atom

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (PrependMainchainAtom)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// add a mainchain atom before the first mainchain atom

C++ signature :
    void __init__(_object*,core::chemical::PrependMainchainAtom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (PrependMainchainAtom)arg1, (ResidueType)rsd) -> bool : set an atom to be the first mainchain atom

C++ signature :
    bool apply(core::chemical::PrependMainchainAtom {lvalue},core::chemical::ResidueType {lvalue})

apply( (PrependMainchainAtom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(PrependMainchainAtom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class PrependMainchainAtomAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PrependMainchainAtomAP)arg1) -> PrependMainchainAtom :

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

class PrependMainchainAtomCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (PrependMainchainAtomCAP)arg1) -> PrependMainchainAtom :

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

class RealFilter

////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////// /////// PREDICATES for FILTERED GRAPHS /////////////////// ///////////////////////////////////////////////////////// @default A filtered graph that doesn't contain fake/virtual atoms and fake/virtual bonds.

Ancestors (in MRO)

  • RealFilter
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (RealFilter)) -> None : ////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////// /////// PREDICATES for FILTERED GRAPHS /////////////////// ///////////////////////////////////////////////////////// @default A filtered graph that doesn't contain fake/virtual atoms and fake/virtual bonds.

C++ signature :
    void __init__(_object*,core::chemical::RealFilter)

init( (object)arg1, (object)graph) -> None : core/chemical/ResidueGraphTypes.hh:148

C++ signature :
    void __init__(_object*,boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>)

class RealFilterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RealFilterAP)arg1) -> RealFilter :

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

class RealFilterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RealFilterCAP)arg1) -> RealFilter :

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

class RedefineChi

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Redefine a chi angle Added by Andy M. Chen in June 2009 This is needed for certain PTMs

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (int)chino_in, (str)atom1_in, (str)atom2_in, (str)atom3_in, (str)atom4_in) -> None : constructor

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

init( (object)arg1, (RedefineChi)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Redefine a chi angle Added by Andy M. Chen in June 2009 This is needed for certain PTMs

C++ signature :
    void __init__(_object*,core::chemical::RedefineChi)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (RedefineChi)arg1, (ResidueType)rsd) -> bool : redefine a chi angle

C++ signature :
    bool apply(core::chemical::RedefineChi {lvalue},core::chemical::ResidueType {lvalue})

apply( (RedefineChi)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(RedefineChi_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class RedefineChiAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RedefineChiAP)arg1) -> RedefineChi :

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

class RedefineChiCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RedefineChiCAP)arg1) -> RedefineChi :

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

class ResConnID

The ResConnID could more properly be called the ResidueConnector. It stores the data necessary to describe how one ResidueConnection on a conformation::Residue is connected to the rest of the structure (Pose), by listing the other Residue's index and the ResidueConnection index.

Ancestors (in MRO)

  • ResConnID
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ResConnID)) -> None : core/chemical/ResConnID.hh:37

C++ signature :
    void __init__(_object*,core::chemical::ResConnID)

init( (object)arg1, (int)resid, (int)connid) -> None : core/chemical/ResConnID.hh:38

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

def assign(

...)

assign( (ResConnID)arg1, (ResConnID)) -> ResConnID : core/chemical/ResConnID.hh:40

C++ signature : core::chemical::ResConnID assign(core::chemical::ResConnID {lvalue},core::chemical::ResConnID)

def connid(

...)

connid( (ResConnID)arg1) -> int : core/chemical/ResConnID.hh:48

C++ signature :
    unsigned long connid(core::chemical::ResConnID {lvalue})

connid( (ResConnID)arg1, (int)) -> None : core/chemical/ResConnID.hh:49

C++ signature :
    void connid(core::chemical::ResConnID {lvalue},unsigned long)

def incomplete(

...)

incomplete( (ResConnID)arg1) -> bool : core/chemical/ResConnID.hh:51

C++ signature : bool incomplete(core::chemical::ResConnID {lvalue})

def mark_incomplete(

...)

mark_incomplete( (ResConnID)arg1) -> None : core/chemical/ResConnID.hh:52

C++ signature : void mark_incomplete(core::chemical::ResConnID {lvalue})

def resid(

...)

resid( (ResConnID)arg1) -> int : core/chemical/ResConnID.hh:45

C++ signature :
    unsigned long resid(core::chemical::ResConnID {lvalue})

resid( (ResConnID)arg1, (int)) -> None : core/chemical/ResConnID.hh:46

C++ signature :
    void resid(core::chemical::ResConnID {lvalue},unsigned long)

class ResConnIDAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResConnIDAP)arg1) -> ResConnID :

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

class ResConnIDCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResConnIDCAP)arg1) -> ResConnID :

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

class ResidueConnection

A simple class marking atoms at inter-residue connections. Each residue type specifies some number of positions at which it is expecting to form a chemical bond with another residue. Think of them as ports: they are parts of the residue where there are chemical bonds beyond the intra-residue chemical bonds are expected -- places where they can be chemically linked to the outside world. A conformation::Residue will require that its ResidueConnections be fulfilled by other Residues -- the ResConnID class describes how two residues are connected: e.g., the third ResConnID for residue 10 would say "I connect to residue 58 at residue 58's third residue connection" if residue 10 and residue 58 were disulfide bonded as the disulfide connection id is "3" for two mid-protein cystine residues. The advantages of separating ResidueConnections from atoms themselves are that 1) it allows multiple residue connections to stem from the same atom -- useful for single-atom residues, such as coordinated metals (Zn, Mg), and 2) it allows one residue to change its set of atoms without invalidating the bond information (e.g. the atom index) on its partner. For example, if a chain-break were placed between residues 57 and 58, then residue 58 will get an extra C-prev virtual atom, and the index of SG will change. Residue 10, if it had recorded the SG index would have to find SG's new index. If instead, the connection point is represented simply as connection point 3, and if the new residue type (the chainbreak disulfide residue) has the same number of residue connections as the original residue type (it will!) then nothing about residue 10 needs to be updated.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ResidueConnection)) -> None : A simple class marking atoms at inter-residue connections. Each residue type specifies some number of positions at which it is expecting to form a chemical bond with another residue. Think of them as ports: they are parts of the residue where there are chemical bonds beyond the intra-residue chemical bonds are expected -- places where they can be chemically linked to the outside world. A conformation::Residue will require that its ResidueConnections be fulfilled by other Residues -- the ResConnID class describes how two residues are connected: e.g., the third ResConnID for residue 10 would say "I connect to residue 58 at residue 58's third residue connection" if residue 10 and residue 58 were disulfide bonded as the disulfide connection id is "3" for two mid-protein cystine residues. The advantages of separating ResidueConnections from atoms themselves are that 1) it allows multiple residue connections to stem from the same atom -- useful for single-atom residues, such as coordinated metals (Zn, Mg), and 2) it allows one residue to change its set of atoms without invalidating the bond information (e.g. the atom index) on its partner. For example, if a chain-break were placed between residues 57 and 58, then residue 58 will get an extra C-prev virtual atom, and the index of SG will change. Residue 10, if it had recorded the SG index would have to find SG's new index. If instead, the connection point is represented simply as connection point 3, and if the new residue type (the chainbreak disulfide residue) has the same number of residue connections as the original residue type (it will!) then nothing about residue 10 needs to be updated.

C++ signature :
    void __init__(_object*,core::chemical::ResidueConnection)

init( (object)arg1, (int)atomno_in, (object)vertex) -> None : constructor with atom index number

C++ signature :
    void __init__(_object*,int,void*)

def atomno(

...)

atomno( (ResidueConnection)arg1) -> int : get atom index number

C++ signature :
    int atomno(core::chemical::ResidueConnection {lvalue})

atomno( (ResidueConnection)arg1, (int)atomno_in) -> None : set atom index number

C++ signature :
    void atomno(core::chemical::ResidueConnection {lvalue},unsigned long)

def icoor(

...)

icoor( (ResidueConnection)arg1) -> AtomICoor : get atom's AtomICoor

C++ signature :
    core::chemical::AtomICoor icoor(core::chemical::ResidueConnection {lvalue})

icoor( (ResidueConnection)arg1, (AtomICoor)ic) -> None : set atom's AtomICoor

C++ signature :
    void icoor(core::chemical::ResidueConnection {lvalue},core::chemical::AtomICoor)

def index(

...)

index( (ResidueConnection)arg1) -> int : core/chemical/ResidueConnection.hh:147

C++ signature :
    int index(core::chemical::ResidueConnection {lvalue})

index( (ResidueConnection)arg1, (int)index_in) -> None : core/chemical/ResidueConnection.hh:148

C++ signature :
    void index(core::chemical::ResidueConnection {lvalue},int)

def vertex(

...)

vertex( (ResidueConnection)arg1) -> object : get the vetex associated with this residue connection

C++ signature :
    void* vertex(core::chemical::ResidueConnection {lvalue})

vertex( (ResidueConnection)arg1, (object)vertex) -> None : set the vertex of this residue connection

C++ signature :
    void vertex(core::chemical::ResidueConnection {lvalue},void*)

class ResidueConnectionAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueConnectionAP)arg1) -> ResidueConnection :

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

class ResidueConnectionCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueConnectionCAP)arg1) -> ResidueConnection :

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

class ResidueDatabaseIO

core/chemical/ResidueDatabaseIO.hh:33

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ResidueDatabaseIO)) -> None : core/chemical/ResidueDatabaseIO.hh:33

C++ signature :
    void __init__(_object*,core::chemical::ResidueDatabaseIO)

def get_all_residues_in_database(

...)

get_all_residues_in_database( (ResidueDatabaseIO)arg1, (object)db_session) -> vector1_string : core/chemical/ResidueDatabaseIO.hh:116

C++ signature : utility::vector1 > get_all_residues_in_database(core::chemical::ResidueDatabaseIO {lvalue},boost::shared_ptr)

def get_version(

...)

get_version( (ResidueDatabaseIO)arg1) -> float : core/chemical/ResidueDatabaseIO.hh:100

C++ signature : double get_version(core::chemical::ResidueDatabaseIO {lvalue})

def initialize(

...)

initialize( (ResidueDatabaseIO)arg1, (object)db_session) -> None : write the schema

C++ signature : void initialize(core::chemical::ResidueDatabaseIO {lvalue},boost::shared_ptr)

def read_residuetype_from_database(

...)

read_residuetype_from_database( (ResidueDatabaseIO)arg1, (AtomTypeSet)atom_types, (ElementSet)elements, (MMAtomTypeSet)mm_atom_types, (OrbitalTypeSet)orbital_atom_types, (str)residue_type_set_name, (str)residue_type_name, (object)db_session) -> ResidueType : core/chemical/ResidueDatabaseIO.hh:114

C++ signature : boost::shared_ptr read_residuetype_from_database(core::chemical::ResidueDatabaseIO {lvalue},boost::shared_ptr,boost::shared_ptr,boost::shared_ptr,boost::shared_ptr,std::string,std::string,boost::shared_ptr)

def write_residuetype_to_database(

...)

write_residuetype_to_database( (ResidueDatabaseIO)arg1, (str)residue_type_set_name, (ResidueType)res_type, (object)db_session) -> None : core/chemical/ResidueDatabaseIO.hh:105

C++ signature : void write_residuetype_to_database(core::chemical::ResidueDatabaseIO {lvalue},std::string,core::chemical::ResidueType,boost::shared_ptr)

def write_schema_to_db(

...)

write_schema_to_db( (ResidueDatabaseIO)arg1, (object)db_session) -> None : generate the table schemas and write them to the database

C++ signature : void write_schema_to_db(core::chemical::ResidueDatabaseIO {lvalue},boost::shared_ptr)

class ResidueDatabaseIOAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueDatabaseIOAP)arg1) -> ResidueDatabaseIO :

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

class ResidueDatabaseIOCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueDatabaseIOCAP)arg1) -> ResidueDatabaseIO :

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

class ResidueLoader

core/chemical/ResidueLoader.hh:32

Ancestors (in MRO)

  • ResidueLoader
  • rosetta.basic.resource_manager._basic_resource_manager_.ResourceLoader
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ResidueLoader)) -> None : core/chemical/ResidueLoader.hh:32

C++ signature :
    void __init__(_object*,core::chemical::ResidueLoader)

def create_resource(

...)

create_resource( (ResidueLoader)arg1, (ResourceOptions)options, (str)locator_id, (std_istream)istream) -> object : returns a pointer to a ResidueType object originated from the data_source specified to the ResourceManager

C++ signature :
    boost::shared_ptr<utility::pointer::ReferenceCount> create_resource(core::chemical::ResidueLoader {lvalue},basic::resource_manager::ResourceOptions,std::string,std::istream {lvalue})

create_resource( (ResidueLoader)arg1, (ResourceOptions)options, (str)locator_id, (std_istream)istream) -> object :

C++ signature :
    boost::shared_ptr<utility::pointer::ReferenceCount> create_resource(ResidueLoader_exposer_callback {lvalue},basic::resource_manager::ResourceOptions,std::string,std::istream {lvalue})

def default_options(

...)

default_options( (ResidueLoader)arg1) -> ResourceOptions : core/chemical/ResidueLoader.hh:48

C++ signature :
    boost::shared_ptr<basic::resource_manager::ResourceOptions> default_options(core::chemical::ResidueLoader {lvalue})

default_options( (ResidueLoader)arg1) -> ResourceOptions :

C++ signature :
    boost::shared_ptr<basic::resource_manager::ResourceOptions> default_options(ResidueLoader_exposer_callback {lvalue})

class ResidueLoaderAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueLoaderAP)arg1) -> ResidueLoader :

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

class ResidueLoaderCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueLoaderCAP)arg1) -> ResidueLoader :

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

class ResidueLoaderCreator

core/chemical/ResidueLoaderCreator.hh:25

Ancestors (in MRO)

  • ResidueLoaderCreator
  • rosetta.basic.resource_manager._basic_resource_manager_.ResourceLoaderCreator
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def create_resource_loader(

...)

create_resource_loader( (ResidueLoaderCreator)arg1) -> ResourceLoader : core/chemical/ResidueLoaderCreator.hh:29

C++ signature :
    boost::shared_ptr<basic::resource_manager::ResourceLoader> create_resource_loader(core::chemical::ResidueLoaderCreator {lvalue})

create_resource_loader( (ResidueLoaderCreator)arg1) -> ResourceLoader :

C++ signature :
    boost::shared_ptr<basic::resource_manager::ResourceLoader> create_resource_loader(ResidueLoaderCreator_exposer_callback {lvalue})

def loader_type(

...)

loader_type( (ResidueLoaderCreator)arg1) -> str : core/chemical/ResidueLoaderCreator.hh:32

C++ signature :
    std::string loader_type(core::chemical::ResidueLoaderCreator {lvalue})

loader_type( (ResidueLoaderCreator)arg1) -> str :

C++ signature :
    std::string loader_type(ResidueLoaderCreator_exposer_callback {lvalue})

class ResidueLoaderCreatorAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueLoaderCreatorAP)arg1) -> ResidueLoaderCreator :

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

class ResidueLoaderCreatorCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueLoaderCreatorCAP)arg1) -> ResidueLoaderCreator :

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

class ResidueLoaderOptions

core/chemical/ResidueLoaderOptions.hh:31

Ancestors (in MRO)

  • ResidueLoaderOptions
  • rosetta.basic.resource_manager._basic_resource_manager_.ResourceOptions
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ResidueLoaderOptions)) -> None : core/chemical/ResidueLoaderOptions.hh:31

C++ signature :
    void __init__(_object*,core::chemical::ResidueLoaderOptions)

def atom_type_set_tag(

...)

atom_type_set_tag( (ResidueLoaderOptions)arg1) -> str : core/chemical/ResidueLoaderOptions.hh:46

C++ signature : std::string atom_type_set_tag(core::chemical::ResidueLoaderOptions {lvalue})

def element_set_tag(

...)

element_set_tag( (ResidueLoaderOptions)arg1) -> str : core/chemical/ResidueLoaderOptions.hh:48

C++ signature : std::string element_set_tag(core::chemical::ResidueLoaderOptions {lvalue})

def mm_atom_type_set_tag(

...)

mm_atom_type_set_tag( (ResidueLoaderOptions)arg1) -> str : core/chemical/ResidueLoaderOptions.hh:47

C++ signature : std::string mm_atom_type_set_tag(core::chemical::ResidueLoaderOptions {lvalue})

def name(

...)

name( (ResourceOptions)arg1) -> str : A name given to a particular ResourceOptions instance. This function allows for better error message delivery.

C++ signature :
    std::string name(basic::resource_manager::ResourceOptions {lvalue})

name( (ResourceOptions)arg1, (str)setting) -> None : Set the name for this %ResoureOptions instance.

C++ signature :
    void name(basic::resource_manager::ResourceOptions {lvalue},std::string)

def orbital_set_tag(

...)

orbital_set_tag( (ResidueLoaderOptions)arg1) -> str : core/chemical/ResidueLoaderOptions.hh:50

C++ signature : std::string orbital_set_tag(core::chemical::ResidueLoaderOptions {lvalue})

def parse_my_tag(

...)

parse_my_tag( (ResidueLoaderOptions)arg1, (Tag)tag) -> None : core/chemical/ResidueLoaderOptions.hh:40

C++ signature :
    void parse_my_tag(core::chemical::ResidueLoaderOptions {lvalue},boost::shared_ptr<utility::tag::Tag const>)

parse_my_tag( (ResidueLoaderOptions)arg1, (Tag)tag) -> None :

C++ signature :
    void parse_my_tag(ResidueLoaderOptions_exposer_callback {lvalue},boost::shared_ptr<utility::tag::Tag const>)

def residue_type_set_tag(

...)

residue_type_set_tag( (ResidueLoaderOptions)arg1) -> str : core/chemical/ResidueLoaderOptions.hh:49

C++ signature : std::string residue_type_set_tag(core::chemical::ResidueLoaderOptions {lvalue})

def show(

...)

show( (ResidueLoaderOptions)arg1, (OStream)out) -> None : Describe this instance to a given output stream

C++ signature :
    void show(core::chemical::ResidueLoaderOptions {lvalue},std::ostream {lvalue})

show( (ResidueLoaderOptions)arg1, (OStream)out) -> None :

C++ signature :
    void show(ResidueLoaderOptions_exposer_callback {lvalue},std::ostream {lvalue})

def type(

...)

type( (ResidueLoaderOptions)arg1) -> str : core/chemical/ResidueLoaderOptions.hh:44

C++ signature :
    std::string type(core::chemical::ResidueLoaderOptions {lvalue})

type( (ResidueLoaderOptions)arg1) -> str :

C++ signature :
    std::string type(ResidueLoaderOptions_exposer_callback {lvalue})

class ResidueLoaderOptionsAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueLoaderOptionsAP)arg1) -> ResidueLoaderOptions :

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

class ResidueLoaderOptionsCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueLoaderOptionsCAP)arg1) -> ResidueLoaderOptions :

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

class ResidueLoaderOptionsCreator

core/chemical/ResidueLoaderOptionsCreator.hh:28

Ancestors (in MRO)

  • ResidueLoaderOptionsCreator
  • rosetta.basic.resource_manager._basic_resource_manager_.ResourceOptionsCreator
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def create_options(

...)

create_options( (ResidueLoaderOptionsCreator)arg1) -> ResourceOptions : core/chemical/ResidueLoaderOptionsCreator.hh:32

C++ signature :
    boost::shared_ptr<basic::resource_manager::ResourceOptions> create_options(core::chemical::ResidueLoaderOptionsCreator {lvalue})

create_options( (ResidueLoaderOptionsCreator)arg1) -> ResourceOptions :

C++ signature :
    boost::shared_ptr<basic::resource_manager::ResourceOptions> create_options(ResidueLoaderOptionsCreator_exposer_callback {lvalue})

def options_type(

...)

options_type( (ResidueLoaderOptionsCreator)arg1) -> str : core/chemical/ResidueLoaderOptionsCreator.hh:31

C++ signature :
    std::string options_type(core::chemical::ResidueLoaderOptionsCreator {lvalue})

options_type( (ResidueLoaderOptionsCreator)arg1) -> str :

C++ signature :
    std::string options_type(ResidueLoaderOptionsCreator_exposer_callback {lvalue})

class ResidueLoaderOptionsCreatorAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueLoaderOptionsCreatorAP)arg1) -> ResidueLoaderOptionsCreator :

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

class ResidueLoaderOptionsCreatorCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueLoaderOptionsCreatorCAP)arg1) -> ResidueLoaderOptionsCreator :

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

class ResidueProperties

This is a container class for the large assortment of properties associated with ResidueTypes. It prevents ResidueType from becoming cluttered with an over-abundance of properties and related methods. @remarks This is the first step in a major refactor of how properties are handled in Rosetta. For now, I have just gathered all the properties related code into one place, so that changes to the system can be more readily made. Previous behavior has been maintained. In the future, I have several ideas for further improvements. ~Labonte

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1, (ResidueType)residue_type) -> None : Constructor with owning ResidueType

C++ signature :
    void __init__(_object*,core::chemical::ResidueType const*)

init( (object)arg1, (ResidueProperties)object_to_copy, (ResidueType)new_owner) -> None : Copy constructor

C++ signature :
    void __init__(_object*,core::chemical::ResidueProperties,core::chemical::ResidueType const*)

def add_numeric_property(

...)

add_numeric_property( (ResidueProperties)arg1, (str)tag, (float)value) -> None : Add a numeric property.

C++ signature : void add_numeric_property(core::chemical::ResidueProperties {lvalue},std::string,double)

def add_string_property(

...)

add_string_property( (ResidueProperties)arg1, (str)tag, (str)value) -> None : Add a string property.

C++ signature : void add_string_property(core::chemical::ResidueProperties {lvalue},std::string,std::string)

def enable_custom_variant_types(

...)

enable_custom_variant_types( (ResidueProperties)arg1) -> None : Turn on the ability to create VariantTypes "on-the-fly". Custom" VariantTypes as strings are permitted for the enzdes and metalloproteins cases. Do not enable unless you have a good reason to, as string look-ups are less efficient and more error-prone.

C++ signature : void enable_custom_variant_types(core::chemical::ResidueProperties {lvalue})

def get_list_of_custom_variants(

...)

get_list_of_custom_variants( (ResidueProperties)arg1) -> vector1_string : Return a list of custom VariantTypes only for this ResidueType.

C++ signature : utility::vector1 > get_list_of_custom_variants(core::chemical::ResidueProperties {lvalue})

def get_list_of_properties(

...)

get_list_of_properties( (ResidueProperties)arg1) -> vector1_string : Generate and return a list of strings representing the properties of this ResidueType.

C++ signature : utility::vector1 > get_list_of_properties(core::chemical::ResidueProperties {lvalue})

def get_list_of_variants(

...)

get_list_of_variants( (ResidueProperties)arg1) -> vector1_string : Generate and return a list of strings representing the VariantTypes of this ResidueType.

C++ signature : utility::vector1 > get_list_of_variants(core::chemical::ResidueProperties {lvalue})

def has_custom_variant_types(

...)

has_custom_variant_types( (ResidueProperties)arg1) -> bool : Does this ResidueType contain additional VariantTypes than the standard list?

C++ signature : bool has_custom_variant_types(core::chemical::ResidueProperties {lvalue})

def has_property(

...)

has_property( (ResidueProperties)arg1, (ResidueProperty)property) -> bool : Get whether or not this ResidueType has the requested property.

C++ signature :
    bool has_property(core::chemical::ResidueProperties {lvalue},core::chemical::ResidueProperty)

has_property( (ResidueProperties)arg1, (str)property) -> bool : Get whether or not this ResidueType has the requested property by string.

C++ signature :
    bool has_property(core::chemical::ResidueProperties {lvalue},std::string)

def is_variant_type(

...)

is_variant_type( (ResidueProperties)arg1, (VariantType)variant_type) -> bool : Get whether or not this ResidueType is of the requested VariantType.

C++ signature :
    bool is_variant_type(core::chemical::ResidueProperties {lvalue},core::chemical::VariantType)

is_variant_type( (ResidueProperties)arg1, (str)variant_type) -> bool : Get whether or not this ResidueType is of the requested VariantType by string.

C++ signature :
    bool is_variant_type(core::chemical::ResidueProperties {lvalue},std::string)

def numeric_properties(

...)

numeric_properties( (ResidueProperties)arg1) -> map_string_Real : core/chemical/ResidueProperties.hh:141

C++ signature : std::map, std::allocator > > numeric_properties(core::chemical::ResidueProperties {lvalue})

def set_property(

...)

set_property( (ResidueProperties)arg1, (ResidueProperty)property, (bool)setting) -> None : Set the status of the given property for this ResidueType.

C++ signature :
    void set_property(core::chemical::ResidueProperties {lvalue},core::chemical::ResidueProperty,bool)

set_property( (ResidueProperties)arg1, (str)property, (bool)setting) -> None : Set the status of the given property for this ResidueType by string.

C++ signature :
    void set_property(core::chemical::ResidueProperties {lvalue},std::string,bool)

def set_variant_type(

...)

set_variant_type( (ResidueProperties)arg1, (VariantType)variant_type, (bool)setting) -> None : Set the status of a given VariantType for this ResidueType.

C++ signature :
    void set_variant_type(core::chemical::ResidueProperties {lvalue},core::chemical::VariantType,bool)

set_variant_type( (ResidueProperties)arg1, (str)variant_type, (bool)setting) -> None : Set the status of a given VariantType for this ResidueType by string.

C++ signature :
    void set_variant_type(core::chemical::ResidueProperties {lvalue},std::string,bool)

def show(

...)

show( (ResidueProperties)arg1, (OStream)output) -> None : Generate string representation of ResidueProperties for debugging purposes.

C++ signature :
    void show(core::chemical::ResidueProperties {lvalue},std::ostream {lvalue})

show( (ResidueProperties)arg1, (OStream)output) -> None :

C++ signature :
    void show(ResidueProperties_exposer_callback {lvalue},std::ostream {lvalue})

def string_properties(

...)

string_properties( (ResidueProperties)arg1) -> map_string_string : core/chemical/ResidueProperties.hh:147

C++ signature : std::map, std::allocator > > string_properties(core::chemical::ResidueProperties {lvalue})

class ResiduePropertiesAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResiduePropertiesAP)arg1) -> ResidueProperties :

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

class ResiduePropertiesCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResiduePropertiesCAP)arg1) -> ResidueProperties :

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

class ResidueProperty

Enumerators for all the properties that can be assigned to a ResidueType.

Ancestors (in MRO)

Class variables

var ACETYLAMINO_SUGAR

var ACETYLATED_NTERMINUS

var ACETYL_SUGAR

var ADDUCT

var ALDONIC_ACID

var ALDOSE

var ALPHA_AA

var ALPHA_SUGAR

var AMINO_SUGAR

var AROMATIC

var BETA_AA

var BETA_SUGAR

var BRANCH_LOWER_TERMINUS

var BRANCH_POINT

var C1_MODIFIED

var C2_MODIFIED

var C3_MODIFIED

var C4_MODIFIED

var C5_MODIFIED

var C6_MODIFIED

var C7_MODIFIED

var C8_MODIFIED

var C9_MODIFIED

var CARBOHYDRATE

var CHARGED

var COARSE

var CYCLIC

var DEOXY_SUGAR

var DISULFIDE_BONDED

var DNA

var D_AA

var D_SUGAR

var FIRST_PROPERTY

var FORMS_DISULFIDE_BOND

var FURANOSE

var GAMMA_AA

var GLYCOSIDE

var KETOSE

var LIGAND

var LIPID

var LOWERTERM_TRUNC

var LOWER_TERMINUS

var L_AA

var L_SUGAR

var MEMBRANE

var METAL

var METALBINDING

var METHYLATED_CTERMINUS

var N_PROPERTIES

var OXETOSE

var OXIROSE

var PEPTOID

var PHOSPHATE

var PHOSPHONATE

var PHOSPHONATE_UPPER

var POLAR

var POLYMER

var PROTEIN

var PYRANOSE

var RNA

var SC_ORBITALS

var SEPTANOSE

var SIALIC_ACID

var SRI

var SURFACE

var TAUTOMER

var TRIAZOLEMER

var UPPERTERM_TRUNC

var UPPER_TERMINUS

var URONIC_ACID

var VIRTUAL_RESIDUE

var WATER

var denominator

var imag

var name

var names

var numerator

var real

var values

class ResidueSelector

///////////////////////////////////////////////////////////////////////////////////// A class picking out a subset of ResidueType by multiple criteria

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def add_line(

...)

add_line( (ResidueSelector)arg1, (str)line) -> ResidueSelector : core/chemical/ResidueSelector.hh:341

C++ signature : core::chemical::ResidueSelector {lvalue} add_line(core::chemical::ResidueSelector {lvalue},std::string)

def clear(

...)

clear( (ResidueSelector)arg1) -> ResidueSelector : core/chemical/ResidueSelector.hh:355

C++ signature : core::chemical::ResidueSelector {lvalue} clear(core::chemical::ResidueSelector {lvalue})

def exclude_variants(

...)

exclude_variants( (ResidueSelector)arg1) -> ResidueSelector : core/chemical/ResidueSelector.hh:389

C++ signature : core::chemical::ResidueSelector {lvalue} exclude_variants(core::chemical::ResidueSelector {lvalue})

def match_variants(

...)

match_variants( (ResidueSelector)arg1, (ResidueType)rsd_type_to_match) -> ResidueSelector : core/chemical/ResidueSelector.hh:397

C++ signature : core::chemical::ResidueSelector {lvalue} match_variants(core::chemical::ResidueSelector {lvalue},core::chemical::ResidueType)

def select(

...)

select( (ResidueSelector)arg1, (ResidueTypeSet)rsd_set) -> object : core/chemical/ResidueSelector.hh:405

C++ signature : utility::vector1, std::allocator > > select(core::chemical::ResidueSelector {lvalue},core::chemical::ResidueTypeSet)

def set_aa(

...)

set_aa( (ResidueSelector)arg1, (AA)aa) -> ResidueSelector : core/chemical/ResidueSelector.hh:371

C++ signature : core::chemical::ResidueSelector {lvalue} set_aa(core::chemical::ResidueSelector {lvalue},core::chemical::AA)

def set_name1(

...)

set_name1( (ResidueSelector)arg1, (str)n) -> ResidueSelector : core/chemical/ResidueSelector.hh:363

C++ signature : core::chemical::ResidueSelector {lvalue} set_name1(core::chemical::ResidueSelector {lvalue},char)

def set_property(

...)

set_property( (ResidueSelector)arg1, (str)property) -> ResidueSelector : core/chemical/ResidueSelector.hh:380

C++ signature : core::chemical::ResidueSelector {lvalue} set_property(core::chemical::ResidueSelector {lvalue},std::string)

class ResidueSelectorAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueSelectorAP)arg1) -> ResidueSelector :

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

class ResidueSelectorCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueSelectorCAP)arg1) -> ResidueSelector :

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

class ResidueSelectorSingle

///////////////////////////////////////////////////////////////////////////////////// A base class for defining a ResidueSelector by a single criterion

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1, (bool)result) -> None : core/chemical/ResidueSelector.hh:61

C++ signature : void init(_object*,bool)

def desired_result(

...)

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class ResidueSelectorSingleAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueSelectorSingleAP)arg1) -> ResidueSelectorSingle :

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

class ResidueSelectorSingleCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueSelectorSingleCAP)arg1) -> ResidueSelectorSingle :

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

class ResidueType

A class for defining a type of residue This class contains the "chemical" information for residues as well as the ideal xyz and internal coordinates for a residue (generated xyz coordinates are found in core/conformation/Residue.hh). A ResidueType in Rosetta can be a ligand, DNA, amino acid, or basically anything. ResidueTypes are generated through .params files, which are read from the database chemical/residue_types. For ligands, a parameter has to be provided to rosetta through the -extra_res_fa flag. Primary data are set through the residue_io.cc class. The primary data that are set are: atoms, mmatoms, orbitals, and properties of the particular ResidueType. These properties can be modified through patches, which create new ResidueTypes, and are controlled through PatchOperations.cc. The data structure of a ResidueType is based on a boost::graph implementation. Vertex descriptors (VD, yeah, I know, the name is kind of bad) are the atoms, while the edge descriptors (ED, yet another bad name) are the bonds. Initially, when a ResidueType is constructed, the following primary data are set: atom_base_; chi_atoms_; nu_atoms_; mainchain_atoms_; nbr_atom_; actcoord_atoms_; cut_bond_neighbor_; atom_shadowed_; When this data is set, it is set based on vertex descriptors. Because vertex descriptors never change, like atom indices, there is no need to reorder this primary data; however, because Rosetta relies heavily on atom indices to access data, atom indices for the above data have to be generated. To do this, when finalized is called, a function specifically designed to generate the atom indices for the primary data is called: generate_atom_indices. This function iterates over the vertex descriptors assigned in the primary data and creates private data based on atom indices. For example, atom_base_ has atom_base_indices_. When the function atom_base(atomno) is called, the private datum atom_base_indices_ is called. This allows for the external interface of ResidueType to be accessed by atom indices while the internal functions in ResidueType work off of vertex descriptors. This also removes the need to have the former old2new reordering scheme. Atoms: Setting of atoms includes indexing the atoms into vectors, saving their names into vectors/maps, saving the associated mm_atom_type into a vector, saving bond connections into vectors, etc, etc. On any given residue, the heavy atoms are put into the vector first, (their indices are first,) and hydrogens are put in last. Properties: Properties of a residue include things like DNA, PROTEIN, CHARGED, etc. These properties indicate the type of residue it is and what properties are associated with the residue. They are set when read in. To add new ResidueProperties, add them to core/chemical/residue_properties/general_properties.list. Orbitals: Orbitals are indexed separately from atoms. They function much the same way as atoms, except for some key differences. To find atoms bonded to orbitals, you must provide the atom index, not the orbital index. (I haven't figured out how to get the reverse to work because of the separate indices.) Orbital xyz coordinates are not updated when atom coordinates are. This is to keep speed consistent with just having atoms. To output the orbitals, use the flag -output_orbitals.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1, (AtomTypeSet)atom_types, (ElementSet)element_types, (MMAtomTypeSet)mm_atom_types, (OrbitalTypeSet)orbital_types) -> None : constructor We use the AtomTypeSet object to assign atom_types to atoms inside add_atom, and to identify (polar) hydrogens, acceptors, etc.

C++ signature :
    void __init__(_object*,boost::shared_ptr<core::chemical::AtomTypeSet const>,boost::shared_ptr<core::chemical::ElementSet const>,boost::shared_ptr<core::chemical::MMAtomTypeSet const>,boost::shared_ptr<core::chemical::orbitals::OrbitalTypeSet const>)

init( (object)arg1, (ResidueType)residue_type) -> None : core/chemical/ResidueType.hh:155

C++ signature :
    void __init__(_object*,core::chemical::ResidueType)

def Haro_index(

...)

Haro_index( (ResidueType)arg1) -> vector1_Size : return indices of aromatic Hydrogens

C++ signature : utility::vector1 > Haro_index(core::chemical::ResidueType {lvalue})

def Hpol_index(

...)

Hpol_index( (ResidueType)arg1) -> vector1_Size : return indices of polar Hydrogens

C++ signature : utility::vector1 > Hpol_index(core::chemical::ResidueType {lvalue})

def Hpos_apolar(

...)

Hpos_apolar( (ResidueType)arg1) -> vector1_Size : indices of non-polar hydrogens as potential carbon Hbond donors

C++ signature : utility::vector1 > Hpos_apolar(core::chemical::ResidueType {lvalue})

def Hpos_polar(

...)

Hpos_polar( (ResidueType)arg1) -> vector1_Size : indices of polar hydrogens as Hbond donors

C++ signature : utility::vector1 > Hpos_polar(core::chemical::ResidueType {lvalue})

def Hpos_polar_sc(

...)

Hpos_polar_sc( (ResidueType)arg1) -> vector1_Size : core/chemical/ResidueType.hh:466

C++ signature : utility::vector1 > Hpos_polar_sc(core::chemical::ResidueType {lvalue})

def RNA_type(

...)

RNA_type( (ResidueType)arg1) -> object : ////////////////////////////////////////////////////////////

C++ signature : core::chemical::rna::RNA_ResidueType RNA_type(core::chemical::ResidueType {lvalue})

def aa(

...)

aa( (ResidueType)arg1, (AA)type) -> None : //////////////////////////////////////////////////////////////////////// set our aa-type (could be "UNK")

C++ signature :
    void aa(core::chemical::ResidueType {lvalue},core::chemical::AA)

aa( (ResidueType)arg1, (str)type) -> None : set our aa-type (could be "UNK")

C++ signature :
    void aa(core::chemical::ResidueType {lvalue},std::string)

aa( (ResidueType)arg1) -> AA : our traditional residue type, if any Used for knowledge-based scores, dunbrack, etc. could be "aa_unk". AA is an enum. There are values for the 20 standard amino acids, the 19 canonical D-amino acids, common beta-amino acids and nucleic acids, and aa_unk as a general catch-all.

C++ signature :
    core::chemical::AA aa(core::chemical::ResidueType {lvalue})

def abase2(

...)

abase2( (ResidueType)arg1, (int)atomno) -> int : get index of an atom's second base atom

C++ signature : unsigned long abase2(core::chemical::ResidueType {lvalue},unsigned long)

def acceptor_atoms(

...)

acceptor_atoms( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:1239

C++ signature : boost::filtered_graph, boost::keep_all, core::chemical::AcceptorAtomFilter> acceptor_atoms(core::chemical::ResidueType {lvalue})

def accpt_pos(

...)

accpt_pos( (ResidueType)arg1) -> vector1_Size : indices of atoms as Hbond acceptors

C++ signature : utility::vector1 > accpt_pos(core::chemical::ResidueType {lvalue})

def accpt_pos_sc(

...)

accpt_pos_sc( (ResidueType)arg1) -> vector1_Size : indices of atoms as Hbond acceptors

C++ signature : utility::vector1 > accpt_pos_sc(core::chemical::ResidueType {lvalue})

def actcoord_atoms(

...)

actcoord_atoms( (ResidueType)arg1) -> vector1_Size : get indices for atoms used to define actcoord

C++ signature : utility::vector1 > actcoord_atoms(core::chemical::ResidueType {lvalue})

def add_actcoord_atom(

...)

add_actcoord_atom( (ResidueType)arg1, (str)atom) -> None : add an atom to the list for calculating actcoord center

C++ signature : void add_actcoord_atom(core::chemical::ResidueType {lvalue},std::string)

def add_adduct(

...)

add_adduct( (ResidueType)arg1, (Adduct)adduct_in) -> None : core/chemical/ResidueType.hh:2075

C++ signature : void add_adduct(core::chemical::ResidueType {lvalue},core::chemical::Adduct {lvalue})

def add_atom(

...)

add_atom( (ResidueType)arg1, (str)atom_name, (str)atom_type_name, (str)mm_atom_type_name, (float)charge) -> object : /////////////////////////////////////////////////////////////////// //////////////////////atoms//////////////////////////////////////// /////////////////////////////////////////////////////////////////// add an atom into this residue Will return the vertex descriptor of the added atom.

C++ signature :
    void* add_atom(core::chemical::ResidueType {lvalue},std::string,std::string,std::string,double)

add_atom( (ResidueType)arg1 [, (str)atom_name='']) -> object : add an atom into this residue, with just the name. Will return the vertex descriptor of the added atom.

C++ signature :
    void* add_atom(core::chemical::ResidueType {lvalue} [,std::string=''])

def add_atom_alias(

...)

add_atom_alias( (ResidueType)arg1, (str)rosetta_atom, (str)alias) -> None : Add an alias name for an atom.

C++ signature : void add_atom_alias(core::chemical::ResidueType {lvalue},std::string,std::string)

def add_bond(

...)

add_bond( (ResidueType)arg1, (str)atom_name1, (str)atom_name2 [, (BondName)bondLabel=rosetta.core.chemical.core_chemical.BondName.SingleBond]) -> None : core/chemical/ResidueType.hh:1020

C++ signature :
    void add_bond(core::chemical::ResidueType {lvalue},std::string,std::string [,core::chemical::BondName=rosetta.core.chemical._core_chemical_.BondName.SingleBond])

add_bond( (ResidueType)arg1, (object)atom1, (object)atom2 [, (BondName)bondLabel=rosetta.core.chemical.core_chemical.BondName.SingleBond]) -> None : core/chemical/ResidueType.hh:1023

C++ signature :
    void add_bond(core::chemical::ResidueType {lvalue},void*,void* [,core::chemical::BondName=rosetta.core.chemical._core_chemical_.BondName.SingleBond])

def add_chi(

...)

add_chi( (ResidueType)arg1, (int)chino, (object)atom1, (object)atom2, (object)atom3, (object)atom4) -> None : /////////////////////////////////////////////////////////////////// //////////////////////residues///////////////////////////////////// /////////////////////////////////////////////////////////////////// Add a chi (side-chain) angle defined by four atoms.

C++ signature :
    void add_chi(core::chemical::ResidueType {lvalue},unsigned long,void*,void*,void*,void*)

add_chi( (ResidueType)arg1, (object)atom1, (object)atom2, (object)atom3, (object)atom4) -> None : Add a chi (side-chain) angle defined by four atoms.

C++ signature :
    void add_chi(core::chemical::ResidueType {lvalue},void*,void*,void*,void*)

add_chi( (ResidueType)arg1, (int)chino, (str)atom_name1, (str)atom_name2, (str)atom_name3, (str)atom_name4) -> None : Add a chi (side-chain) angle defined by four atoms.

C++ signature :
    void add_chi(core::chemical::ResidueType {lvalue},unsigned long,std::string,std::string,std::string,std::string)

add_chi( (ResidueType)arg1, (str)atom_name1, (str)atom_name2, (str)atom_name3, (str)atom_name4) -> None : Add a chi (side-chain) angle defined by four atoms to the end of the list of chis.

C++ signature :
    void add_chi(core::chemical::ResidueType {lvalue},std::string,std::string,std::string,std::string)

def add_chi_rotamer(

...)

add_chi_rotamer( (ResidueType)arg1, (int)chino, (float)mean, (float)sdev) -> None : Add a rotamer bin for a given chi.

C++ signature : void add_chi_rotamer(core::chemical::ResidueType {lvalue},unsigned long,double,double)

def add_chi_rotamer_to_last_chi(

...)

add_chi_rotamer_to_last_chi( (ResidueType)arg1, (float)mean, (float)sdev) -> None : Adds a chi rotamer bin to the highest-indexed chi in the list of chis for this ResidueType.

C++ signature : void add_chi_rotamer_to_last_chi(core::chemical::ResidueType {lvalue},double,double)

def add_cut_bond(

...)

add_cut_bond( (ResidueType)arg1, (str)atom_name1, (str)atom_name2) -> None : add a bond between atom1 and atom2, if bond type is not specified, default to a SingleBond

C++ signature : void add_cut_bond(core::chemical::ResidueType {lvalue},std::string,std::string)

def add_metalbinding_atom(

...)

add_metalbinding_atom( (ResidueType)arg1, (str)atom_name) -> None : Add an atom to the list of atoms that can potentially form a bond to a metal ion. Note that the atom must exist in the residue type (the function checks for this at runtime). Vikram K. Mulligan (vmullig@uw.edu)

C++ signature : void add_metalbinding_atom(core::chemical::ResidueType {lvalue},std::string)

def add_nu(

...)

add_nu( (ResidueType)arg1, (int)nu_index, (str)atom_name1, (str)atom_name2, (str)atom_name3, (str)atom_name4) -> None : Add a nu (internal cyclic) angle defined by four atoms.

C++ signature : void add_nu(core::chemical::ResidueType {lvalue},unsigned long,std::string,std::string,std::string,std::string)

def add_numeric_property(

...)

add_numeric_property( (ResidueType)arg1, (str)tag, (float)value) -> None : Add a numeric property.

C++ signature : void add_numeric_property(core::chemical::ResidueType {lvalue},std::string,double)

def add_orbital(

...)

add_orbital( (ResidueType)arg1, (str)orbital_name, (str)orbital_type_name) -> None : /////////////////////////////////////////////////////////////////// //////////////////////orbitals///////////////////////////////////// /////////////////////////////////////////////////////////////////// add an orbital onto a residue based upon atom

C++ signature : void add_orbital(core::chemical::ResidueType {lvalue},std::string {lvalue},std::string {lvalue})

def add_orbital_bond(

...)

add_orbital_bond( (ResidueType)arg1, (str)atom_name1, (str)orbital_name) -> None : add an orbital bond between an atom and an orbital. NOTE!!!!! This is indexed based upon atoms, not orbitals. That means that in your params file you must have the atom as the first and orbital as the second.

C++ signature : void add_orbital_bond(core::chemical::ResidueType {lvalue},std::string,std::string)

def add_property(

...)

add_property( (ResidueType)arg1, (str)property) -> None : Add a property to this ResidueType.

C++ signature : void add_property(core::chemical::ResidueType {lvalue},std::string)

def add_residue_connection(

...)

add_residue_connection( (ResidueType)arg1, (str)atom_name) -> int : add a non-polymeric ResidueConnection For polymeric connections, see set_lower_connect() and set_upper_connect() Doesn't set the ideal geometry -- maybe it should?

C++ signature : unsigned long add_residue_connection(core::chemical::ResidueType {lvalue},std::string)

def add_string_property(

...)

add_string_property( (ResidueType)arg1, (str)tag, (str)value) -> None : Add a string property.

C++ signature : void add_string_property(core::chemical::ResidueType {lvalue},std::string,std::string)

def add_variant_type(

...)

add_variant_type( (ResidueType)arg1, (VariantType)variant_type) -> None : Add a variant type to this ResidueType.

C++ signature :
    void add_variant_type(core::chemical::ResidueType {lvalue},core::chemical::VariantType)

add_variant_type( (ResidueType)arg1, (str)variant_type) -> None : Add a variant type to this ResidueType by string.

C++ signature :
    void add_variant_type(core::chemical::ResidueType {lvalue},std::string)

def all_bb_atoms(

...)

all_bb_atoms( (ResidueType)arg1) -> vector1_Size : Indices of all backbone atoms, hydrogens and heavyatoms

C++ signature : utility::vector1 > all_bb_atoms(core::chemical::ResidueType {lvalue})

def all_sc_atoms(

...)

all_sc_atoms( (ResidueType)arg1) -> vector1_Size : Indices of all sidechain atoms, hydrogens and heavyatoms

C++ signature : utility::vector1 > all_sc_atoms(core::chemical::ResidueType {lvalue})

def apolar_hydrogens(

...)

apolar_hydrogens( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:1254

C++ signature : boost::filtered_graph, boost::keep_all, core::chemical::APolarHydrogenFilter> apolar_hydrogens(core::chemical::ResidueType {lvalue})

def aromatic_atoms(

...)

aromatic_atoms( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:1257

C++ signature : boost::filtered_graph, boost::keep_all, core::chemical::AromaticAtomFilter> aromatic_atoms(core::chemical::ResidueType {lvalue})

def assign_internal_coordinates(

...)

assign_internal_coordinates( (ResidueType)arg1) -> None : Assign internal coordinates from the set ideal xyz coordinates. Note that it currently does not obey mainchain designations or cut bonds.

C++ signature :
    void assign_internal_coordinates(core::chemical::ResidueType {lvalue})

assign_internal_coordinates( (ResidueType)arg1, (object)new_root) -> None : @ recursive function to assign internal coordinates Note that it currently does not work well with polymers.

C++ signature :
    void assign_internal_coordinates(core::chemical::ResidueType {lvalue},void*)

def assign_neighbor_atom(

...)

assign_neighbor_atom( (ResidueType)arg1) -> None : core/chemical/ResidueType.hh:1157

C++ signature : void assign_neighbor_atom(core::chemical::ResidueType {lvalue})

def atom(

...)

atom( (ResidueType)arg1, (int)atom_index) -> Atom : core/chemical/ResidueType.hh:193

C++ signature :
    core::chemical::Atom {lvalue} atom(core::chemical::ResidueType {lvalue},unsigned long)

atom( (ResidueType)arg1, (int)atom_index) -> Atom : core/chemical/ResidueType.hh:194

C++ signature :
    core::chemical::Atom atom(core::chemical::ResidueType {lvalue},unsigned long)

atom( (ResidueType)arg1, (str)atom_name) -> Atom : core/chemical/ResidueType.hh:195

C++ signature :
    core::chemical::Atom {lvalue} atom(core::chemical::ResidueType {lvalue},std::string)

atom( (ResidueType)arg1, (str)atom_name) -> Atom : core/chemical/ResidueType.hh:196

C++ signature :
    core::chemical::Atom atom(core::chemical::ResidueType {lvalue},std::string)

atom( (ResidueType)arg1, (object)atom_vd) -> Atom : core/chemical/ResidueType.hh:197

C++ signature :
    core::chemical::Atom {lvalue} atom(core::chemical::ResidueType {lvalue},void*)

atom( (ResidueType)arg1, (object)atom_vd) -> Atom : core/chemical/ResidueType.hh:198

C++ signature :
    core::chemical::Atom atom(core::chemical::ResidueType {lvalue},void*)

def atom_base(

...)

atom_base( (ResidueType)arg1, (int)atomno) -> int : get index of an atom's base atom

C++ signature :
    unsigned long atom_base(core::chemical::ResidueType {lvalue},unsigned long)

atom_base( (ResidueType)arg1, (object)atomno) -> object : get vd of an atom's base atom

C++ signature :
    void* atom_base(core::chemical::ResidueType {lvalue},void*)

def atom_being_shadowed(

...)

atom_being_shadowed( (ResidueType)arg1, (int)atom_shadowing) -> int : Return the index of the atom that the "atom_shadowing" atom is shadowing; returns zero if the "atom_shadowing" atom is not shadowing anyone.

C++ signature : unsigned long atom_being_shadowed(core::chemical::ResidueType {lvalue},unsigned long)

def atom_forms_residue_connection(

...)

atom_forms_residue_connection( (ResidueType)arg1, (int)atomid) -> bool : Does an atom form any inter-residue chemical bonds?

C++ signature : bool atom_forms_residue_connection(core::chemical::ResidueType {lvalue},unsigned long)

def atom_index(

...)

atom_index( (ResidueType)arg1, (str)name) -> int : get atom index by name

C++ signature :
    unsigned long atom_index(core::chemical::ResidueType {lvalue},std::string)

atom_index( (ResidueType)arg1, (object)vd) -> int : get atom index by vertex descriptor

C++ signature :
    unsigned long atom_index(core::chemical::ResidueType {lvalue},void*)

def atom_is_backbone(

...)

atom_is_backbone( (ResidueType)arg1, (int)atomno) -> bool : is a backbone atom (heavy or hydrogen)?

C++ signature : bool atom_is_backbone(core::chemical::ResidueType {lvalue},unsigned long)

def atom_is_hydrogen(

...)

atom_is_hydrogen( (ResidueType)arg1, (int)atomno) -> bool : quick lookup: is the atom with the given index a hydrogen or not? Atoms are sorted so that heavy atoms come first and hydrogen atoms come last.

C++ signature : bool atom_is_hydrogen(core::chemical::ResidueType {lvalue},unsigned long)

def atom_is_polar_hydrogen(

...)

atom_is_polar_hydrogen( (ResidueType)arg1, (int)atomno) -> bool : core/chemical/ResidueType.hh:498

C++ signature : bool atom_is_polar_hydrogen(core::chemical::ResidueType {lvalue},unsigned long)

def atom_iterators(

...)

atom_iterators( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:619

C++ signature : std::pair, std::_List_iterator > atom_iterators(core::chemical::ResidueType {lvalue})

def atom_name(

...)

atom_name( (ResidueType)arg1, (int)index) -> str : get atom name by index

C++ signature :
    std::string atom_name(core::chemical::ResidueType {lvalue},unsigned long)

atom_name( (ResidueType)arg1, (object)vd) -> str : get atom name by vertex descriptor

C++ signature :
    std::string atom_name(core::chemical::ResidueType {lvalue},void*)

def atom_type(

...)

atom_type( (ResidueType)arg1, (int)atomno) -> AtomType : Get the chemical atom_type for this atom by it index number in this residue If we want the atom_type index (integer), we get this from the conformation::Atom itself, as seen in the code below

C++ signature :
    core::chemical::AtomType atom_type(core::chemical::ResidueType {lvalue},unsigned long)

atom_type( (ResidueType)arg1, (object)vd) -> AtomType : Get the chemical atom_type for this atom by it index number in this residue

C++ signature :
    core::chemical::AtomType atom_type(core::chemical::ResidueType {lvalue},void*)

def atom_type_set(

...)

atom_type_set( (ResidueType)arg1) -> AtomTypeSet : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ////////////// Atom Functions //////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// access by reference the atomset for which this residue is constructed

C++ signature : core::chemical::AtomTypeSet atom_type_set(core::chemical::ResidueType {lvalue})

def atom_type_set_ptr(

...)

atom_type_set_ptr( (ResidueType)arg1) -> AtomTypeSet : access by const pointer the atomset for which this residue is constructed

C++ signature : boost::shared_ptr atom_type_set_ptr(core::chemical::ResidueType {lvalue})

def atom_vertex(

...)

atom_vertex( (ResidueType)arg1, (str)name) -> object : get the vertex descriptor from the name of the atom.

C++ signature :
    void* atom_vertex(core::chemical::ResidueType {lvalue},std::string)

atom_vertex( (ResidueType)arg1, (int)atomno) -> object : Get the vertex descriptor from the atom index.

C++ signature :
    void* atom_vertex(core::chemical::ResidueType {lvalue},unsigned long)

def atoms_are_bonded(

...)

atoms_are_bonded( (ResidueType)arg1, (int)atomindex1, (int)atomindex2) -> bool : Indicates whether or not two atom indices have a chemical bond linking them. Note that this assumes that the Rosetta machinery is set up so that if atom 1 is bonded to atom 2, atom 2 is bonded to atom 1. This function breaks if that assumption breaks. Vikram K. Mulligan

C++ signature : bool atoms_are_bonded(core::chemical::ResidueType {lvalue},unsigned long,unsigned long)

def atoms_last_controlled_by_chi(

...)

atoms_last_controlled_by_chi( (ResidueType)arg1) -> vec1_vec1_Size : Read access to the atoms_last_controlled_by_chi_ array

C++ signature :
    utility::vector1<utility::vector1<unsigned long, std::allocator<unsigned long> >, std::allocator<utility::vector1<unsigned long, std::allocator<unsigned long> > > > atoms_last_controlled_by_chi(core::chemical::ResidueType {lvalue})

atoms_last_controlled_by_chi( (ResidueType)arg1, (int)chi) -> vector1_Size : Read access to the Atoms last controlled by a particular chi

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > atoms_last_controlled_by_chi(core::chemical::ResidueType {lvalue},unsigned long)

def atoms_with_orb_index(

...)

atoms_with_orb_index( (ResidueType)arg1) -> vector1_Size : core/chemical/ResidueType.hh:744

C++ signature : utility::vector1 > atoms_with_orb_index(core::chemical::ResidueType {lvalue})

def atoms_within_one_bond_of_a_residue_connection(

...)

atoms_within_one_bond_of_a_residue_connection( (ResidueType)arg1, (int)resconn) -> object : Returns a list of those atoms within one bond of a residue connection. For residue connection i, its position in this array is a list of pairs of atom-id's, the first of which is always the id for the atom forming residue connection i.

C++ signature : utility::vector1, std::allocator > > atoms_within_one_bond_of_a_residue_connection(core::chemical::ResidueType {lvalue},unsigned long)

def atoms_within_two_bonds_of_a_residue_connection(

...)

atoms_within_two_bonds_of_a_residue_connection( (ResidueType)arg1, (int)resconn) -> object : Returns the list of those atoms within two bonds of residue connection # resconn. Each entry in this list is a triple of atom-id's, the first of which is always the id for the atom forming residue connection resconn.

C++ signature : utility::vector1, std::allocator > > atoms_within_two_bonds_of_a_residue_connection(core::chemical::ResidueType {lvalue},unsigned long)

def attached_H_begin(

...)

attached_H_begin( (ResidueType)arg1, (int)atom) -> int : index number of the first attached Hydrogen on an atom

C++ signature :
    unsigned long attached_H_begin(core::chemical::ResidueType {lvalue},unsigned long)

attached_H_begin( (ResidueType)arg1) -> vector1_Size : for all heavy atoms, index numbers of their first attached Hydrogen

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > attached_H_begin(core::chemical::ResidueType {lvalue})

def attached_H_end(

...)

attached_H_end( (ResidueType)arg1, (int)atom) -> int : index number of the last attached Hydrogen on an atom

C++ signature :
    unsigned long attached_H_end(core::chemical::ResidueType {lvalue},unsigned long)

attached_H_end( (ResidueType)arg1) -> vector1_Size : for all heavy atoms, index numbers of their last attached Hydrogen

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > attached_H_end(core::chemical::ResidueType {lvalue})

def autodetermine_chi_bonds(

...)

autodetermine_chi_bonds( (ResidueType)arg1 [, (int)max_proton_chi_samples=500]) -> None : Regenerate the rotatable chi bonds from the internal graph structure. If the number of proton chi samples would exceed max_proton_chi_samples, don't add extra sampling to proton chis. As a special case, if this is zero don't add any proton chi sampling at all. Requires that Icoor and atom base records are up-to-date, and that ring bonds have been annotated.

C++ signature : void autodetermine_chi_bonds(core::chemical::ResidueType {lvalue} [,unsigned long=500])

def backbone_aa(

...)

backbone_aa( (ResidueType)arg1, (str)type) -> None : AA to use for backbone scoring

C++ signature :
    void backbone_aa(core::chemical::ResidueType {lvalue},std::string)

backbone_aa( (ResidueType)arg1) -> AA : Returns the amino acid type to be used for backbone scoring (rama and p_aa_pp).

C++ signature :
    core::chemical::AA backbone_aa(core::chemical::ResidueType {lvalue})

def base_restype_name(

...)

base_restype_name( (ResidueType)arg1, (str)in) -> None : core/chemical/ResidueType.hh:2600

C++ signature :
    void base_restype_name(core::chemical::ResidueType {lvalue},std::string)

base_restype_name( (ResidueType)arg1) -> str : core/chemical/ResidueType.hh:2601

C++ signature :
    std::string base_restype_name(core::chemical::ResidueType {lvalue})

def bond(

...)

bond( (ResidueType)arg1, (object)ed) -> Bond : core/chemical/ResidueType.hh:203

C++ signature :
    core::chemical::Bond {lvalue} bond(core::chemical::ResidueType {lvalue},boost::detail::edge_desc_impl<boost::undirected_tag, void*>)

bond( (ResidueType)arg1, (object)ed) -> Bond : core/chemical/ResidueType.hh:204

C++ signature :
    core::chemical::Bond bond(core::chemical::ResidueType {lvalue},boost::detail::edge_desc_impl<boost::undirected_tag, void*>)

bond( (ResidueType)arg1, (str)atom1, (str)atom2) -> Bond : core/chemical/ResidueType.hh:205

C++ signature :
    core::chemical::Bond {lvalue} bond(core::chemical::ResidueType {lvalue},std::string,std::string)

bond( (ResidueType)arg1, (str)atom1, (str)atom2) -> Bond : core/chemical/ResidueType.hh:206

C++ signature :
    core::chemical::Bond bond(core::chemical::ResidueType {lvalue},std::string,std::string)

def bond_iterators(

...)

bond_iterators( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:623

C++ signature :
    std::pair<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<void*, boost::property<boost::edge_index_t, unsigned int, core::chemical::Bond> > >, boost::detail::edge_desc_impl<boost::undirected_tag, void*>, long>, boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<void*, boost::property<boost::edge_index_t, unsigned int, core::chemical::Bond> > >, boost::detail::edge_desc_impl<boost::undirected_tag, void*>, long> > bond_iterators(core::chemical::ResidueType {lvalue})

bond_iterators( (ResidueType)arg1, (object)atom) -> object : core/chemical/ResidueType.hh:627

C++ signature :
    std::pair<boost::detail::out_edge_iter<std::_List_iterator<boost::detail::stored_edge_iter<void*, std::_List_iterator<boost::list_edge<void*, boost::property<boost::edge_index_t, unsigned int, core::chemical::Bond> > >, boost::property<boost::edge_index_t, unsigned int, core::chemical::Bond> > >, void*, boost::detail::edge_desc_impl<boost::undirected_tag, void*>, long>, boost::detail::out_edge_iter<std::_List_iterator<boost::detail::stored_edge_iter<void*, std::_List_iterator<boost::list_edge<void*, boost::property<boost::edge_index_t, unsigned int, core::chemical::Bond> > >, boost::property<boost::edge_index_t, unsigned int, core::chemical::Bond> > >, void*, boost::detail::edge_desc_impl<boost::undirected_tag, void*>, long> > bond_iterators(core::chemical::ResidueType {lvalue},void*)

def bondangle(

...)

bondangle( (ResidueType)arg1, (int)bondang) -> object : Return the indices for the set of atoms that define a particular intraresidue angle

C++ signature : utility::keys::Key3Tuple bondangle(core::chemical::ResidueType {lvalue},unsigned long)

def bondangles_for_atom(

...)

bondangles_for_atom( (ResidueType)arg1, (int)atomno) -> vector1_Size : Returns the list of all of the indices of all the intraresidue bond angles a particular atom is involved in. Useful for calculating the derivatives for an atom.

C++ signature : utility::vector1 > bondangles_for_atom(core::chemical::ResidueType {lvalue},unsigned long)

def bonded_neighbor(

...)

bonded_neighbor( (ResidueType)arg1, (int)atomno) -> vector1_Size : core/chemical/ResidueType.hh:340

C++ signature : utility::vector1 > bonded_neighbor(core::chemical::ResidueType {lvalue},unsigned long)

def bonded_neighbor_iterators(

...)

bonded_neighbor_iterators( (ResidueType)arg1, (object)atom) -> object : core/chemical/ResidueType.hh:343

C++ signature : std::pair, boost::property, boost::no_property, boost::listS>, void, boost::detail::out_edge_iter > >, boost::property > >, void, boost::detail::edge_desc_impl, long>, long>, boost::adjacency_iterator, boost::property, boost::no_property, boost::listS>, void, boost::detail::out_edge_iter > >, boost::property > >, void, boost::detail::edge_desc_impl, long>, long> > bonded_neighbor_iterators(core::chemical::ResidueType {lvalue},void*)

def bonded_neighbor_types(

...)

bonded_neighbor_types( (ResidueType)arg1, (int)atomno) -> object : core/chemical/ResidueType.hh:352

C++ signature : utility::vector1 > bonded_neighbor_types(core::chemical::ResidueType {lvalue},unsigned long)

def bonded_orbitals(

...)

bonded_orbitals( (ResidueType)arg1, (int)atomno) -> vector1_Size : indices of the orbitals bonded to an atom

C++ signature : utility::vector1 > bonded_orbitals(core::chemical::ResidueType {lvalue},unsigned long)

def carbohydrate_info(

...)

carbohydrate_info( (ResidueType)arg1) -> object : Return the CarbohydrateInfo object containing sugar-specific properties for this residue.

C++ signature : boost::shared_ptr carbohydrate_info(core::chemical::ResidueType {lvalue})

def chi_2_proton_chi(

...)

chi_2_proton_chi( (ResidueType)arg1, (int)chi_index) -> int : core/chemical/ResidueType.hh:814

C++ signature : unsigned long chi_2_proton_chi(core::chemical::ResidueType {lvalue},unsigned long)

def chi_atom_vds(

...)

chi_atom_vds( (ResidueType)arg1, (int)chino) -> object : VDs of the atoms which are used to define a given chi angle (chino)

C++ signature : utility::vector1 > chi_atom_vds(core::chemical::ResidueType {lvalue},unsigned long)

def chi_atoms(

...)

chi_atoms( (ResidueType)arg1, (int)chino) -> vector1_Size : indices of the atoms which are used to define a given chi angle (chino)

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > chi_atoms(core::chemical::ResidueType {lvalue},unsigned long)

chi_atoms( (ResidueType)arg1) -> vec1_vec1_Size : indices of the atoms which are used to define all the chi angles

C++ signature :
    utility::vector1<utility::vector1<unsigned long, std::allocator<unsigned long> >, std::allocator<utility::vector1<unsigned long, std::allocator<unsigned long> > > > chi_atoms(core::chemical::ResidueType {lvalue})

def chi_rotamers(

...)

chi_rotamers( (ResidueType)arg1, (int)chino) -> vector1_pair_Real_Real : all rotamers bins (mean, std) for a given chi angle

C++ signature : utility::vector1, std::allocator > > chi_rotamers(core::chemical::ResidueType {lvalue},unsigned long)

def chiral_equivalent_name(

...)

chiral_equivalent_name( (ResidueType)arg1) -> str : get our chiral equivalent name

C++ signature :
    std::string chiral_equivalent_name(core::chemical::ResidueType {lvalue})

chiral_equivalent_name( (ResidueType)arg1, (str)name_in) -> None : set our chiral equivalent name

C++ signature :
    void chiral_equivalent_name(core::chemical::ResidueType {lvalue},std::string)

def clone(

...)

clone( (ResidueType)arg1) -> ResidueType : make a copy

C++ signature : boost::shared_ptr clone(core::chemical::ResidueType {lvalue})

def cut_bond_neighbor(

...)

cut_bond_neighbor( (ResidueType)arg1, (int)atomno) -> vector1_Size : indices of the bonded neighbors for an atom

C++ signature : utility::vector1 > cut_bond_neighbor(core::chemical::ResidueType {lvalue},unsigned long)

def debug_dump_icoor(

...)

debug_dump_icoor( (ResidueType)arg1) -> None : Dump out atomnames and icoor values

C++ signature : void debug_dump_icoor(core::chemical::ResidueType {lvalue})

def defined_adducts(

...)

defined_adducts( (ResidueType)arg1) -> object : ///////////////////////////////////////////////////////////////////////// get the adducts defined for this residue

C++ signature : utility::vector1 > defined_adducts(core::chemical::ResidueType {lvalue})

def delete_atom(

...)

delete_atom( (ResidueType)arg1, (str)name) -> None : flag an atom for deletion by adding its index to the delete_atom_ list

C++ signature :
    void delete_atom(core::chemical::ResidueType {lvalue},std::string)

delete_atom( (ResidueType)arg1, (int)index) -> None : core/chemical/ResidueType.hh:968

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

def delete_atom_alias(

...)

delete_atom_alias( (ResidueType)arg1, (str)alias) -> None : Remove a given alias name for an atom.

C++ signature : void delete_atom_alias(core::chemical::ResidueType {lvalue},std::string)

def delete_metalbinding_atom(

...)

delete_metalbinding_atom( (ResidueType)arg1, (str)atom_name) -> None : Remove an atom from the list of atoms that can potentially form a bond to a metal ion (used in patching when it kills the valence that is thus used) Andrew Watkins (amw579@nyu.edu)

C++ signature : void delete_metalbinding_atom(core::chemical::ResidueType {lvalue},std::string)

def delete_property(

...)

delete_property( (ResidueType)arg1, (str)property) -> None : Add a property of this ResidueType.

C++ signature : void delete_property(core::chemical::ResidueType {lvalue},std::string)

def delete_terminal_chi(

...)

delete_terminal_chi( (ResidueType)arg1) -> None : delete terminal chi angle

C++ signature : void delete_terminal_chi(core::chemical::ResidueType {lvalue})

def dihedral(

...)

dihedral( (ResidueType)arg1, (int)dihe) -> object : ///////////////////////////////////////////////////////////////////////// dihedral methods Return the indices for the set of atoms that define a particular intraresidue dihedral

C++ signature : utility::keys::Key4Tuple dihedral(core::chemical::ResidueType {lvalue},unsigned long)

def dihedrals_for_atom(

...)

dihedrals_for_atom( (ResidueType)arg1, (int)atomno) -> vector1_Size : Returns the list of all of the indices of all the intraresidue dihedrals a particular atom is involved in. Useful for calculating the derivatives for an atom.

C++ signature : utility::vector1 > dihedrals_for_atom(core::chemical::ResidueType {lvalue},unsigned long)

def dump_vd_info(

...)

dump_vd_info( (ResidueType)arg1) -> None : core/chemical/ResidueType.hh:590

C++ signature : void dump_vd_info(core::chemical::ResidueType {lvalue})

def element_set(

...)

element_set( (ResidueType)arg1) -> ElementSet : access by reference the atomset for which this residue is constructed

C++ signature : core::chemical::ElementSet element_set(core::chemical::ResidueType {lvalue})

def enable_custom_variant_types(

...)

enable_custom_variant_types( (ResidueType)arg1) -> None : Turn on the ability to create VariantTypes "on-the-fly".

C++ signature : void enable_custom_variant_types(core::chemical::ResidueType {lvalue})

def fill_ideal_xyz_from_icoor(

...)

fill_ideal_xyz_from_icoor( (ResidueType)arg1) -> None : core/chemical/ResidueType.hh:1186

C++ signature : void fill_ideal_xyz_from_icoor(core::chemical::ResidueType {lvalue})

def finalize(

...)

finalize( (ResidueType)arg1) -> None : recalculate derived data, potentially reordering atom-indices

C++ signature : void finalize(core::chemical::ResidueType {lvalue})

def first_sidechain_atom(

...)

first_sidechain_atom( (ResidueType)arg1) -> int : index of the first sidechain atom (heavy or hydrogen)

C++ signature : unsigned long first_sidechain_atom(core::chemical::ResidueType {lvalue})

def first_sidechain_hydrogen(

...)

first_sidechain_hydrogen( (ResidueType)arg1) -> int : index of the first sidehchain hydrogen

C++ signature : unsigned long first_sidechain_hydrogen(core::chemical::ResidueType {lvalue})

def force_nbr_atom_orient(

...)

force_nbr_atom_orient( (ResidueType)arg1, (bool)force_orient) -> None : Set force_nbr_atom_orient_, used to control orient atoms selected by select_orient_atoms

C++ signature :
    void force_nbr_atom_orient(core::chemical::ResidueType {lvalue},bool)

force_nbr_atom_orient( (ResidueType)arg1) -> bool : Return force_nbr_atom_orient_, used to control orient atoms selected by select_orient_atoms

C++ signature :
    bool force_nbr_atom_orient(core::chemical::ResidueType {lvalue})

def forms_disulfide_bond(

...)

forms_disulfide_bond( (ResidueType)arg1) -> bool : is thiol?

C++ signature : bool forms_disulfide_bond(core::chemical::ResidueType {lvalue})

def gasteiger_atom_type(

...)

gasteiger_atom_type( (ResidueType)arg1, (int)atomno) -> object : Get the MM atom_type index number for this atom by its index number in this residue /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ////////////// Gasteiger Atom Type Functions ////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// Get the MM atom_type for this atom by its index number in this residue

C++ signature : boost::shared_ptr gasteiger_atom_type(core::chemical::ResidueType {lvalue},unsigned long)

def get_RotamerLibraryName(

...)

get_RotamerLibraryName( (ResidueType)arg1) -> str : A residue parameter file can refer to a set of "pdb rotamers" that can be superimposed onto a starting position for use in the packer. These rotamers are loaded into the pack::dunbrack::RotamerLibrary at the time of their first use.

C++ signature : std::string get_RotamerLibraryName(core::chemical::ResidueType {lvalue})

def get_metal_binding_atoms(

...)

get_metal_binding_atoms( (ResidueType)arg1, (vector1_Size)metal_binding_indices) -> None : Gets indices of all atoms that can form bonds to metals Vikram K. Mulligan (vmullig@uw.edu).

C++ signature : void get_metal_binding_atoms(core::chemical::ResidueType {lvalue},utility::vector1 > {lvalue})

def get_ncaa_rotlib_n_bin_per_rot(

...)

get_ncaa_rotlib_n_bin_per_rot( (ResidueType)arg1, (int)n_rot) -> int : Returns the number of rotamers for each rotatable bond described by the NCAA rotlib for a single bond

C++ signature :
    unsigned long get_ncaa_rotlib_n_bin_per_rot(core::chemical::ResidueType {lvalue},unsigned long)

get_ncaa_rotlib_n_bin_per_rot( (ResidueType)arg1) -> vector1_Size : Returns the number of rotamers for each rotatable bond described by the NCAA rotlib for all bonds

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > get_ncaa_rotlib_n_bin_per_rot(core::chemical::ResidueType {lvalue})

def get_ncaa_rotlib_n_rotameric_bins(

...)

get_ncaa_rotlib_n_rotameric_bins( (ResidueType)arg1) -> int : Returns the number of rotatable bonds described by the NCAA rotlib (not nesesarily equal to nchi)

C++ signature : unsigned long get_ncaa_rotlib_n_rotameric_bins(core::chemical::ResidueType {lvalue})

def get_ncaa_rotlib_path(

...)

get_ncaa_rotlib_path( (ResidueType)arg1) -> str : Returns the path to the NCAA rotlib for the residue type

C++ signature : std::string get_ncaa_rotlib_path(core::chemical::ResidueType {lvalue})

def get_nrchi_start_angle(

...)

get_nrchi_start_angle( (ResidueType)arg1) -> float : core/chemical/ResidueType.hh:1891

C++ signature : double get_nrchi_start_angle(core::chemical::ResidueType {lvalue})

def get_nrchi_symmetric(

...)

get_nrchi_symmetric( (ResidueType)arg1) -> bool : core/chemical/ResidueType.hh:1900

C++ signature : bool get_nrchi_symmetric(core::chemical::ResidueType {lvalue})

def get_numeric_property(

...)

get_numeric_property( (ResidueType)arg1, (str)tag) -> float : Get a numeric property, if it exists.

C++ signature : double get_numeric_property(core::chemical::ResidueType {lvalue},std::string)

def get_peptoid_rotlib_n_bin_per_rot(

...)

get_peptoid_rotlib_n_bin_per_rot( (ResidueType)arg1, (int)n_rot) -> int : Returns the number of rotamers for each rotatable bond described by the peptoid rotlib for a single bond

C++ signature :
    unsigned long get_peptoid_rotlib_n_bin_per_rot(core::chemical::ResidueType {lvalue},unsigned long)

get_peptoid_rotlib_n_bin_per_rot( (ResidueType)arg1) -> vector1_Size : Returns the number of rotamers for each rotatable bond described by the peptoid rotlib for all bonds

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > get_peptoid_rotlib_n_bin_per_rot(core::chemical::ResidueType {lvalue})

def get_peptoid_rotlib_path(

...)

get_peptoid_rotlib_path( (ResidueType)arg1) -> str : Returns the path to the peptoid rotlib for the residue type

C++ signature : std::string get_peptoid_rotlib_path(core::chemical::ResidueType {lvalue})

def get_self_ptr(

...)

get_self_ptr( (ResidueType)arg1) -> ResidueType : self pointers

C++ signature :
    boost::shared_ptr<core::chemical::ResidueType const> get_self_ptr(core::chemical::ResidueType {lvalue})

get_self_ptr( (ResidueType)arg1) -> ResidueType : core/chemical/ResidueType.hh:162

C++ signature :
    boost::shared_ptr<core::chemical::ResidueType> get_self_ptr(core::chemical::ResidueType {lvalue})

def get_self_weak_ptr(

...)

get_self_weak_ptr( (ResidueType)arg1) -> ResidueTypeCAP : core/chemical/ResidueType.hh:163

C++ signature :
    boost::weak_ptr<core::chemical::ResidueType const> get_self_weak_ptr(core::chemical::ResidueType {lvalue})

get_self_weak_ptr( (ResidueType)arg1) -> ResidueTypeAP : core/chemical/ResidueType.hh:164

C++ signature :
    boost::weak_ptr<core::chemical::ResidueType> get_self_weak_ptr(core::chemical::ResidueType {lvalue})

def get_semirotameric_ncaa_rotlib(

...)

get_semirotameric_ncaa_rotlib( (ResidueType)arg1) -> bool : Returns whether our NCAA rotlib is semirotameric

C++ signature : bool get_semirotameric_ncaa_rotlib(core::chemical::ResidueType {lvalue})

def get_string_property(

...)

get_string_property( (ResidueType)arg1, (str)tag) -> str : Get a string property, if it exists.

C++ signature : std::string get_string_property(core::chemical::ResidueType {lvalue},std::string)

def get_use_ncaa_rotlib(

...)

get_use_ncaa_rotlib( (ResidueType)arg1) -> bool : Returns whether we are using a NCAA rotlib for the residue type

C++ signature : bool get_use_ncaa_rotlib(core::chemical::ResidueType {lvalue})

def get_use_peptoid_rotlib(

...)

get_use_peptoid_rotlib( (ResidueType)arg1) -> bool : Returns whether we are using a peptoid rotlib for the residue type

C++ signature : bool get_use_peptoid_rotlib(core::chemical::ResidueType {lvalue})

def graph(

...)

graph( (ResidueType)arg1) -> object : Constant access to the underlying graph.

C++ signature : boost::undirected_graph graph(core::chemical::ResidueType {lvalue})

def has(

...)

has( (ResidueType)arg1, (str)atom_name) -> bool : is this atom present in this residue?

C++ signature :
    bool has(core::chemical::ResidueType {lvalue},std::string)

has( (ResidueType)arg1, (object)vd) -> bool : is this vertex descriptor present in this residue?

C++ signature :
    bool has(core::chemical::ResidueType {lvalue},void*)

def has_orbital(

...)

has_orbital( (ResidueType)arg1, (str)orbital_name) -> bool : is this orbital present in this residue?

C++ signature : bool has_orbital(core::chemical::ResidueType {lvalue},std::string)

def has_property(

...)

has_property( (ResidueType)arg1, (str)property) -> bool : Generic property access.

C++ signature : bool has_property(core::chemical::ResidueType {lvalue},std::string)

def has_sc_orbitals(

...)

has_sc_orbitals( (ResidueType)arg1) -> bool : does this residue have sidechain orbitals?

C++ signature : bool has_sc_orbitals(core::chemical::ResidueType {lvalue})

def has_variant_type(

...)

has_variant_type( (ResidueType)arg1, (VariantType)variant_type) -> bool : Generic variant access.

C++ signature :
    bool has_variant_type(core::chemical::ResidueType {lvalue},core::chemical::VariantType)

has_variant_type( (ResidueType)arg1, (str)variant_type) -> bool : Generic variant access by string.

C++ signature :
    bool has_variant_type(core::chemical::ResidueType {lvalue},std::string)

def heavy_atom_with_hydrogens(

...)

heavy_atom_with_hydrogens( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:1245

C++ signature : boost::filtered_graph, boost::keep_all, core::chemical::HeavyAtomWithHydrogensFilter> heavy_atom_with_hydrogens(core::chemical::ResidueType {lvalue})

def heavy_atom_with_polar_hydrogens(

...)

heavy_atom_with_polar_hydrogens( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:1242

C++ signature : boost::filtered_graph, boost::keep_all, core::chemical::HeavyAtomWithPolarHydrogensFilter> heavy_atom_with_polar_hydrogens(core::chemical::ResidueType {lvalue})

def heavy_atoms(

...)

heavy_atoms( (ResidueType)arg1) -> object : /////////////////////////////////////////////////////////////////// //////////////////////GRAPHS///////////////////////////////////// ///////////////////////////////////////////////////////////////////

C++ signature : boost::filtered_graph, boost::keep_all, core::chemical::HeavyAtomFilter> heavy_atoms(core::chemical::ResidueType {lvalue})

def heavyatom_has_polar_hydrogens(

...)

heavyatom_has_polar_hydrogens( (ResidueType)arg1, (int)atomno) -> bool : core/chemical/ResidueType.hh:486

C++ signature : bool heavyatom_has_polar_hydrogens(core::chemical::ResidueType {lvalue},unsigned long)

def heavyatom_is_an_acceptor(

...)

heavyatom_is_an_acceptor( (ResidueType)arg1, (int)atomno) -> bool : core/chemical/ResidueType.hh:492

C++ signature : bool heavyatom_is_an_acceptor(core::chemical::ResidueType {lvalue},unsigned long)

def hydrogens(

...)

hydrogens( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:1248

C++ signature : boost::filtered_graph, boost::keep_all, core::chemical::HydrogenAtomFilter> hydrogens(core::chemical::ResidueType {lvalue})

def icoor(

...)

icoor( (ResidueType)arg1, (int)atm) -> AtomICoor : AtomICoord of an atom

C++ signature :
    core::chemical::AtomICoor icoor(core::chemical::ResidueType {lvalue},unsigned long)

icoor( (ResidueType)arg1, (object)atm) -> AtomICoor : AtomICoord of an atom

C++ signature :
    core::chemical::AtomICoor icoor(core::chemical::ResidueType {lvalue},void*)

def improper_dihedral(

...)

improper_dihedral( (ResidueType)arg1, (int)dihe) -> object : Return the indices for the set of atoms that define a particular intraresidue improper dihedral

C++ signature : utility::keys::Key4Tuple improper_dihedral(core::chemical::ResidueType {lvalue},unsigned long)

def improper_dihedrals_for_atom(

...)

improper_dihedrals_for_atom( (ResidueType)arg1, (int)atomno) -> vector1_Size : Returns the list of all of the indices of all the intraresidue dihedrals a particular atom is involved in. Useful for calculating the derivatives for an atom.

C++ signature : utility::vector1 > improper_dihedrals_for_atom(core::chemical::ResidueType {lvalue},unsigned long)

def interchangeability_group(

...)

interchangeability_group( (ResidueType)arg1) -> str : get our interchangeability-group id. Used to determine if two residue types are equivalent, except for their variant status. E.g. ResidueTypes ALA and ALA_Nterm would be part of the same interchangeability group. This has a degree of subjectivity; are TYR and pTYR in the same interchangeability group? Probably not. This data can be specified in the ResidueTypes .params file with the INTERCHANGEABILITY_GROUP tag.

C++ signature :
    std::string interchangeability_group(core::chemical::ResidueType {lvalue})

interchangeability_group( (ResidueType)arg1, (str)setting) -> None : set our interchangeability-group id

C++ signature :
    void interchangeability_group(core::chemical::ResidueType {lvalue},std::string)

def is_DNA(

...)

is_DNA( (ResidueType)arg1) -> bool : is DNA?

C++ signature : bool is_DNA(core::chemical::ResidueType {lvalue})

def is_NA(

...)

is_NA( (ResidueType)arg1) -> bool : is Nucleic Acid?

C++ signature : bool is_NA(core::chemical::ResidueType {lvalue})

def is_RNA(

...)

is_RNA( (ResidueType)arg1) -> bool : is RNA?

C++ signature : bool is_RNA(core::chemical::ResidueType {lvalue})

def is_acetylated_nterminus(

...)

is_acetylated_nterminus( (ResidueType)arg1) -> bool : is acetylated n terminus

C++ signature : bool is_acetylated_nterminus(core::chemical::ResidueType {lvalue})

def is_adduct(

...)

is_adduct( (ResidueType)arg1) -> bool : is an adduct-modified residue?

C++ signature : bool is_adduct(core::chemical::ResidueType {lvalue})

def is_alpha_aa(

...)

is_alpha_aa( (ResidueType)arg1) -> bool : is this an alpha amino acid?

C++ signature : bool is_alpha_aa(core::chemical::ResidueType {lvalue})

def is_aromatic(

...)

is_aromatic( (ResidueType)arg1) -> bool : is aromatic?

C++ signature : bool is_aromatic(core::chemical::ResidueType {lvalue})

def is_beta_aa(

...)

is_beta_aa( (ResidueType)arg1) -> bool : is this a beta amino acid?

C++ signature : bool is_beta_aa(core::chemical::ResidueType {lvalue})

def is_branch_lower_terminus(

...)

is_branch_lower_terminus( (ResidueType)arg1) -> bool : is lower terminus of a branch?

C++ signature : bool is_branch_lower_terminus(core::chemical::ResidueType {lvalue})

def is_branch_point(

...)

is_branch_point( (ResidueType)arg1) -> bool : is a branch-point residue?

C++ signature : bool is_branch_point(core::chemical::ResidueType {lvalue})

def is_carbohydrate(

...)

is_carbohydrate( (ResidueType)arg1) -> bool : is carbohydrate?

C++ signature : bool is_carbohydrate(core::chemical::ResidueType {lvalue})

def is_charged(

...)

is_charged( (ResidueType)arg1) -> bool : is charged?

C++ signature : bool is_charged(core::chemical::ResidueType {lvalue})

def is_coarse(

...)

is_coarse( (ResidueType)arg1) -> bool : is coarse?

C++ signature : bool is_coarse(core::chemical::ResidueType {lvalue})

def is_cyclic(

...)

is_cyclic( (ResidueType)arg1) -> bool : is cyclic?

C++ signature : bool is_cyclic(core::chemical::ResidueType {lvalue})

def is_d_aa(

...)

is_d_aa( (ResidueType)arg1) -> bool : is this a d-amino acid?

C++ signature : bool is_d_aa(core::chemical::ResidueType {lvalue})

def is_disulfide_bonded(

...)

is_disulfide_bonded( (ResidueType)arg1) -> bool : is disulfide?

C++ signature : bool is_disulfide_bonded(core::chemical::ResidueType {lvalue})

def is_l_aa(

...)

is_l_aa( (ResidueType)arg1) -> bool : is this an l-amino acid?

C++ signature : bool is_l_aa(core::chemical::ResidueType {lvalue})

def is_ligand(

...)

is_ligand( (ResidueType)arg1) -> bool : is ligand?

C++ signature : bool is_ligand(core::chemical::ResidueType {lvalue})

def is_lipid(

...)

is_lipid( (ResidueType)arg1) -> bool : is lipid?

C++ signature : bool is_lipid(core::chemical::ResidueType {lvalue})

def is_lower_terminus(

...)

is_lower_terminus( (ResidueType)arg1) -> bool : is lower terminus?

C++ signature : bool is_lower_terminus(core::chemical::ResidueType {lvalue})

def is_membrane(

...)

is_membrane( (ResidueType)arg1) -> bool : is membrane?

C++ signature : bool is_membrane(core::chemical::ResidueType {lvalue})

def is_metal(

...)

is_metal( (ResidueType)arg1) -> bool : Return true if this residue type is a metal ion, false otherwise.

C++ signature : bool is_metal(core::chemical::ResidueType {lvalue})

def is_metalbinding(

...)

is_metalbinding( (ResidueType)arg1) -> bool : Return true if this residue type is a type that can bind to a metal ion (e.g. His, Asp, Cys, etc.), false otherwise.

C++ signature : bool is_metalbinding(core::chemical::ResidueType {lvalue})

def is_methylated_cterminus(

...)

is_methylated_cterminus( (ResidueType)arg1) -> bool : is methylated c terminus

C++ signature : bool is_methylated_cterminus(core::chemical::ResidueType {lvalue})

def is_peptoid(

...)

is_peptoid( (ResidueType)arg1) -> bool : is peptoid?

C++ signature : bool is_peptoid(core::chemical::ResidueType {lvalue})

def is_polar(

...)

is_polar( (ResidueType)arg1) -> bool : is polar?

C++ signature : bool is_polar(core::chemical::ResidueType {lvalue})

def is_polymer(

...)

is_polymer( (ResidueType)arg1) -> bool : is polymer?

C++ signature : bool is_polymer(core::chemical::ResidueType {lvalue})

def is_protein(

...)

is_protein( (ResidueType)arg1) -> bool : is protein?

C++ signature : bool is_protein(core::chemical::ResidueType {lvalue})

def is_proton_chi(

...)

is_proton_chi( (ResidueType)arg1, (int)chino) -> bool : number of proton chis

C++ signature : bool is_proton_chi(core::chemical::ResidueType {lvalue},unsigned long)

def is_sri(

...)

is_sri( (ResidueType)arg1) -> bool : Is this one of SRI's special heteropolymer building blocks?

C++ signature : bool is_sri(core::chemical::ResidueType {lvalue})

def is_surface(

...)

is_surface( (ResidueType)arg1) -> bool : is surface? (e.g. enamel)

C++ signature : bool is_surface(core::chemical::ResidueType {lvalue})

def is_terminus(

...)

is_terminus( (ResidueType)arg1) -> bool : is terminus?

C++ signature : bool is_terminus(core::chemical::ResidueType {lvalue})

def is_triazolemer(

...)

is_triazolemer( (ResidueType)arg1) -> bool : Is this a triazolemer?

C++ signature : bool is_triazolemer(core::chemical::ResidueType {lvalue})

def is_upper_terminus(

...)

is_upper_terminus( (ResidueType)arg1) -> bool : is upper terminus?

C++ signature : bool is_upper_terminus(core::chemical::ResidueType {lvalue})

def is_virtual(

...)

is_virtual( (ResidueType)arg1, (int)atomno) -> bool : Check if atom is virtual.

C++ signature : bool is_virtual(core::chemical::ResidueType {lvalue},unsigned long)

def is_virtual_residue(

...)

is_virtual_residue( (ResidueType)arg1) -> bool : Check if residue is 'VIRTUAL_RESIDUE'

C++ signature : bool is_virtual_residue(core::chemical::ResidueType {lvalue})

def last_backbone_atom(

...)

last_backbone_atom( (ResidueType)arg1) -> int : index of the last backbone heavy atom

C++ signature : unsigned long last_backbone_atom(core::chemical::ResidueType {lvalue})

def last_controlling_chi(

...)

last_controlling_chi( (ResidueType)arg1) -> vector1_Size : Read access to the last_controlling_chi_ array

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > last_controlling_chi(core::chemical::ResidueType {lvalue})

last_controlling_chi( (ResidueType)arg1, (int)atomno) -> int : The last_controlling_chi for an atom. 0 if an atom is controlled by no chi.

C++ signature :
    unsigned long last_controlling_chi(core::chemical::ResidueType {lvalue},unsigned long)

def lower_connect(

...)

lower_connect( (ResidueType)arg1) -> ResidueConnection : core/chemical/ResidueType.hh:841

C++ signature : core::chemical::ResidueConnection lower_connect(core::chemical::ResidueType {lvalue})

def lower_connect_atom(

...)

lower_connect_atom( (ResidueType)arg1) -> int : index number of the atom which connects to the lower connection

C++ signature : unsigned long lower_connect_atom(core::chemical::ResidueType {lvalue})

def lower_connect_id(

...)

lower_connect_id( (ResidueType)arg1) -> int : core/chemical/ResidueType.hh:844

C++ signature : unsigned long lower_connect_id(core::chemical::ResidueType {lvalue})

def mainchain_atom(

...)

mainchain_atom( (ResidueType)arg1, (int)atm) -> int : index of mainchain atom

C++ signature : unsigned long mainchain_atom(core::chemical::ResidueType {lvalue},unsigned long)

def mainchain_atoms(

...)

mainchain_atoms( (ResidueType)arg1) -> vector1_Size : indices of all mainchain atoms

C++ signature : utility::vector1 > mainchain_atoms(core::chemical::ResidueType {lvalue})

def mass(

...)

mass( (ResidueType)arg1) -> float : get the molecular weight of this residue

C++ signature : double mass(core::chemical::ResidueType {lvalue})

def mm_atom_type(

...)

mm_atom_type( (ResidueType)arg1, (int)atomno) -> MMAtomType : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ////////////// MMAtom Functions ////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// Get the MM atom_type for this atom by its index number in this residue

C++ signature : core::chemical::MMAtomType mm_atom_type(core::chemical::ResidueType {lvalue},unsigned long)

def n_hbond_acceptors(

...)

n_hbond_acceptors( (ResidueType)arg1) -> int : number of hbond_acceptors

C++ signature : unsigned long n_hbond_acceptors(core::chemical::ResidueType {lvalue})

def n_hbond_donors(

...)

n_hbond_donors( (ResidueType)arg1) -> int : number of hbond_donors

C++ signature : unsigned long n_hbond_donors(core::chemical::ResidueType {lvalue})

def n_non_polymeric_residue_connections(

...)

n_non_polymeric_residue_connections( (ResidueType)arg1) -> int : core/chemical/ResidueType.hh:885

C++ signature : unsigned long n_non_polymeric_residue_connections(core::chemical::ResidueType {lvalue})

def n_nus(

...)

n_nus( (ResidueType)arg1) -> int : Return number of nu (internal ring) angles.

C++ signature : unsigned long n_nus(core::chemical::ResidueType {lvalue})

def n_orbitals(

...)

n_orbitals( (ResidueType)arg1) -> int : number of orbitals

C++ signature : unsigned long n_orbitals(core::chemical::ResidueType {lvalue})

def n_polymeric_residue_connections(

...)

n_polymeric_residue_connections( (ResidueType)arg1) -> int : core/chemical/ResidueType.hh:880

C++ signature : unsigned long n_polymeric_residue_connections(core::chemical::ResidueType {lvalue})

def n_proton_chi(

...)

n_proton_chi( (ResidueType)arg1) -> int : number of proton chis

C++ signature : unsigned long n_proton_chi(core::chemical::ResidueType {lvalue})

def n_residue_connections(

...)

n_residue_connections( (ResidueType)arg1) -> int : number of ResidueConnections, counting polymeric residue connections

C++ signature : unsigned long n_residue_connections(core::chemical::ResidueType {lvalue})

def n_residue_connections_for_atom(

...)

n_residue_connections_for_atom( (ResidueType)arg1, (int)atomid) -> int : How many inter-residue chemical bonds does a particular atom form?

C++ signature : unsigned long n_residue_connections_for_atom(core::chemical::ResidueType {lvalue},unsigned long)

def n_virtual_atoms(

...)

n_virtual_atoms( (ResidueType)arg1) -> int : Counts the number of virtual atoms and returns the count. The virtual count is not stored in the resiude type. This count is performed on the fly, and can hurt performance if reapeatedly carried out. Not intended for use in large loops -- instead, call once and store the value. Vikram K. Mulligan (vmullig@uw.edu)

C++ signature : unsigned long n_virtual_atoms(core::chemical::ResidueType {lvalue})

def name(

...)

name( (ResidueType)arg1) -> str : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ////////////// Names ///////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// get our (unique) residue name

C++ signature :
    std::string name(core::chemical::ResidueType {lvalue})

name( (ResidueType)arg1, (str)name_in) -> None : set our (unique) residue name

C++ signature :
    void name(core::chemical::ResidueType {lvalue},std::string)

def name1(

...)

name1( (ResidueType)arg1) -> str : get our 1letter code. This is set in the ResidueType .params file through the IO_STRING tag along with the name3 string.

C++ signature :
    char name1(core::chemical::ResidueType {lvalue})

name1( (ResidueType)arg1, (str)code) -> None : set our 1letter code

C++ signature :
    void name1(core::chemical::ResidueType {lvalue},char)

def name3(

...)

name3( (ResidueType)arg1) -> str : get our 3letter code. This is set in the ResidueType .params file through the IO_STRING tag along with the name1 string

C++ signature :
    std::string name3(core::chemical::ResidueType {lvalue})

name3( (ResidueType)arg1, (str)name_in) -> None : set our 3letter code

C++ signature :
    void name3(core::chemical::ResidueType {lvalue},std::string)

def natoms(

...)

natoms( (ResidueType)arg1) -> int : number of atoms

C++ signature : unsigned long natoms(core::chemical::ResidueType {lvalue})

def nbonds(

...)

nbonds( (ResidueType)arg1) -> int : number of bonds

C++ signature :
    unsigned long nbonds(core::chemical::ResidueType {lvalue})

nbonds( (ResidueType)arg1, (int)atom) -> int : number of bonds for given atom

C++ signature :
    unsigned long nbonds(core::chemical::ResidueType {lvalue},unsigned long)

nbonds( (ResidueType)arg1, (object)atom) -> int : number of bonds for given atom

C++ signature :
    unsigned long nbonds(core::chemical::ResidueType {lvalue},void*)

def nbr_atom(

...)

nbr_atom( (ResidueType)arg1, (str)atom_name) -> None : set nbr_atom used to define residue-level neighbors

C++ signature :
    void nbr_atom(core::chemical::ResidueType {lvalue},std::string)

nbr_atom( (ResidueType)arg1, (object)vertex) -> None : set nbr_atom used to define residue-level neighbors

C++ signature :
    void nbr_atom(core::chemical::ResidueType {lvalue},void*)

nbr_atom( (ResidueType)arg1) -> int : get nbr_atom used to define residue-level neighbors

C++ signature :
    unsigned long nbr_atom(core::chemical::ResidueType {lvalue})

def nbr_radius(

...)

nbr_radius( (ResidueType)arg1, (float)radius) -> None : set nbr_radius_ used to define residue-level neighbors

C++ signature :
    void nbr_radius(core::chemical::ResidueType {lvalue},double)

nbr_radius( (ResidueType)arg1) -> float : get nbr_radius_ used to define residue-level neighbors

C++ signature :
    double nbr_radius(core::chemical::ResidueType {lvalue})

def nbr_vertex(

...)

nbr_vertex( (ResidueType)arg1) -> object : get VD used to define residue-level neighbors

C++ signature : void* nbr_vertex(core::chemical::ResidueType {lvalue})

def nbrs(

...)

nbrs( (ResidueType)arg1, (int)atomno) -> vector1_Size : indices of the bonded neighbors for an atom, shortcut for bonded_neighbor(atomno)

C++ signature : utility::vector1 > nbrs(core::chemical::ResidueType {lvalue},unsigned long)

def nchi(

...)

nchi( (ResidueType)arg1) -> int : number of chi angles

C++ signature : unsigned long nchi(core::chemical::ResidueType {lvalue})

def ndihe(

...)

ndihe( (ResidueType)arg1) -> int : Return the number of intraresidue dihedrals. This covers all pairs of atoms that are separated by four bonds, and all pairs of intervening atoms.

C++ signature : unsigned long ndihe(core::chemical::ResidueType {lvalue})

def new_orbital_icoor_data(

...)

new_orbital_icoor_data( (ResidueType)arg1, (int)orbital_index) -> ICoorOrbitalData : core/chemical/ResidueType.hh:1218

C++ signature : core::chemical::orbitals::ICoorOrbitalData new_orbital_icoor_data(core::chemical::ResidueType {lvalue},unsigned long)

def nheavyatoms(

...)

nheavyatoms( (ResidueType)arg1) -> int : number of heavy atoms

C++ signature : unsigned long nheavyatoms(core::chemical::ResidueType {lvalue})

def nondefault(

...)

nondefault( (ResidueType)arg1, (bool)in) -> None : core/chemical/ResidueType.hh:2599

C++ signature : void nondefault(core::chemical::ResidueType {lvalue},bool)

def nu_atoms(

...)

nu_atoms( (ResidueType)arg1, (int)nu_index) -> vector1_Size : Return indices of the atoms used to define a given nu (internal ring) angle.

C++ signature :
    utility::vector1<unsigned long, std::allocator<unsigned long> > nu_atoms(core::chemical::ResidueType {lvalue},unsigned long)

nu_atoms( (ResidueType)arg1) -> vec1_vec1_Size : Return list of indices of the atoms used to define all the nu (internal ring) angles.

C++ signature :
    utility::vector1<utility::vector1<unsigned long, std::allocator<unsigned long> >, std::allocator<utility::vector1<unsigned long, std::allocator<unsigned long> > > > nu_atoms(core::chemical::ResidueType {lvalue})

def num_bondangles(

...)

num_bondangles( (ResidueType)arg1) -> int : get number of intraresidue bond angles

C++ signature : unsigned long num_bondangles(core::chemical::ResidueType {lvalue})

def number_bonded_heavyatoms(

...)

number_bonded_heavyatoms( (ResidueType)arg1, (int)atomno) -> int : indicates how many heavyatom bonded neighbors an atom has

C++ signature : unsigned long number_bonded_heavyatoms(core::chemical::ResidueType {lvalue},unsigned long)

def number_bonded_hydrogens(

...)

number_bonded_hydrogens( (ResidueType)arg1, (int)atomno) -> int : indicates how many proton bonded neighbors an atom has

C++ signature : unsigned long number_bonded_hydrogens(core::chemical::ResidueType {lvalue},unsigned long)

def orbital(

...)

orbital( (ResidueType)arg1, (int)orbital_index) -> Orbital : core/chemical/ResidueType.hh:200

C++ signature :
    core::chemical::Orbital orbital(core::chemical::ResidueType {lvalue},unsigned long)

orbital( (ResidueType)arg1, (str)orbital_name) -> Orbital : core/chemical/ResidueType.hh:201

C++ signature :
    core::chemical::Orbital orbital(core::chemical::ResidueType {lvalue},std::string)

def orbital_icoor_data(

...)

orbital_icoor_data( (ResidueType)arg1, (int)orbital_index) -> ICoorOrbitalData : core/chemical/ResidueType.hh:1215

C++ signature : core::chemical::orbitals::ICoorOrbitalData orbital_icoor_data(core::chemical::ResidueType {lvalue},unsigned long)

def orbital_index(

...)

orbital_index( (ResidueType)arg1, (str)name) -> int : get orbital index by name

C++ signature : unsigned long orbital_index(core::chemical::ResidueType {lvalue},std::string)

def orbital_type(

...)

orbital_type( (ResidueType)arg1, (int)orbital_index) -> OrbitalType : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ///////////// Orbital Functions ////////////////////// /////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////

C++ signature : core::chemical::orbitals::OrbitalType orbital_type(core::chemical::ResidueType {lvalue},int)

def path_distance(

...)

path_distance( (ResidueType)arg1, (int)at1, (int)at2) -> int : path distance (number of bonds separated) between a pair of atoms

C++ signature :
    int path_distance(core::chemical::ResidueType {lvalue},unsigned long,unsigned long)

path_distance( (ResidueType)arg1, (int)atom) -> vector1_int : shortest path distance for an atom to all other residue atoms

C++ signature :
    utility::vector1<int, std::allocator<int> > path_distance(core::chemical::ResidueType {lvalue},unsigned long)

def path_distances(

...)

path_distances( (ResidueType)arg1) -> vec1_vec1_int : accessor of path_distance_ data for this residue, which is a 2D array

C++ signature : utility::vector1 >, std::allocator > > > path_distances(core::chemical::ResidueType {lvalue})

def polar_hydrogens(

...)

polar_hydrogens( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:1251

C++ signature : boost::filtered_graph, boost::keep_all, core::chemical::PolarHydrogenFilter> polar_hydrogens(core::chemical::ResidueType {lvalue})

def print_bondangles(

...)

print_bondangles( (ResidueType)arg1) -> None : print intraresidue bond angles to standard out

C++ signature : void print_bondangles(core::chemical::ResidueType {lvalue})

def print_dihedrals(

...)

print_dihedrals( (ResidueType)arg1) -> None : core/chemical/ResidueType.hh:1788

C++ signature : void print_dihedrals(core::chemical::ResidueType {lvalue})

def print_pretty_path_distances(

...)

print_pretty_path_distances( (ResidueType)arg1) -> None : print chemical-bond path distances to standard out

C++ signature : void print_pretty_path_distances(core::chemical::ResidueType {lvalue})

def properties(

...)

properties( (ResidueType)arg1) -> ResidueProperties : /////////////////////////////////////////////////////////////////// ////////////// properties ///////////////////////////////////////// /////////////////////////////////////////////////////////////////// Access the collection of properties for this ResidueType.

C++ signature : core::chemical::ResidueProperties properties(core::chemical::ResidueType {lvalue})

def proton_chi_2_chi(

...)

proton_chi_2_chi( (ResidueType)arg1, (int)proton_chi_id) -> int : translate proton_chi to global chi

C++ signature : unsigned long proton_chi_2_chi(core::chemical::ResidueType {lvalue},unsigned long)

def proton_chi_extra_samples(

...)

proton_chi_extra_samples( (ResidueType)arg1, (int)proton_chi) -> vector1_Real : core/chemical/ResidueType.hh:826

C++ signature : utility::vector1 > proton_chi_extra_samples(core::chemical::ResidueType {lvalue},unsigned long)

def proton_chi_samples(

...)

proton_chi_samples( (ResidueType)arg1, (int)proton_chi) -> vector1_Real : core/chemical/ResidueType.hh:820

C++ signature : utility::vector1 > proton_chi_samples(core::chemical::ResidueType {lvalue},unsigned long)

def redefine_chi(

...)

redefine_chi( (ResidueType)arg1, (int)chino, (str)atom_name1, (str)atom_name2, (str)atom_name3, (str)atom_name4) -> None : redefine a chi angle based on four atoms

C++ signature : void redefine_chi(core::chemical::ResidueType {lvalue},unsigned long,std::string,std::string,std::string,std::string)

def remap_pdb_atom_names(

...)

remap_pdb_atom_names( (ResidueType)arg1, (bool)rename) -> None : Turn on geometry-based atom renaming when loading this residue type from PDB files

C++ signature :
    void remap_pdb_atom_names(core::chemical::ResidueType {lvalue},bool)

remap_pdb_atom_names( (ResidueType)arg1) -> bool : Are we using geometry-based atom renaming when loading this residue type from PDB

C++ signature :
    bool remap_pdb_atom_names(core::chemical::ResidueType {lvalue})

def remove_variant_type(

...)

remove_variant_type( (ResidueType)arg1, (VariantType)variant_type) -> None : Remove a variant type to this ResidueType.

C++ signature :
    void remove_variant_type(core::chemical::ResidueType {lvalue},core::chemical::VariantType)

remove_variant_type( (ResidueType)arg1, (str)variant_type) -> None : Remove a variant type to this ResidueType by string.

C++ signature :
    void remove_variant_type(core::chemical::ResidueType {lvalue},std::string)

def report_adducts(

...)

report_adducts( (ResidueType)arg1) -> None : core/chemical/ResidueType.hh:2081

C++ signature : void report_adducts(core::chemical::ResidueType {lvalue})

def require_final(

...)

require_final( (ResidueType)arg1) -> None : an assertion function to ensure an ResidueType has been finalized

C++ signature : void require_final(core::chemical::ResidueType {lvalue})

def requires_actcoord(

...)

requires_actcoord( (ResidueType)arg1) -> bool : require actcoord?

C++ signature : bool requires_actcoord(core::chemical::ResidueType {lvalue})

def residue_connect_atom_index(

...)

residue_connect_atom_index( (ResidueType)arg1, (int)resconn_id) -> int : core/chemical/ResidueType.hh:929

C++ signature : unsigned long residue_connect_atom_index(core::chemical::ResidueType {lvalue},unsigned long)

def residue_connection(

...)

residue_connection( (ResidueType)arg1, (int)i) -> ResidueConnection : get a ResidueConection

C++ signature :
    core::chemical::ResidueConnection residue_connection(core::chemical::ResidueType {lvalue},unsigned long)

residue_connection( (ResidueType)arg1, (int)i) -> ResidueConnection : core/chemical/ResidueType.hh:892

C++ signature :
    core::chemical::ResidueConnection {lvalue} residue_connection(core::chemical::ResidueType {lvalue},unsigned long)

def residue_connection_id_for_atom(

...)

residue_connection_id_for_atom( (ResidueType)arg1, (int)atomid) -> int : Convenience access function for the residue connection at a particular atom; requires that there is exactly one residue connection at this atom.

C++ signature : unsigned long residue_connection_id_for_atom(core::chemical::ResidueType {lvalue},unsigned long)

def residue_connection_is_polymeric(

...)

residue_connection_is_polymeric( (ResidueType)arg1, (int)resconn_id) -> bool : core/chemical/ResidueType.hh:924

C++ signature : bool residue_connection_is_polymeric(core::chemical::ResidueType {lvalue},unsigned long)

def residue_connections_for_atom(

...)

residue_connections_for_atom( (ResidueType)arg1, (int)atomid) -> vector1_Size : / Accessor for the full complement of residue connections for a single atom.

C++ signature : utility::vector1 > residue_connections_for_atom(core::chemical::ResidueType {lvalue},unsigned long)

def residue_type_set(

...)

residue_type_set( (ResidueType)arg1) -> ResidueTypeSet : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ///////////// Residue Functions ////////////////////// /////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////

C++ signature :
    core::chemical::ResidueTypeSet residue_type_set(core::chemical::ResidueType {lvalue})

residue_type_set( (ResidueType)arg1, (ResidueTypeSetCAP)set_in) -> None : set the residue type set of origin.

C++ signature :
    void residue_type_set(core::chemical::ResidueType {lvalue},boost::weak_ptr<core::chemical::ResidueTypeSet const>)

def ring_conformer_set(

...)

ring_conformer_set( (ResidueType)arg1) -> RingConformerSet : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ///////////// Ring Conformer Set Functions ////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// Return a pointer to the object containing the set of ring conformers possible for this cyclic residue.

C++ signature : boost::shared_ptr ring_conformer_set(core::chemical::ResidueType {lvalue})

def rings(

...)

rings( (ResidueType)arg1) -> object : core/chemical/ResidueType.hh:2056

C++ signature : std::list, std::allocator > >, std::allocator, std::allocator > > > > rings(core::chemical::ResidueType {lvalue})

def root_atom(

...)

root_atom( (ResidueType)arg1) -> object : get root_atom used as the base of the icoor tree.

C++ signature : void* root_atom(core::chemical::ResidueType {lvalue})

def rotamer_aa(

...)

rotamer_aa( (ResidueType)arg1, (AA)type) -> None : AA to use for rotamer library

C++ signature :
    void rotamer_aa(core::chemical::ResidueType {lvalue},core::chemical::AA)

rotamer_aa( (ResidueType)arg1, (str)type) -> None : AA to use for rotamer library

C++ signature :
    void rotamer_aa(core::chemical::ResidueType {lvalue},std::string)

rotamer_aa( (ResidueType)arg1) -> AA : core/chemical/ResidueType.hh:1717

C++ signature :
    core::chemical::AA rotamer_aa(core::chemical::ResidueType {lvalue})

def select_orient_atoms(

...)

select_orient_atoms( (ResidueType)arg1, (int)center, (int)nbr1, (int)nbr2) -> None : Selects three atoms for orienting this residue type

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

def set_RotamerLibraryName(

...)

set_RotamerLibraryName( (ResidueType)arg1, (str)filename) -> None : core/chemical/ResidueType.hh:1732

C++ signature : void set_RotamerLibraryName(core::chemical::ResidueType {lvalue},std::string)

def set_adduct_flag(

...)

set_adduct_flag( (ResidueType)arg1, (bool)adduct_in) -> None : core/chemical/ResidueType.hh:1390

C++ signature : void set_adduct_flag(core::chemical::ResidueType {lvalue},bool)

def set_atom_base(

...)

set_atom_base( (ResidueType)arg1, (str)atom_name1, (str)atom_name2) -> None : sets atom_base[ atom1 ] = atom2

C++ signature :
    void set_atom_base(core::chemical::ResidueType {lvalue},std::string,std::string)

set_atom_base( (ResidueType)arg1, (object)atom1, (object)atom2) -> None : sets atom_base[ atom1 ] = atom2, vertex descriptor version

C++ signature :
    void set_atom_base(core::chemical::ResidueType {lvalue},void*,void*)

def set_atom_type(

...)

set_atom_type( (ResidueType)arg1, (str)atom_name, (str)atom_type_name) -> None : set atom type

C++ signature :
    void set_atom_type(core::chemical::ResidueType {lvalue},std::string,std::string)

set_atom_type( (ResidueType)arg1, (object)atom, (str)atom_type_name) -> None : set atom type

C++ signature :
    void set_atom_type(core::chemical::ResidueType {lvalue},void*,std::string)

def set_backbone_heavyatom(

...)

set_backbone_heavyatom( (ResidueType)arg1, (str)name) -> None : set an atom as backbone heavy atom backbone stuff is a little tricky if we want to allow newly added atoms, eg in patching, to be backbone atoms. We move any exsiting backbone heavy atoms back into force_bb_ list and add the new one. Afterwards, the new backbone heavy atom list will be generated in finalize() using info from force_bb_.

C++ signature : void set_backbone_heavyatom(core::chemical::ResidueType {lvalue},std::string)

def set_gasteiger_atom_type(

...)

set_gasteiger_atom_type( (ResidueType)arg1, (str)atom_name, (str)gasteiger_atom_type_name) -> None : set gasteiger atom type

C++ signature : void set_gasteiger_atom_type(core::chemical::ResidueType {lvalue},std::string,std::string)

def set_gasteiger_typeset(

...)

set_gasteiger_typeset( (ResidueType)arg1, (object)gasteiger_atom_types) -> None : Manually set the gasteiger typeset - will use the default set otherwise

C++ signature : void set_gasteiger_typeset(core::chemical::ResidueType {lvalue},boost::shared_ptr)

def set_icoor(

...)

set_icoor( (ResidueType)arg1, (str)atm, (float)phi, (float)theta, (float)d, (str)stub_atom1, (str)stub_atom2, (str)stub_atom3 [, (bool)update_xyz=False]) -> None : set AtomICoor for an atom phi and theta are in radians

C++ signature :
    void set_icoor(core::chemical::ResidueType {lvalue},std::string,double,double,double,std::string,std::string,std::string [,bool=False])

set_icoor( (ResidueType)arg1, (object)atm, (float)phi, (float)theta, (float)d, (object)stub_atom1, (object)stub_atom2, (object)stub_atom3 [, (bool)update_xyz=False]) -> None : set AtomICoor for an atom, vertex descriptor version phi and theta are in radians

C++ signature :
    void set_icoor(core::chemical::ResidueType {lvalue},void*,double,double,double,void*,void*,void* [,bool=False])

def set_ideal_xyz(

...)

set_ideal_xyz( (ResidueType)arg1, (str)atm, (xyzVector_Real)xyz_in) -> None : core/chemical/ResidueType.hh:1171

C++ signature :
    void set_ideal_xyz(core::chemical::ResidueType {lvalue},std::string,numeric::xyzVector<double>)

set_ideal_xyz( (ResidueType)arg1, (int)index, (xyzVector_Real)xyz_in) -> None : core/chemical/ResidueType.hh:1177

C++ signature :
    void set_ideal_xyz(core::chemical::ResidueType {lvalue},unsigned long,numeric::xyzVector<double>)

set_ideal_xyz( (ResidueType)arg1, (object)atm, (xyzVector_Real)xyz_in) -> None : core/chemical/ResidueType.hh:1183

C++ signature :
    void set_ideal_xyz(core::chemical::ResidueType {lvalue},void*,numeric::xyzVector<double>)

def set_low_energy_ring_conformers(

...)

set_low_energy_ring_conformers( (ResidueType)arg1, (vector1_string)conformers) -> None : Set this cyclic residue's low-energy ring conformers by IUPAC name.

C++ signature : void set_low_energy_ring_conformers(core::chemical::ResidueType {lvalue},utility::vector1 >)

def set_lower_connect_atom(

...)

set_lower_connect_atom( (ResidueType)arg1, (str)atm_name) -> None : set the atom which connects to the lower connection

C++ signature : void set_lower_connect_atom(core::chemical::ResidueType {lvalue},std::string)

def set_lowest_energy_ring_conformer(

...)

set_lowest_energy_ring_conformer( (ResidueType)arg1, (str)conformer) -> None : Set this cyclic residue's lowest-energy ring conformer by IUPAC name.

C++ signature : void set_lowest_energy_ring_conformer(core::chemical::ResidueType {lvalue},std::string)

def set_mainchain_atoms(

...)

set_mainchain_atoms( (ResidueType)arg1, (vector1_Size)mainchain) -> None : set indices of all mainchain atoms

C++ signature : void set_mainchain_atoms(core::chemical::ResidueType {lvalue},utility::vector1 >)

def set_mm_atom_type(

...)

set_mm_atom_type( (ResidueType)arg1, (str)atom_name, (str)mm_atom_type_name) -> None : set mm atom type

C++ signature : void set_mm_atom_type(core::chemical::ResidueType {lvalue},std::string,std::string)

def set_ncaa_rotlib_n_bin_per_rot(

...)

set_ncaa_rotlib_n_bin_per_rot( (ResidueType)arg1, (vector1_Size)n_bins_per_rot) -> None : Sets the number of rotamers for each rotatable bond described by the NCAA rotlib

C++ signature : void set_ncaa_rotlib_n_bin_per_rot(core::chemical::ResidueType {lvalue},utility::vector1 >)

def set_ncaa_rotlib_n_rotameric_bins(

...)

set_ncaa_rotlib_n_rotameric_bins( (ResidueType)arg1, (int)n_rots) -> None : Sets the number of rotatable bonds described by the NCAA rotlib (not nesesarily equal to nchi)

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

def set_ncaa_rotlib_path(

...)

set_ncaa_rotlib_path( (ResidueType)arg1, (str)path) -> None : Sets the path for the NCAA rotlib for the ResidueType

C++ signature : void set_ncaa_rotlib_path(core::chemical::ResidueType {lvalue},std::string)

def set_nrchi_start_angle(

...)

set_nrchi_start_angle( (ResidueType)arg1, (float)setting) -> None : core/chemical/ResidueType.hh:1896

C++ signature : void set_nrchi_start_angle(core::chemical::ResidueType {lvalue},double)

def set_nrchi_symmetric(

...)

set_nrchi_symmetric( (ResidueType)arg1, (bool)setting) -> None : core/chemical/ResidueType.hh:1887

C++ signature : void set_nrchi_symmetric(core::chemical::ResidueType {lvalue},bool)

def set_orbital_icoor_id(

...)

set_orbital_icoor_id( (ResidueType)arg1, (str)orbital, (float)phi, (float)theta, (float)d, (str)stub_atom1, (str)stub_atom2, (str)stub_atom3) -> None : set OrbitalICoor for an orbital

C++ signature : void set_orbital_icoor_id(core::chemical::ResidueType {lvalue},std::string,double,double,double,std::string,std::string,std::string)

def set_peptoid_rotlib_n_bin_per_rot(

...)

set_peptoid_rotlib_n_bin_per_rot( (ResidueType)arg1, (vector1_Size)n_bins_per_rot) -> None : Sets the number of rotamers for each rotatable bond described by the peptoid rotlib

C++ signature : void set_peptoid_rotlib_n_bin_per_rot(core::chemical::ResidueType {lvalue},utility::vector1 >)

def set_peptoid_rotlib_n_rotameric_bins(

...)

set_peptoid_rotlib_n_rotameric_bins( (ResidueType)arg1, (int)n_rots) -> None : Sets the number of rotatable bonds described by the peptoid rotlib (not nesesarily equal to nchi)

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

set_peptoid_rotlib_n_rotameric_bins( (ResidueType)arg1) -> int : Returns the number of rotatable bonds described by the peptoid rotlib (not nesesarily equal to nchi)

C++ signature :
    unsigned long set_peptoid_rotlib_n_rotameric_bins(core::chemical::ResidueType {lvalue})

def set_peptoid_rotlib_path(

...)

set_peptoid_rotlib_path( (ResidueType)arg1, (str)path) -> None : DOUG DOUG DOUG Sets the path for the peptoid rotlib for the ResidueType

C++ signature : void set_peptoid_rotlib_path(core::chemical::ResidueType {lvalue},std::string)

def set_proton_chi(

...)

set_proton_chi( (ResidueType)arg1, (int)chino, (vector1_Real)dihedral_samples, (vector1_Real)extra_samples) -> None : Annotate a given chi as a proton chi, and set the sampling behavior If the chi is already listed as a proton chi, change the sampling behavior

C++ signature : void set_proton_chi(core::chemical::ResidueType {lvalue},unsigned long,utility::vector1 >,utility::vector1 >)

def set_semirotameric_ncaa_rotlib(

...)

set_semirotameric_ncaa_rotlib( (ResidueType)arg1, (bool)flag) -> None : Sets whether our NCAA rotlib is semirotameric

C++ signature : void set_semirotameric_ncaa_rotlib(core::chemical::ResidueType {lvalue},bool)

def set_shadowing_atom(

...)

set_shadowing_atom( (ResidueType)arg1, (str)atom, (str)atom_being_shadowed) -> None : core/chemical/ResidueType.hh:1192

C++ signature : void set_shadowing_atom(core::chemical::ResidueType {lvalue},std::string,std::string)

def set_upper_connect_atom(

...)

set_upper_connect_atom( (ResidueType)arg1, (str)atm_name) -> None : set the atom which connects to the upper connection

C++ signature : void set_upper_connect_atom(core::chemical::ResidueType {lvalue},std::string)

def set_use_ncaa_rotlib(

...)

set_use_ncaa_rotlib( (ResidueType)arg1, (bool)flag) -> None : Sets whether we are using a NCAA rotlib for the residue type

C++ signature : void set_use_ncaa_rotlib(core::chemical::ResidueType {lvalue},bool)

def set_use_peptoid_rotlib(

...)

set_use_peptoid_rotlib( (ResidueType)arg1, (bool)flag) -> None : Sets whether we are using a peptoid rotlib for the residue type

C++ signature : void set_use_peptoid_rotlib(core::chemical::ResidueType {lvalue},bool)

def show(

...)

show( (ResidueType)arg1, (OStream)output [, (bool)output_atomic_details=False]) -> None : Generate string representation of ResidueType for debugging purposes.

C++ signature : void show(core::chemical::ResidueType {lvalue},std::ostream {lvalue} [,bool=False])

def show_all_atom_names(

...)

show_all_atom_names( (ResidueType)arg1, (OStream)out) -> None : core/chemical/ResidueType.hh:593

C++ signature : void show_all_atom_names(core::chemical::ResidueType {lvalue},std::ostream {lvalue})

def smallest_ring_size(

...)

smallest_ring_size( (ResidueType)arg1, (object)atom [, (int)max_size=999999]) -> int : A graph-based function to determine the size of the smallest ring that involves a given atom.

C++ signature : unsigned long smallest_ring_size(core::chemical::ResidueType {lvalue},void* [,unsigned long=999999])

def update_actcoord(

...)

update_actcoord( (ResidueType)arg1, (Residue)rot) -> None : update actcoord

C++ signature : void update_actcoord(core::chemical::ResidueType {lvalue},core::conformation::Residue {lvalue})

def upper_connect(

...)

upper_connect( (ResidueType)arg1) -> ResidueConnection : core/chemical/ResidueType.hh:858

C++ signature : core::chemical::ResidueConnection upper_connect(core::chemical::ResidueType {lvalue})

def upper_connect_atom(

...)

upper_connect_atom( (ResidueType)arg1) -> int : index number of the atom which connects to the upper connection

C++ signature : unsigned long upper_connect_atom(core::chemical::ResidueType {lvalue})

def upper_connect_id(

...)

upper_connect_id( (ResidueType)arg1) -> int : core/chemical/ResidueType.hh:861

C++ signature : unsigned long upper_connect_id(core::chemical::ResidueType {lvalue})

def within1bonds_sets_for_atom(

...)

within1bonds_sets_for_atom( (ResidueType)arg1, (int)atomid) -> vector1_pair_Size_Size : Returns a list of pairs for atom# atomid where first == the residue_connection id that lists atomid as being within one bond of a residue connection, and second == the index of the entry containing this atom in the atoms_within_one_bond_of_a_residue_connection_[ first ] array. Useful for calculating the derivatives for an atom.

C++ signature : utility::vector1, std::allocator > > within1bonds_sets_for_atom(core::chemical::ResidueType {lvalue},unsigned long)

def within2bonds_sets_for_atom(

...)

within2bonds_sets_for_atom( (ResidueType)arg1, (int)atomid) -> vector1_pair_Size_Size : Returns a list of pairs for atom # atomid where first == the residue_connection id that lists this atom as being within two bonds of a residue connection, and second == the index of the entry containing this atom in the atoms_within_two_bonds_of_a_residue_connection_[ first ] array. Useful for calculating the derivatives for an atom.

C++ signature : utility::vector1, std::allocator > > within2bonds_sets_for_atom(core::chemical::ResidueType {lvalue},unsigned long)

class ResidueTypeAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueTypeAP)arg1) -> ResidueType :

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

class ResidueTypeCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueTypeCAP)arg1) -> ResidueType :

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

class ResidueTypeKinWriter

core/chemical/ResidueTypeKinWriter.hh:36

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ResidueTypeKinWriter)) -> None : core/chemical/ResidueTypeKinWriter.hh:36

C++ signature :
    void __init__(_object*,core::chemical::ResidueTypeKinWriter)

def write_kin_header(

...)

write_kin_header( (ResidueTypeKinWriter)arg1, (OStream)ostr, (ResidueType)restype [, (int)which_kin=1]) -> None : write the header for the kinemage to center on this residue

C++ signature : void write_kin_header(core::chemical::ResidueTypeKinWriter {lvalue},std::ostream {lvalue},core::chemical::ResidueType [,unsigned long=1])

def write_restype(

...)

write_restype( (ResidueTypeKinWriter)arg1, (OStream)ostr, (ResidueType)restype [, (int)which_kin=1]) -> None : Write out settings for a particular ResidueType This should be similar to the kinemage files that molfile_to_params.py writes

C++ signature : void write_restype(core::chemical::ResidueTypeKinWriter {lvalue},std::ostream {lvalue},core::chemical::ResidueType [,unsigned long=1])

class ResidueTypeKinWriterAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueTypeKinWriterAP)arg1) -> ResidueTypeKinWriter :

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

class ResidueTypeKinWriterCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueTypeKinWriterCAP)arg1) -> ResidueTypeKinWriter :

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

class ResidueTypeSet

A collection of ResidueType defined One thing that is not nailed down is whether a single ResidueSet can have ResidueType's with different AtomTypeSets. I've left open this possibility currently although there isnt any code for this yet (PB-07/07)

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (str)name, (str)directory) -> None : constructor from directory

C++ signature :
    void __init__(_object*,std::string,std::string)

def aa_map(

...)

aa_map( (ResidueTypeSet)arg1, (AA)aa) -> object : query ResidueTypes by their AA enum type similar to name3_map, return all matched residue types or an empty list.

C++ signature : utility::vector1, std::allocator > > aa_map(core::chemical::ResidueTypeSet {lvalue},core::chemical::AA)

def aas_defined_begin(

...)

aas_defined_begin( (ResidueTypeSet)arg1) -> object : beginning of aas_defined_ list

C++ signature : std::_List_const_iterator aas_defined_begin(core::chemical::ResidueTypeSet {lvalue})

def aas_defined_end(

...)

aas_defined_end( (ResidueTypeSet)arg1) -> object : end of aas_defined_ list

C++ signature : std::_List_const_iterator aas_defined_end(core::chemical::ResidueTypeSet {lvalue})

def add_residue_type(

...)

add_residue_type( (ResidueTypeSet)arg1, (ResidueType)new_type) -> None : adds a new residue type to the set

C++ signature :
    void add_residue_type(core::chemical::ResidueTypeSet {lvalue},boost::shared_ptr<core::chemical::ResidueType>)

add_residue_type( (ResidueTypeSet)arg1, (str)filename) -> None : core/chemical/ResidueTypeSet.hh:142

C++ signature :
    void add_residue_type(core::chemical::ResidueTypeSet {lvalue},std::string)

def all_residues_begin(

...)

all_residues_begin( (ResidueTypeSet)arg1) -> object : core/chemical/ResidueTypeSet.hh:221

C++ signature : std::_Rb_tree_const_iterator > > all_residues_begin(core::chemical::ResidueTypeSet {lvalue})

def all_residues_end(

...)

all_residues_end( (ResidueTypeSet)arg1) -> object : core/chemical/ResidueTypeSet.hh:227

C++ signature : std::_Rb_tree_const_iterator > > all_residues_end(core::chemical::ResidueTypeSet {lvalue})

def apply_patches(

...)

apply_patches( (ResidueTypeSet)arg1, (vector1_string)filenames) -> None : core/chemical/ResidueTypeSet.hh:131

C++ signature : void apply_patches(core::chemical::ResidueTypeSet {lvalue},utility::vector1 >)

def atom_type_set(

...)

atom_type_set( (ResidueTypeSet)arg1) -> AtomTypeSet : core/chemical/ResidueTypeSet.hh:94

C++ signature :
    boost::shared_ptr<core::chemical::AtomTypeSet const> atom_type_set(core::chemical::ResidueTypeSet {lvalue})

atom_type_set( (ResidueTypeSet)arg1, (AtomTypeSet)atom_types) -> None : core/chemical/ResidueTypeSet.hh:99

C++ signature :
    void atom_type_set(core::chemical::ResidueTypeSet {lvalue},boost::shared_ptr<core::chemical::AtomTypeSet const>)

def create_adduct_combinations(

...)

create_adduct_combinations( (ResidueTypeSet)arg1, (ResidueType)rsd, (map_string_int)ref_map, (map_string_int)count_map, (vector1_bool)add_mask, (object)work_iter) -> None : Create correct combinations of adducts for a residue type

C++ signature : void create_adduct_combinations(core::chemical::ResidueTypeSet {lvalue},core::chemical::ResidueType,std::map, std::allocator > >,std::map, std::allocator > >,utility::vector1 >,gnu_cxx::normal_iterator > >)

def database_directory(

...)

database_directory( (ResidueTypeSet)arg1) -> str : accessor for database_directory

C++ signature : std::string database_directory(core::chemical::ResidueTypeSet {lvalue})

def element_set(

...)

element_set( (ResidueTypeSet)arg1) -> ElementSet : core/chemical/ResidueTypeSet.hh:95

C++ signature :
    boost::shared_ptr<core::chemical::ElementSet const> element_set(core::chemical::ResidueTypeSet {lvalue})

element_set( (ResidueTypeSet)arg1, (ElementSet)elements) -> None : core/chemical/ResidueTypeSet.hh:103

C++ signature :
    void element_set(core::chemical::ResidueTypeSet {lvalue},boost::shared_ptr<core::chemical::ElementSet const>)

def get_residue_type_with_variant_added(

...)

get_residue_type_with_variant_added( (ResidueTypeSet)arg1, (ResidueType)init_rsd, (VariantType)new_type) -> ResidueType : Query a variant ResidueType by its base ResidueType and VariantType

C++ signature : core::chemical::ResidueType get_residue_type_with_variant_added(core::chemical::ResidueTypeSet {lvalue},core::chemical::ResidueType,core::chemical::VariantType)

def get_residue_type_with_variant_removed(

...)

get_residue_type_with_variant_removed( (ResidueTypeSet)arg1, (ResidueType)init_rsd, (VariantType)old_type) -> ResidueType : return the residuetype we get from variant rsd type after removing the desired variant type

C++ signature : core::chemical::ResidueType get_residue_type_with_variant_removed(core::chemical::ResidueTypeSet {lvalue},core::chemical::ResidueType,core::chemical::VariantType)

def get_self_ptr(

...)

get_self_ptr( (ResidueTypeSet)arg1) -> ResidueTypeSet : self pointers

C++ signature :
    boost::shared_ptr<core::chemical::ResidueTypeSet const> get_self_ptr(core::chemical::ResidueTypeSet {lvalue})

get_self_ptr( (ResidueTypeSet)arg1) -> ResidueTypeSet : core/chemical/ResidueTypeSet.hh:84

C++ signature :
    boost::shared_ptr<core::chemical::ResidueTypeSet> get_self_ptr(core::chemical::ResidueTypeSet {lvalue})

def get_self_weak_ptr(

...)

get_self_weak_ptr( (ResidueTypeSet)arg1) -> ResidueTypeSetCAP : core/chemical/ResidueTypeSet.hh:85

C++ signature : boost::weak_ptr get_self_weak_ptr(core::chemical::ResidueTypeSet {lvalue})

def has_name(

...)

has_name( (ResidueTypeSet)arg1, (str)name) -> bool : query if a ResidueType of the unique residue id (name) is present.

C++ signature : bool has_name(core::chemical::ResidueTypeSet {lvalue},std::string)

def has_name3(

...)

has_name3( (ResidueTypeSet)arg1, (str)name3) -> bool : query if any ResidueTypes in the set have a "name3" tat matches the input name3

C++ signature : bool has_name3(core::chemical::ResidueTypeSet {lvalue},std::string)

def init(

...)

init( (ResidueTypeSet)arg1, (std_vector_string)extra_res_param_files, (std_vector_string)extra_patch_files) -> None : core/chemical/ResidueTypeSet.hh:80

C++ signature : void init(core::chemical::ResidueTypeSet {lvalue},std::vector >,std::vector >)

def interchangeability_group_map(

...)

interchangeability_group_map( (ResidueTypeSet)arg1, (str)name) -> object : query ResidueTypes by their interchangeability-group name

C++ signature : utility::vector1, std::allocator > > interchangeability_group_map(core::chemical::ResidueTypeSet {lvalue},std::string)

def mm_atom_type_set(

...)

mm_atom_type_set( (ResidueTypeSet)arg1) -> MMAtomTypeSet : core/chemical/ResidueTypeSet.hh:96

C++ signature :
    boost::shared_ptr<core::chemical::MMAtomTypeSet const> mm_atom_type_set(core::chemical::ResidueTypeSet {lvalue})

mm_atom_type_set( (ResidueTypeSet)arg1, (MMAtomTypeSet)mm_atom_types) -> None : core/chemical/ResidueTypeSet.hh:107

C++ signature :
    void mm_atom_type_set(core::chemical::ResidueTypeSet {lvalue},boost::shared_ptr<core::chemical::MMAtomTypeSet const>)

def name(

...)

name( (ResidueTypeSet)arg1) -> str : name of the residue type set

C++ signature : std::string name(core::chemical::ResidueTypeSet {lvalue})

def name3_map(

...)

name3_map( (ResidueTypeSet)arg1, (str)name) -> object : query ResidueTypes by their 3-letter name

C++ signature : utility::vector1, std::allocator > > name3_map(core::chemical::ResidueTypeSet {lvalue},std::string)

def name_map(

...)

name_map( (ResidueTypeSet)arg1, (str)name) -> ResidueType : query ResidueType by its unique residue id. since residue id is unique, it only returns one residue type or exit without match.

C++ signature : core::chemical::ResidueType name_map(core::chemical::ResidueTypeSet {lvalue},std::string)

def orbital_type_set(

...)

orbital_type_set( (ResidueTypeSet)arg1) -> OrbitalTypeSet : core/chemical/ResidueTypeSet.hh:97

C++ signature :
    boost::shared_ptr<core::chemical::orbitals::OrbitalTypeSet const> orbital_type_set(core::chemical::ResidueTypeSet {lvalue})

orbital_type_set( (ResidueTypeSet)arg1, (OrbitalTypeSet)orbital_types) -> None : core/chemical/ResidueTypeSet.hh:111

C++ signature :
    void orbital_type_set(core::chemical::ResidueTypeSet {lvalue},boost::shared_ptr<core::chemical::orbitals::OrbitalTypeSet const>)

def place_adducts(

...)

place_adducts( (ResidueTypeSet)arg1) -> None : apply patches to base ResidueType to generate variant ResidueTyes

C++ signature : void place_adducts(core::chemical::ResidueTypeSet {lvalue})

def read_files(

...)

read_files( (ResidueTypeSet)arg1, (vector1_string)filenames) -> None : core/chemical/ResidueTypeSet.hh:125

C++ signature : void read_files(core::chemical::ResidueTypeSet {lvalue},utility::vector1 >)

def read_list_of_residues(

...)

read_list_of_residues( (ResidueTypeSet)arg1, (str)list_filename) -> None : read a list of residue types

C++ signature : void read_list_of_residues(core::chemical::ResidueTypeSet {lvalue},std::string)

def remove_residue_type(

...)

remove_residue_type( (ResidueTypeSet)arg1, (str)name) -> None : delete a residue type from the set (Use with care)

C++ signature : void remove_residue_type(core::chemical::ResidueTypeSet {lvalue},std::string)

def residue_types(

...)

residue_types( (ResidueTypeSet)arg1) -> object : alternate access to all residuetypes as vector

C++ signature : utility::vector1, std::allocator > > residue_types(core::chemical::ResidueTypeSet {lvalue})

def select_residues(

...)

select_residues( (ResidueTypeSet)arg1, (ResidueSelector)selector, (object)matches) -> None : select a set of ResidueTypes give certain criteria

C++ signature : void select_residues(core::chemical::ResidueTypeSet {lvalue},core::chemical::ResidueSelector,utility::vector1, std::allocator > > {lvalue})

class ResidueTypeSetAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueTypeSetAP)arg1) -> ResidueTypeSet :

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

class ResidueTypeSetCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (ResidueTypeSetCAP)arg1) -> ResidueTypeSet :

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

class RingConformer

A structure for storing information for specific, idealized ring conformers.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

class RingConformerAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RingConformerAP)arg1) -> RingConformer :

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

class RingConformerCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RingConformerCAP)arg1) -> RingConformer :

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

class RingConformerManager

This class is a singleton and manages RingConformer data that should only be read from the database one time and shared among all RingConformerSets.

Ancestors (in MRO)

class RingConformerManagerAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RingConformerManagerAP)arg1) -> RingConformerManager :

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

class RingConformerManagerCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RingConformerManagerCAP)arg1) -> RingConformerManager :

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

class RingConformerSet

core/chemical/RingConformerSet.hh:46

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1, (int)ring_size, (str)lowest_conformer, (vector1_string)low_conformers) -> None : Standard constructor

C++ signature :
    void __init__(_object*,unsigned long,std::string,utility::vector1<std::string, std::allocator<std::string> >)

init( (object)arg1, (RingConformerSet)object_to_copy) -> None : Copy constructor

C++ signature :
    void __init__(_object*,core::chemical::RingConformerSet)

def assign(

...)

assign( (RingConformerSet)arg1, (RingConformerSet)object_to_copy) -> RingConformerSet : core/chemical/RingConformerSet.hh:59

C++ signature : core::chemical::RingConformerSet {lvalue} assign(core::chemical::RingConformerSet {lvalue},core::chemical::RingConformerSet)

def get_all_nondegenerate_conformers(

...)

get_all_nondegenerate_conformers( (RingConformerSet)arg1) -> object : Return a list of all nondegenerate conformers in the set.

C++ signature : utility::vector1 > get_all_nondegenerate_conformers(core::chemical::RingConformerSet {lvalue})

def get_ideal_conformer_by_CP_parameters(

...)

get_ideal_conformer_by_CP_parameters( (RingConformerSet)arg1, (vector1_Real)parameters) -> RingConformer : Return the conformer that is the best fit for the provided Cremer-Pople parameters.

C++ signature : core::chemical::RingConformer get_ideal_conformer_by_CP_parameters(core::chemical::RingConformerSet {lvalue},utility::vector1 >)

def get_ideal_conformer_by_name(

...)

get_ideal_conformer_by_name( (RingConformerSet)arg1, (str)name) -> RingConformer : Return the conformer corresponding to the requested name.

C++ signature : core::chemical::RingConformer get_ideal_conformer_by_name(core::chemical::RingConformerSet {lvalue},std::string)

def get_ideal_conformer_from_nus(

...)

get_ideal_conformer_from_nus( (RingConformerSet)arg1, (vector1_Real)angles) -> RingConformer : Return the conformer that is the best fit for the provided list of nu angles.

C++ signature : core::chemical::RingConformer get_ideal_conformer_from_nus(core::chemical::RingConformerSet {lvalue},utility::vector1 >)

def get_lowest_energy_conformer(

...)

get_lowest_energy_conformer( (RingConformerSet)arg1) -> RingConformer : Return the conformer that is known from studies (if available) to be the lowest energy ring conformer.

C++ signature : core::chemical::RingConformer get_lowest_energy_conformer(core::chemical::RingConformerSet {lvalue})

def get_random_conformer(

...)

get_random_conformer( (RingConformerSet)arg1) -> RingConformer : Return a random conformer from the set.

C++ signature : core::chemical::RingConformer get_random_conformer(core::chemical::RingConformerSet {lvalue})

def get_random_local_min_conformer(

...)

get_random_local_min_conformer( (RingConformerSet)arg1) -> RingConformer : Return a random conformer from the subset of conformers that are local minima.

C++ signature : core::chemical::RingConformer get_random_local_min_conformer(core::chemical::RingConformerSet {lvalue})

def low_energy_conformers_are_known(

...)

low_energy_conformers_are_known( (RingConformerSet)arg1) -> bool : Are the low-energy conformers known for this set?

C++ signature : bool low_energy_conformers_are_known(core::chemical::RingConformerSet {lvalue})

def ring_size(

...)

ring_size( (RingConformerSet)arg1) -> int : Return the ring size of the conformers in this set.

C++ signature : unsigned long ring_size(core::chemical::RingConformerSet {lvalue})

def show(

...)

show( (RingConformerSet)arg1, (OStream)output) -> None : Generate string representation of RingConformerSet for debugging purposes.

C++ signature :
    void show(core::chemical::RingConformerSet {lvalue},std::ostream {lvalue})

show( (RingConformerSet)arg1, (OStream)output) -> None :

C++ signature :
    void show(RingConformerSet_exposer_callback {lvalue},std::ostream {lvalue})

def size(

...)

size( (RingConformerSet)arg1) -> int : Return the size of the conformer set.

C++ signature : unsigned long size(core::chemical::RingConformerSet {lvalue})

class RingConformerSetAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RingConformerSetAP)arg1) -> RingConformerSet :

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

class RingConformerSetCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (RingConformerSetCAP)arg1) -> RingConformerSet :

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

class Selector_AA

///////////////////////////////////////////////////////////////////////////////////// Does the residue belong to ANY of these AAs?

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (object)aas_in, (bool)result) -> None : core/chemical/ResidueSelector.hh:88

C++ signature :
    void __init__(_object*,utility::vector1<core::chemical::AA, std::allocator<core::chemical::AA> >,bool)

init( (object)arg1, (Selector_AA)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Does the residue belong to ANY of these AAs?

C++ signature :
    void __init__(_object*,core::chemical::Selector_AA)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_AAAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_AAAP)arg1) -> Selector_AA :

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

class Selector_AACAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_AACAP)arg1) -> Selector_AA :

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

class Selector_CMDFLAG

///////////////////////////////////////////////////////////////////////////////////// Is a certain string in the command-line option -chemical:allow_patch present ? this selector does actually not depend on the residuetype it is queried for

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (str)flags_in, (bool)result) -> None : core/chemical/ResidueSelector.hh:115

C++ signature :
    void __init__(_object*,std::string,bool)

init( (object)arg1, (Selector_CMDFLAG)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Is a certain string in the command-line option -chemical:allow_patch present ? this selector does actually not depend on the residuetype it is queried for

C++ signature :
    void __init__(_object*,core::chemical::Selector_CMDFLAG)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_CMDFLAGAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_CMDFLAGAP)arg1) -> Selector_CMDFLAG :

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

class Selector_CMDFLAGCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_CMDFLAGCAP)arg1) -> Selector_CMDFLAG :

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

class Selector_MATCH_VARIANTS

///////////////////////////////////////////////////////////////////////////////////// Does the residue have ALL of the variant types and no more

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (vector1_string)variants_in, (bool)result) -> None : core/chemical/ResidueSelector.hh:251

C++ signature :
    void __init__(_object*,utility::vector1<std::string, std::allocator<std::string> >,bool)

init( (object)arg1, (Selector_MATCH_VARIANTS)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Does the residue have ALL of the variant types and no more

C++ signature :
    void __init__(_object*,core::chemical::Selector_MATCH_VARIANTS)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_MATCH_VARIANTSAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_MATCH_VARIANTSAP)arg1) -> Selector_MATCH_VARIANTS :

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

class Selector_MATCH_VARIANTSCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_MATCH_VARIANTSCAP)arg1) -> Selector_MATCH_VARIANTS :

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

class Selector_NAME1

///////////////////////////////////////////////////////////////////////////////////// Does the residue belong to ANY of these one-letter codes?

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (str)n, (bool)result) -> None : core/chemical/ResidueSelector.hh:298

C++ signature :
    void __init__(_object*,char,bool)

init( (object)arg1, (Selector_NAME1)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Does the residue belong to ANY of these one-letter codes?

C++ signature :
    void __init__(_object*,core::chemical::Selector_NAME1)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_NAME1AP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_NAME1AP)arg1) -> Selector_NAME1 :

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

class Selector_NAME1CAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_NAME1CAP)arg1) -> Selector_NAME1 :

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

class Selector_NAME3

///////////////////////////////////////////////////////////////////////////////////// Does the residue have to ANY of these three-letter codes?

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (vector1_string)name3s_in, (bool)result) -> None : core/chemical/ResidueSelector.hh:137

C++ signature :
    void __init__(_object*,utility::vector1<std::string, std::allocator<std::string> >,bool)

init( (object)arg1, (Selector_NAME3)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Does the residue have to ANY of these three-letter codes?

C++ signature :
    void __init__(_object*,core::chemical::Selector_NAME3)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_NAME3AP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_NAME3AP)arg1) -> Selector_NAME3 :

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

class Selector_NAME3CAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_NAME3CAP)arg1) -> Selector_NAME3 :

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

class Selector_NO_VARIANTS

///////////////////////////////////////////////////////////////////////////////////// Does the residue have NO variant types?

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (bool)result) -> None : core/chemical/ResidueSelector.hh:279

C++ signature :
    void __init__(_object*,bool)

init( (object)arg1, (Selector_NO_VARIANTS)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Does the residue have NO variant types?

C++ signature :
    void __init__(_object*,core::chemical::Selector_NO_VARIANTS)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_NO_VARIANTSAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_NO_VARIANTSAP)arg1) -> Selector_NO_VARIANTS :

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

class Selector_NO_VARIANTSCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_NO_VARIANTSCAP)arg1) -> Selector_NO_VARIANTS :

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

class Selector_PROPERTY

///////////////////////////////////////////////////////////////////////////////////// Does the residue have ANY of these properties?

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (vector1_string)properties_in, (bool)result) -> None : core/chemical/ResidueSelector.hh:160

C++ signature :
    void __init__(_object*,utility::vector1<std::string, std::allocator<std::string> >,bool)

init( (object)arg1, (Selector_PROPERTY)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Does the residue have ANY of these properties?

C++ signature :
    void __init__(_object*,core::chemical::Selector_PROPERTY)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_PROPERTYAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_PROPERTYAP)arg1) -> Selector_PROPERTY :

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

class Selector_PROPERTYCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_PROPERTYCAP)arg1) -> Selector_PROPERTY :

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

class Selector_UPPER_POSITION

///////////////////////////////////////////////////////////////////////////////////// Does the main chain of this residue follow from the given position label? By position, it is meant the single digit integer by which atoms are labeled to indicate their position. For example, if an upper connection is from C8 of a generic residue, the position is 8. @remarks This selector was added primarily for use with carbohydrate residues, which have a wide assortment of main- chain designations. To properly patch upper terminus variants, it is necessary to know which atoms need to be added and, particularly, at which position to add them. However, this selector could be adapted for any residue subclass that contains variability in the main chain, provided the nomenclature is consistent and numerical. See patches/carbohydrates/upper_terminus.txt for an example of use. Labonte

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (int)position, (bool)result) -> None : core/chemical/ResidueSelector.hh:220

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

init( (object)arg1, (Selector_UPPER_POSITION)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Does the main chain of this residue follow from the given position label? By position, it is meant the single digit integer by which atoms are labeled to indicate their position. For example, if an upper connection is from C8 of a generic residue, the position is 8. @remarks This selector was added primarily for use with carbohydrate residues, which have a wide assortment of main- chain designations. To properly patch upper terminus variants, it is necessary to know which atoms need to be added and, particularly, at which position to add them. However, this selector could be adapted for any residue subclass that contains variability in the main chain, provided the nomenclature is consistent and numerical. See patches/carbohydrates/upper_terminus.txt for an example of use. Labonte

C++ signature :
    void __init__(_object*,core::chemical::Selector_UPPER_POSITION)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_UPPER_POSITIONAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_UPPER_POSITIONAP)arg1) -> Selector_UPPER_POSITION :

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

class Selector_UPPER_POSITIONCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_UPPER_POSITIONCAP)arg1) -> Selector_UPPER_POSITION :

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

class Selector_VARIANT_TYPE

///////////////////////////////////////////////////////////////////////////////////// Does the residue have ANY of variant types?

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: ResidueSelectorSingle.__init__

init( (object)arg1, (vector1_string)variants_in, (bool)result) -> None : core/chemical/ResidueSelector.hh:187

C++ signature :
    void __init__(_object*,utility::vector1<std::string, std::allocator<std::string> >,bool)

init( (object)arg1, (Selector_VARIANT_TYPE)) -> None : ///////////////////////////////////////////////////////////////////////////////////// Does the residue have ANY of variant types?

C++ signature :
    void __init__(_object*,core::chemical::Selector_VARIANT_TYPE)

def desired_result(

...)

Inheritance: ResidueSelectorSingle.desired_result

desired_result( (ResidueSelectorSingle)arg1) -> bool : core/chemical/ResidueSelector.hh:67

C++ signature : bool desired_result(core::chemical::ResidueSelectorSingle {lvalue})

class Selector_VARIANT_TYPEAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_VARIANT_TYPEAP)arg1) -> Selector_VARIANT_TYPE :

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

class Selector_VARIANT_TYPECAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (Selector_VARIANT_TYPECAP)arg1) -> Selector_VARIANT_TYPE :

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

class SetAtomType

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set atom's chemical type

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in, (str)atom_type_name_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,std::string)

init( (object)arg1, (SetAtomType)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set atom's chemical type

C++ signature :
    void __init__(_object*,core::chemical::SetAtomType)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetAtomType)arg1, (ResidueType)rsd) -> bool : set atom's chemical type

C++ signature :
    bool apply(core::chemical::SetAtomType {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetAtomType)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetAtomType_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetAtomTypeAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetAtomTypeAP)arg1) -> SetAtomType :

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

class SetAtomTypeCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetAtomTypeCAP)arg1) -> SetAtomType :

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

class SetAtomicCharge

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set an atom's charge

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in, (float)charge_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,double)

init( (object)arg1, (SetAtomicCharge)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set an atom's charge

C++ signature :
    void __init__(_object*,core::chemical::SetAtomicCharge)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetAtomicCharge)arg1, (ResidueType)rsd) -> bool : set an atom's charge

C++ signature :
    bool apply(core::chemical::SetAtomicCharge {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetAtomicCharge)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetAtomicCharge_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetAtomicChargeAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetAtomicChargeAP)arg1) -> SetAtomicCharge :

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

class SetAtomicChargeCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetAtomicChargeCAP)arg1) -> SetAtomicCharge :

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

class SetBackboneHeavyatom

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set an atom as backbone heavy atom

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (SetBackboneHeavyatom)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set an atom as backbone heavy atom

C++ signature :
    void __init__(_object*,core::chemical::SetBackboneHeavyatom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetBackboneHeavyatom)arg1, (ResidueType)rsd) -> bool : set an atom in ResidueType rsd as backbone heavy atom

C++ signature :
    bool apply(core::chemical::SetBackboneHeavyatom {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetBackboneHeavyatom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetBackboneHeavyatom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetBackboneHeavyatomAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetBackboneHeavyatomAP)arg1) -> SetBackboneHeavyatom :

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

class SetBackboneHeavyatomCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetBackboneHeavyatomCAP)arg1) -> SetBackboneHeavyatom :

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

class SetFormalCharge

//////////////////////////////////////////////////////////////////////////// A patch operation for setting the formal charge of a ResidueType's atom. Labonte JWLabonte@jhu.edu

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in, (int)charge_in) -> None : core/chemical/PatchOperation.hh:426

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

init( (object)arg1, (SetFormalCharge)) -> None : //////////////////////////////////////////////////////////////////////////// A patch operation for setting the formal charge of a ResidueType's atom. Labonte JWLabonte@jhu.edu

C++ signature :
    void __init__(_object*,core::chemical::SetFormalCharge)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetFormalCharge)arg1, (ResidueType)rsd) -> bool : Apply this patch to the given ResidueType.

C++ signature :
    bool apply(core::chemical::SetFormalCharge {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetFormalCharge)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetFormalCharge_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetFormalChargeAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetFormalChargeAP)arg1) -> SetFormalCharge :

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

class SetFormalChargeCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetFormalChargeCAP)arg1) -> SetFormalCharge :

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

class SetICoor

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set an atom's AtomICoord

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_in, (float)phi_in, (float)theta_in, (float)d_in, (str)stub1_in, (str)stub2_in, (str)stub3_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,double,double,double,std::string,std::string,std::string)

init( (object)arg1, (SetICoor)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set an atom's AtomICoord

C++ signature :
    void __init__(_object*,core::chemical::SetICoor)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetICoor)arg1, (ResidueType)rsd) -> bool : set an atom's AtomICoord

C++ signature :
    bool apply(core::chemical::SetICoor {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetICoor)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetICoor_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetICoorAP

Ancestors (in MRO)

  • SetICoorAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetICoorAP)arg1) -> SetICoor :

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

class SetICoorCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetICoorCAP)arg1) -> SetICoor :

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

class SetIO_String

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set atom's chemical type

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)name3, (str)name1) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,char)

init( (object)arg1, (SetIO_String)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set atom's chemical type

C++ signature :
    void __init__(_object*,core::chemical::SetIO_String)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetIO_String)arg1, (ResidueType)rsd) -> bool : set atom's chemical type

C++ signature :
    bool apply(core::chemical::SetIO_String {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetIO_String)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetIO_String_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetIO_StringAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetIO_StringAP)arg1) -> SetIO_String :

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

class SetIO_StringCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetIO_StringCAP)arg1) -> SetIO_String :

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

class SetInterchangeabilityGroup_String

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set the interchangeability_group string for a ResidueType

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)intgrp) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (SetInterchangeabilityGroup_String)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set the interchangeability_group string for a ResidueType

C++ signature :
    void __init__(_object*,core::chemical::SetInterchangeabilityGroup_String)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetInterchangeabilityGroup_String)arg1, (ResidueType)rsd) -> bool : core/chemical/PatchOperation.hh:487

C++ signature :
    bool apply(core::chemical::SetInterchangeabilityGroup_String {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetInterchangeabilityGroup_String)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetInterchangeabilityGroup_String_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetInterchangeabilityGroup_StringAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetInterchangeabilityGroup_StringAP)arg1) -> SetInterchangeabilityGroup_String :

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

class SetInterchangeabilityGroup_StringCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetInterchangeabilityGroup_StringCAP)arg1) -> SetInterchangeabilityGroup_String :

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

class SetMMAtomType

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set atom's MM chemical type

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in, (str)mm_atom_type_name_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string,std::string)

init( (object)arg1, (SetMMAtomType)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set atom's MM chemical type

C++ signature :
    void __init__(_object*,core::chemical::SetMMAtomType)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetMMAtomType)arg1, (ResidueType)rsd) -> bool : set atom's chemical type

C++ signature :
    bool apply(core::chemical::SetMMAtomType {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetMMAtomType)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetMMAtomType_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetMMAtomTypeAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetMMAtomTypeAP)arg1) -> SetMMAtomType :

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

class SetMMAtomTypeCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetMMAtomTypeCAP)arg1) -> SetMMAtomType :

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

class SetNbrAtom

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set the residue neighbor atom

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in) -> None : constructor

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (SetNbrAtom)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set the residue neighbor atom

C++ signature :
    void __init__(_object*,core::chemical::SetNbrAtom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetNbrAtom)arg1, (ResidueType)rsd) -> bool : set the residue neighbor atom

C++ signature :
    bool apply(core::chemical::SetNbrAtom {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetNbrAtom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetNbrAtom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetNbrAtomAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetNbrAtomAP)arg1) -> SetNbrAtom :

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

class SetNbrAtomCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetNbrAtomCAP)arg1) -> SetNbrAtom :

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

class SetNbrRadius

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set the residue neighbor radius

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (float)radius) -> None : constructor

C++ signature :
    void __init__(_object*,double)

init( (object)arg1, (SetNbrRadius)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set the residue neighbor radius

C++ signature :
    void __init__(_object*,core::chemical::SetNbrRadius)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetNbrRadius)arg1, (ResidueType)rsd) -> bool : set the residue neighbor atom

C++ signature :
    bool apply(core::chemical::SetNbrRadius {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetNbrRadius)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetNbrRadius_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetNbrRadiusAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetNbrRadiusAP)arg1) -> SetNbrRadius :

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

class SetNbrRadiusCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetNbrRadiusCAP)arg1) -> SetNbrRadius :

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

class SetOrientAtom

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Set orient atom selection mode.

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (bool)force_nbr_atom_orient) -> None : core/chemical/PatchOperation.hh:626

C++ signature :
    void __init__(_object*,bool)

init( (object)arg1, (SetOrientAtom)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Set orient atom selection mode.

C++ signature :
    void __init__(_object*,core::chemical::SetOrientAtom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetOrientAtom)arg1, (ResidueType)rsd) -> bool : core/chemical/PatchOperation.hh:629

C++ signature :
    bool apply(core::chemical::SetOrientAtom {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetOrientAtom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetOrientAtom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetOrientAtomAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetOrientAtomAP)arg1) -> SetOrientAtom :

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

class SetOrientAtomCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetOrientAtomCAP)arg1) -> SetOrientAtom :

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

class SetPolymerConnectAtom

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set an atom as polymer connection

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: PatchOperation.__init__

init( (object)arg1, (str)atom_name_in, (str)upper_lower_in) -> None : constructor the type of connection is "LOWER" or "UPPER"

C++ signature :
    void __init__(_object*,std::string,std::string)

init( (object)arg1, (SetPolymerConnectAtom)) -> None : //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// set an atom as polymer connection

C++ signature :
    void __init__(_object*,core::chemical::SetPolymerConnectAtom)

def apply(

...)

Inheritance: PatchOperation.apply

apply( (SetPolymerConnectAtom)arg1, (ResidueType)rsd) -> bool : set an atom in ResidueType rsd as a polymer connection atom

C++ signature :
    bool apply(core::chemical::SetPolymerConnectAtom {lvalue},core::chemical::ResidueType {lvalue})

apply( (SetPolymerConnectAtom)arg1, (ResidueType)rsd) -> bool :

C++ signature :
    bool apply(SetPolymerConnectAtom_exposer_callback {lvalue},core::chemical::ResidueType {lvalue})

class SetPolymerConnectAtomAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetPolymerConnectAtomAP)arg1) -> SetPolymerConnectAtom :

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

class SetPolymerConnectAtomCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SetPolymerConnectAtomCAP)arg1) -> SetPolymerConnectAtom :

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

class SingletonBase_T_core_chemical_ChemicalManager_T

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

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

class SingletonBase_T_core_chemical_ChemicalManager_TAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SingletonBase_T_core_chemical_ChemicalManager_TAP)arg1) -> SingletonBase_T_core_chemical_ChemicalManager_T :

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

class SingletonBase_T_core_chemical_ChemicalManager_TCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SingletonBase_T_core_chemical_ChemicalManager_TCAP)arg1) -> SingletonBase_T_core_chemical_ChemicalManager_T :

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

class SingletonBase_T_core_chemical_RingConformerManager_T

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

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

class SingletonBase_T_core_chemical_RingConformerManager_TAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SingletonBase_T_core_chemical_RingConformerManager_TAP)arg1) -> SingletonBase_T_core_chemical_RingConformerManager_T :

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

class SingletonBase_T_core_chemical_RingConformerManager_TCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SingletonBase_T_core_chemical_RingConformerManager_TCAP)arg1) -> SingletonBase_T_core_chemical_RingConformerManager_T :

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

class VariantType

Enumerators for all the ResidueType variants. VariantTypes are primarily utilized by the patch system. All the type does is add an identifier that can be used later on in different protocols. It also helps the patch system keep track of which residues are patched with which patches.

Ancestors (in MRO)

  • VariantType
  • Boost.Python.enum
  • __builtin__.int
  • __builtin__.object

Class variables

var ACETYLATED_NTERMINUS_VARIANT

var ACETYLATION

var ADDUCT_VARIANT

var ALDONIC_ACID_VARIANT

var ALTERNATIVE_PROTONATION

var BRANCH_LOWER_TERMINUS_VARIANT

var BULGE

var C1_ACETYLAMINO_SUGAR

var C1_AMINO_SUGAR

var C1_BRANCH_POINT

var C1_DEOXY_SUGAR

var C1_PHOSPHATE

var C2_ACETYLAMINO_SUGAR

var C2_AMINO_SUGAR

var C2_BRANCH_POINT

var C2_DEOXY_SUGAR

var C2_KETOALDONIC_ACID

var C2_PHOSPHATE

var C3_ACETYLAMINO_SUGAR

var C3_AMINO_SUGAR

var C3_BRANCH_POINT

var C3_DEOXY_SUGAR

var C3_KETOALDONIC_ACID

var C3_PHOSPHATE

var C4_ACETYLAMINO_SUGAR

var C4_AMINO_SUGAR

var C4_BRANCH_POINT

var C4_DEOXY_SUGAR

var C4_KETOALDONIC_ACID

var C4_PHOSPHATE

var C5_ACETYLAMINO_SUGAR

var C5_AMINO_SUGAR

var C5_BRANCH_POINT

var C5_DEOXY_SUGAR

var C5_KETOALDONIC_ACID

var C5_PHOSPHATE

var C6_ACETYLAMINO_SUGAR

var C6_AMINO_SUGAR

var C6_BRANCH_POINT

var C6_DEOXY_SUGAR

var C6_KETOALDONIC_ACID

var C6_PHOSPHATE

var C7_ACETYLAMINO_SUGAR

var C7_AMINO_SUGAR

var C7_BRANCH_POINT

var C7_DEOXY_SUGAR

var C7_KETOALDONIC_ACID

var C7_PHOSPHATE

var C8_ACETYLAMINO_SUGAR

var C8_AMINO_SUGAR

var C8_BRANCH_POINT

var C8_DEOXY_SUGAR

var C8_KETOALDONIC_ACID

var C8_PHOSPHATE

var C9_ACETYLAMINO_SUGAR

var C9_AMINO_SUGAR

var C9_BRANCH_POINT

var C9_DEOXY_SUGAR

var C9_PHOSPHATE

var CARBOXYLATION

var CENTROID_HA

var CTERM_CONNECT

var CUTPOINT_LOWER

var CUTPOINT_UPPER

var C_METHYLAMIDATION

var DEPROTONATED

var DIIODINATION

var DIMETHYLATION

var DISULFIDE

var FIRST_VARIANT

var FIVE_PRIME_END_OH

var FIVE_PRIME_END_PHOSPHATE

var FIVE_PRIME_PACKABLE_PHOSPHATE

var FIVE_PRIME_PHOSPHATE

var HBS_POST

var HBS_PRE

var HYDROXYLATION

var HYDROXYLATION1

var HYDROXYLATION2

var LOWERTERM_TRUNC_VARIANT

var LOWER_TERMINUS_VARIANT

var METHYLATED_CTERMINUS_VARIANT

var METHYLATED_NTERM_VARIANT

var METHYLATION

var METHYL_GLYCOSIDE

var NE2_CONNECT

var NTERM_CONNECT

var N_ACETYLATION

var N_VARIANTS

var OOP_POST

var OOP_PRE

var PHOSPHONATE_UPPER_VARIANT

var PHOSPHORYLATION

var PROTONATED

var PROTONATED_H1_ADENOSINE

var REPLONLY

var SC_BRANCH_POINT

var SC_FRAGMENT

var SG_CONNECT

var SHOVE_BB

var SIDECHAIN_CONJUGATION

var SPECIAL_ROT

var SULFATION

var THREE_PRIME_END_OH

var THREE_PRIME_PACKABLE_PHOSPHATE

var THREE_PRIME_PHOSPHATE

var TRIMETHYLATION

var UPPERTERM_TRUNC_VARIANT

var UPPER_TERMINUS_VARIANT

var URONIC_ACID_VARIANT

var VIRTUAL_BACKBONE_EXCEPT_C1PRIME

var VIRTUAL_BASE

var VIRTUAL_BASE_HEAVY_ATOM

var VIRTUAL_BB

var VIRTUAL_DNA_PHOSPHATE

var VIRTUAL_NTERM

var VIRTUAL_O2PRIME_HYDROGEN

var VIRTUAL_PHOSPHATE

var VIRTUAL_RESIDUE_VARIANT

var VIRTUAL_RIBOSE

var VIRTUAL_RNA_RESIDUE

var VIRTUAL_RNA_RESIDUE_EXCLUDE_PHOSPHATE

var VIRTUAL_SIDE_CHAIN

var ZN_CONNECT

var denominator

var imag

var name

var names

var numerator

var real

var values