Bindings for core::chemical namespace

Modules
		rosetta.core.chemical.carbohydrates rosetta.core.chemical.element rosetta.core.chemical.gasteiger rosetta.core.chemical.mmCIF rosetta.core.chemical.orbitals rosetta.core.chemical.rings rosetta.core.chemical.rna rosetta.core.chemical.rotamers rosetta.core.chemical.sdf

Classes
		builtins.object AA APolarHydrogenFilter AcceptorAtomFilter Adduct Ancestor AromaticAtomFilter Atom AtomICoor AtomProperties AtomProperty AtomType AtomTypeDatabaseIO AtomTypeSet AutomorphismIterator Bond BondAromaticity BondConjugability BondIsometry BondName BondOrder BondRingness ElectronConfiguration Element ElementSet GreekDistance HeavyAtomFilter HeavyAtomWithHydrogensFilter HeavyAtomWithPolarHydrogensFilter Hybridization HydrogenAtomFilter ICoorAtomID IdealBondLengthSet MMAtomType MMAtomTypeSet MergeBehaviorManager Metapatch Orbital Patch PatchCase PatchOperation AddAtom AddAtomAlias AddBond AddBondType AddChi AddChiRotamer AddConnect AddConnectAndTrackingVirt AddConnectDeleteChildProton AddProperty AddProtonChi AppendMainchainAtom ChangeAncestory ChangeBondType ChiralFlipAtoms ChiralFlipNaming ClearChiRotamers ConnectSulfurAndMakeVirtualProton DeleteActCoordAtom DeleteAtom DeleteChildProton DeleteMetalbindingAtom DeleteProperty DeleteTerminalChi DeleteVariantType NCAARotLibPath PrependMainchainAtom RedefineChi ReplaceMainchainAtom ReplaceProtonWithBromine ReplaceProtonWithChlorine ReplaceProtonWithEthyl ReplaceProtonWithFluorine ReplaceProtonWithHydroxyl ReplaceProtonWithIodine ReplaceProtonWithMethoxy ReplaceProtonWithMethyl ReplaceProtonWithTrifluoromethyl ResetBondLength SetAllAtomsRepulsive SetAtomType SetAtomicCharge SetBackboneHeavyatom SetFormalCharge SetICoor SetIO_String SetInterchangeabilityGroup_String SetMMAtomType SetNbrAtom SetNbrRadius SetOrientAtom SetPolymerConnectAtom PolarHydrogenFilter RealFilter ResConnID ResidueConnection ResidueDatabaseIO ResidueProperties ResidueProperty ResidueType ResidueTypeFinder ResidueTypeKinWriter ResidueTypeSelector ResidueTypeSelectorSingle Selector_AA Selector_CMDFLAG Selector_MATCH_VARIANTS Selector_NAME1 Selector_NAME3 Selector_NO_VARIANTS Selector_PROPERTY Selector_UPPER_POSITION Selector_VARIANT_TYPE ResidueTypeSet ResidueTypeSetCache VariantType merge_residue_behavior rosetta.basic.resource_manager.ResourceLoader(builtins.object) ResidueLoader rosetta.basic.resource_manager.ResourceLoaderCreator(builtins.object) ResidueLoaderCreator rosetta.basic.resource_manager.ResourceOptions(builtins.object) ResidueLoaderOptions rosetta.basic.resource_manager.ResourceOptionsCreator(builtins.object) ResidueLoaderOptionsCreator rosetta.utility.SingletonBase_core_chemical_AtomPropertiesManager_t(builtins.object) AtomPropertiesManager rosetta.utility.SingletonBase_core_chemical_ChemicalManager_t(builtins.object) ChemicalManager   class AA(builtins.object)     ////////////////////////////////////////////////////////////////////////      enumeration for amino acids and nucleotides types with the total  number as num_aa_types ////////////////////////////////////////////////////////////////////////     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.AA, rosetta.core.chemical.AA) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.AA) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.AA, int) -> NoneType   2. __init__(rosetta.core.chemical.AA, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.AA) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.AA, rosetta.core.chemical.AA) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.AA) -> str Data and other attributes defined here: aa_ala = AA.first_l_aa aa_arg = AA.aa_arg aa_asn = AA.aa_asn aa_asp = AA.aa_asp aa_b3a = AA.first_beta3_aa aa_b3c = AA.aa_b3c aa_b3cisACHC = AA.last_beta3_aa aa_b3cisACPC = AA.aa_b3cisACPC aa_b3cisACPrC = AA.aa_b3cisACPrC aa_b3d = AA.aa_b3d aa_b3e = AA.aa_b3e aa_b3f = AA.aa_b3f aa_b3g = AA.aa_b3g aa_b3h = AA.aa_b3h aa_b3i = AA.aa_b3i aa_b3k = AA.aa_b3k aa_b3l = AA.aa_b3l aa_b3m = AA.aa_b3m aa_b3n = AA.aa_b3n aa_b3p = AA.aa_b3p aa_b3q = AA.aa_b3q aa_b3r = AA.aa_b3r aa_b3s = AA.aa_b3s aa_b3t = AA.aa_b3t aa_b3v = AA.aa_b3v aa_b3w = AA.aa_b3w aa_b3y = AA.aa_b3y aa_cys = AA.aa_cys aa_dal = AA.first_D_aa aa_dan = AA.aa_dan aa_dar = AA.aa_dar aa_das = AA.aa_das aa_dcs = AA.aa_dcs aa_dgn = AA.aa_dgn aa_dgu = AA.aa_dgu aa_dhi = AA.aa_dhi aa_dil = AA.aa_dil aa_dle = AA.aa_dle aa_dly = AA.aa_dly aa_dme = AA.aa_dme aa_dph = AA.aa_dph aa_dpr = AA.aa_dpr aa_dse = AA.aa_dse aa_dth = AA.aa_dth aa_dtr = AA.aa_dtr aa_dty = AA.last_D_aa aa_dva = AA.aa_dva aa_gln = AA.aa_gln aa_glu = AA.aa_glu aa_gly = AA.aa_gly aa_h2o = AA.aa_h2o aa_his = AA.aa_his aa_ile = AA.aa_ile aa_leu = AA.aa_leu aa_lys = AA.aa_lys aa_met = AA.aa_met aa_none = AA.aa_none aa_phe = AA.aa_phe aa_pro = AA.aa_pro aa_ser = AA.aa_ser aa_thr = AA.aa_thr aa_trp = AA.aa_trp aa_tyr = AA.num_canonical_aas aa_unk = AA.num_aa_types aa_unp = AA.aa_unp aa_val = AA.aa_val aa_vrt = AA.aa_vrt first_DNA_aa = AA.first_DNA_aa first_D_aa = AA.first_D_aa first_beta3_aa = AA.first_beta3_aa first_l_aa = AA.first_l_aa last_DNA_aa = AA.last_DNA_aa last_D_aa = AA.last_D_aa last_beta3_aa = AA.last_beta3_aa na_ade = AA.first_DNA_aa na_cyt = AA.na_cyt na_gua = AA.na_gua na_rad = AA.na_rad na_rcy = AA.na_rcy na_rgu = AA.na_rgu na_thy = AA.last_DNA_aa na_ura = AA.na_ura num_aa_types = AA.num_aa_types num_canonical_aas = AA.num_canonical_aas   class APolarHydrogenFilter(builtins.object)     The filter responsible for all apolar hydrogens.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.APolarHydrogenFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.APolarHydrogenFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.APolarHydrogenFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>, atom_types : rosetta.std.weak_ptr_const_core_chemical_AtomTypeSet_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.APolarHydrogenFilter,  : rosetta.core.chemical.APolarHydrogenFilter) -> rosetta.core.chemical.APolarHydrogenFilter   class AcceptorAtomFilter(builtins.object)     The filter responsible for obtaining all acceptor atoms.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.AcceptorAtomFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.AcceptorAtomFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.AcceptorAtomFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>, atom_types : rosetta.std.weak_ptr_const_core_chemical_AtomTypeSet_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AcceptorAtomFilter,  : rosetta.core.chemical.AcceptorAtomFilter) -> rosetta.core.chemical.AcceptorAtomFilter   class AddAtom(PatchOperation)       Method resolution order: AddAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str, atom_type_name_in : str, mm_atom_type_name_in : str, charge : float) -> NoneType   2. __init__(handle, rosetta.core.chemical.AddAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.AddAtom) -> str apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddAtom, rsd : core::chemical::ResidueType) -> bool   add an atom Methods inherited from PatchOperation: adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.PatchOperation,  : rosetta.core.chemical.PatchOperation) -> rosetta.core.chemical.PatchOperation deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddAtomAlias(PatchOperation)     ////////////////////////////////////////////////////////////////////////////       A patch operation for adding an atom alias to a ResidueType.        See residue_io.cc for a description of atom aliases.     Atom aliases were graciously added to Rosetta by Rocco Moretti.      Labonte <JWLabonte.edu>     Method resolution order: AddAtomAlias PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, rosetta_atom_name_in : str, alias_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.AddAtomAlias) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.AddAtomAlias) -> str apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddAtomAlias, rsd : core::chemical::ResidueType) -> bool   Apply this patch to the given ResidueType. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddAtomAlias,  : rosetta.core.chemical.AddAtomAlias) -> rosetta.core.chemical.AddAtomAlias Methods inherited from PatchOperation: adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddBond(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     add a bond to ResidueType     Method resolution order: AddBond PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom1_in : str, atom2_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.AddBond) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddBond, rsd : core::chemical::ResidueType) -> bool   add a bond assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddBond,  : rosetta.core.chemical.AddBond) -> rosetta.core.chemical.AddBond Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddBondType(PatchOperation)     ////////////////////////////////////////////////////////////////////////////      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.edu>     Method resolution order: AddBondType PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom1_in : str, atom2_in : str, bond_type_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.AddBondType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddBondType, rsd : core::chemical::ResidueType) -> bool   Apply this patch to the given ResidueType. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddBondType,  : rosetta.core.chemical.AddBondType) -> rosetta.core.chemical.AddBondType Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddChi(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////       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.     Method resolution order: AddChi PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, chino_in : int, atom1_in : str, atom2_in : str, atom3_in : str, atom4_in : str) -> NoneType   2. __init__(self : handle, atom1_in : str, atom2_in : str, atom3_in : str, atom4_in : str) -> NoneType   3. __init__(handle, rosetta.core.chemical.AddChi) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddChi, rsd : core::chemical::ResidueType) -> bool   Add a chi angle. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddChi,  : rosetta.core.chemical.AddChi) -> rosetta.core.chemical.AddChi Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddChiRotamer(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////       Add a rotamer sample to a chi angle of the ResidueType.      Added by Andy M. Chen in June 2009     This is needed for PTMs.     Method resolution order: AddChiRotamer PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, chino_in : int, mean_in : float, sdev_in : float) -> NoneType   2. __init__(self : handle, mean_in : float, sdev_in : float) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddChiRotamer, rsd : core::chemical::ResidueType) -> bool   Add a rotamer sample. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddChiRotamer,  : rosetta.core.chemical.AddChiRotamer) -> rosetta.core.chemical.AddChiRotamer Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddConnect(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Method resolution order: AddConnect PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, connect_atom : str, phi : float, theta : float, d : float, parent_atom : str, angle_atom : str, torsion_atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.AddConnect) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddConnect, rsd : core::chemical::ResidueType) -> bool   add a property Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.PatchOperation,  : rosetta.core.chemical.PatchOperation) -> rosetta.core.chemical.PatchOperation deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddConnectAndTrackingVirt(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     add a connect and tracking virt to the atom     Method resolution order: AddConnectAndTrackingVirt PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.AddConnectAndTrackingVirt) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddConnectAndTrackingVirt, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddConnectAndTrackingVirt,  : rosetta.core.chemical.AddConnectAndTrackingVirt) -> rosetta.core.chemical.AddConnectAndTrackingVirt Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddConnectDeleteChildProton(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     add a connect to the atom, delete child proton     Method resolution order: AddConnectDeleteChildProton PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.AddConnectDeleteChildProton) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddConnectDeleteChildProton, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddConnectDeleteChildProton,  : rosetta.core.chemical.AddConnectDeleteChildProton) -> rosetta.core.chemical.AddConnectDeleteChildProton Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddProperty(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     add a property to ResidueType     Method resolution order: AddProperty PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, property_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.AddProperty) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.AddProperty) -> str   Which property, if any, is added. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddProperty, rsd : core::chemical::ResidueType) -> bool   add a property assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddProperty,  : rosetta.core.chemical.AddProperty) -> rosetta.core.chemical.AddProperty Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AddProtonChi(PatchOperation)       Method resolution order: AddProtonChi PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : handle, chino_in : int, samples : rosetta.utility.vector1_double, extrasamples : rosetta.utility.vector1_double) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AddProtonChi, rsd : core::chemical::ResidueType) -> bool   add a proton chi angle assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AddProtonChi,  : rosetta.core.chemical.AddProtonChi) -> rosetta.core.chemical.AddProtonChi Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class Adduct(builtins.object)     Description of optional single-atom residue adducts     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.Adduct) -> NoneType   2. __init__(self : rosetta.core.chemical.Adduct, adduct_name : str, atom_name : str, atom_type_name : str, mm_atom_type_name : str, atom_charge_in : float, phi_in : float, theta_in : float, d_in : float, stub_atom1_name : str, stub_atom2_name : str, stub_atom3_name : str) -> NoneType   3. __init__(self : rosetta.core.chemical.Adduct,  : rosetta.core.chemical.Adduct) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. adduct_name(...) from builtins.PyCapsule adduct_name(rosetta.core.chemical.Adduct) -> str   accessor to adduct_name string assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Adduct,  : rosetta.core.chemical.Adduct) -> rosetta.core.chemical.Adduct atom_charge(...) from builtins.PyCapsule atom_charge(rosetta.core.chemical.Adduct) -> float atom_name(...) from builtins.PyCapsule atom_name(rosetta.core.chemical.Adduct) -> str   accessor to atom_name string atom_type_name(...) from builtins.PyCapsule atom_type_name(rosetta.core.chemical.Adduct) -> str   accessor to atom type string d(...) from builtins.PyCapsule d(rosetta.core.chemical.Adduct) -> float mm_atom_type_name(...) from builtins.PyCapsule mm_atom_type_name(rosetta.core.chemical.Adduct) -> str   accessor to mm type string phi(...) from builtins.PyCapsule phi(rosetta.core.chemical.Adduct) -> float   accessor for Adduct geometric info stub_atom(...) from builtins.PyCapsule stub_atom(self : rosetta.core.chemical.Adduct, atm : int) -> str   const accessor to stub_atom strings by index stub_atom1(...) from builtins.PyCapsule stub_atom1(rosetta.core.chemical.Adduct) -> str   accessor to stub_atom1 name string stub_atom2(...) from builtins.PyCapsule stub_atom2(rosetta.core.chemical.Adduct) -> str   accessor to stub_atom2 name string stub_atom3(...) from builtins.PyCapsule stub_atom3(rosetta.core.chemical.Adduct) -> str   accessor to stub_atom3 name string theta(...) from builtins.PyCapsule theta(rosetta.core.chemical.Adduct) -> float   class Ancestor(builtins.object)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Change the parent, grandparent, or great-grandparent of an atom     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.Ancestor, rosetta.core.chemical.Ancestor) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.Ancestor) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.Ancestor, int) -> NoneType   2. __init__(rosetta.core.chemical.Ancestor, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.Ancestor) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.Ancestor, rosetta.core.chemical.Ancestor) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.Ancestor) -> str Data and other attributes defined here: anc_grandparent = Ancestor.anc_grandparent anc_greatgrandparent = Ancestor.anc_greatgrandparent anc_parent = Ancestor.anc_parent   class AppendMainchainAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     add a mainchain atom after the last mainchain atom     Method resolution order: AppendMainchainAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.AppendMainchainAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.AppendMainchainAtom, rsd : core::chemical::ResidueType) -> bool   set an atom to be the last mainchain atom assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AppendMainchainAtom,  : rosetta.core.chemical.AppendMainchainAtom) -> rosetta.core.chemical.AppendMainchainAtom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class AromaticAtomFilter(builtins.object)     The filter responsible for all aromatic atoms.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.AromaticAtomFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.AromaticAtomFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.AromaticAtomFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>, atom_types : rosetta.std.weak_ptr_const_core_chemical_AtomTypeSet_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AromaticAtomFilter,  : rosetta.core.chemical.AromaticAtomFilter) -> rosetta.core.chemical.AromaticAtomFilter   class Atom(builtins.object)     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     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(self : rosetta.core.chemical.Atom, atom : rosetta.core.chemical.Atom) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.Atom) -> NoneType   2. __init__(self : rosetta.core.chemical.Atom, name_in : str, mm_name : str, mm_atom_type_index : int, element : rosetta.core.chemical.Element, charge : float, ideal_xyz : rosetta.numeric.xyzVector_double_t) -> NoneType   3. __init__(self : rosetta.core.chemical.Atom, src : rosetta.core.chemical.Atom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.Atom) -> str absolute_stereochemistry(...) from builtins.PyCapsule absolute_stereochemistry(rosetta.core.chemical.Atom) -> str   Return the absolute stereochemistry (R/S designation) of this stereocenter. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Atom, atom : rosetta.core.chemical.Atom) -> rosetta.core.chemical.Atom atom_type_index(...) from builtins.PyCapsule atom_type_index(*args, **kwargs) Overloaded function.   1. atom_type_index(rosetta.core.chemical.Atom) -> int   2. atom_type_index(self : rosetta.core.chemical.Atom, atom_type_index : int) -> NoneType   You probably don't want to use this directly.  Use ResidueType::set_atom_type() which correctly updates the internal state of the residuetype/atom bonded_orbitals(...) from builtins.PyCapsule bonded_orbitals(*args, **kwargs) Overloaded function.   1. bonded_orbitals(rosetta.core.chemical.Atom) -> rosetta.utility.vector1_unsigned_long   2. bonded_orbitals(rosetta.core.chemical.Atom) -> rosetta.utility.vector1_unsigned_long charge(...) from builtins.PyCapsule charge(*args, **kwargs) Overloaded function.   1. charge(rosetta.core.chemical.Atom) -> float   2. charge(self : rosetta.core.chemical.Atom, charge : float) -> NoneType element(...) from builtins.PyCapsule element(rosetta.core.chemical.Atom) -> rosetta.core.chemical.element.Elements   Convenience function to go directly to the element enum element_type(...) from builtins.PyCapsule element_type(*args, **kwargs) Overloaded function.   1. element_type(rosetta.core.chemical.Atom) -> rosetta.core.chemical.Element   2. element_type(self : rosetta.core.chemical.Atom, element : rosetta.core.chemical.Element) -> NoneType formal_charge(...) from builtins.PyCapsule formal_charge(*args, **kwargs) Overloaded function.   1. formal_charge(rosetta.core.chemical.Atom) -> int   2. formal_charge(self : rosetta.core.chemical.Atom, charge : int) -> NoneType gasteiger_atom_type(...) from builtins.PyCapsule gasteiger_atom_type(*args, **kwargs) Overloaded function.   1. gasteiger_atom_type(rosetta.core.chemical.Atom) -> core::chemical::gasteiger::GasteigerAtomTypeData   2. gasteiger_atom_type(self : rosetta.core.chemical.Atom, gasteiger_atom_type : core::chemical::gasteiger::GasteigerAtomTypeData) -> NoneType greek_distance(...) from builtins.PyCapsule greek_distance(*args, **kwargs) Overloaded function.   1. greek_distance(rosetta.core.chemical.Atom) -> rosetta.core.chemical.GreekDistance   How far (in Greek letters) is this atom from the primary functional group of the molecule?   2. greek_distance(self : rosetta.core.chemical.Atom, setting : rosetta.core.chemical.GreekDistance) -> NoneType   Set how far (in Greek letters) this atom is from the primary functional group of the molecule. has_orbitals(...) from builtins.PyCapsule has_orbitals(*args, **kwargs) Overloaded function.   1. has_orbitals(rosetta.core.chemical.Atom) -> bool   2. has_orbitals(self : rosetta.core.chemical.Atom, orbitals : bool) -> NoneType has_property(...) from builtins.PyCapsule has_property(*args, **kwargs) Overloaded function.   1. has_property(self : rosetta.core.chemical.Atom, property : str) -> bool   Generic property access.   2. has_property(self : rosetta.core.chemical.Atom, property : rosetta.core.chemical.AtomProperty) -> bool heavyatom_has_polar_hydrogens(...) from builtins.PyCapsule heavyatom_has_polar_hydrogens(*args, **kwargs) Overloaded function.   1. heavyatom_has_polar_hydrogens(rosetta.core.chemical.Atom) -> bool   Get whether or not this heavy atom is a hydrogen-bond donor.   2. heavyatom_has_polar_hydrogens(self : rosetta.core.chemical.Atom, setting : bool) -> NoneType   Set whether or not this heavy atom is a hydrogen-bond donor. ideal_xyz(...) from builtins.PyCapsule ideal_xyz(*args, **kwargs) Overloaded function.   1. ideal_xyz(rosetta.core.chemical.Atom) -> rosetta.numeric.xyzVector_double_t   2. ideal_xyz(self : rosetta.core.chemical.Atom, ideal_xyz : rosetta.numeric.xyzVector_double_t) -> NoneType is_acceptor(...) from builtins.PyCapsule is_acceptor(*args, **kwargs) Overloaded function.   1. is_acceptor(rosetta.core.chemical.Atom) -> bool   Get whether or not this heavy atom is a hydrogen-bond acceptor.   2. is_acceptor(self : rosetta.core.chemical.Atom, setting : bool) -> NoneType   Set whether or not this heavy atom is a hydrogen-bond acceptor. is_fake(...) from builtins.PyCapsule is_fake(rosetta.core.chemical.Atom) -> bool   Return true if this represents a fake/mock atom. is_haro(...) from builtins.PyCapsule is_haro(*args, **kwargs) Overloaded function.   1. is_haro(rosetta.core.chemical.Atom) -> bool   Get whether or not this hydrogen atom is bonded to an aromatic ring.   2. is_haro(self : rosetta.core.chemical.Atom, setting : bool) -> NoneType   Set whether or not this hydrogen atom is bonded to an aromatic ring. is_hydrogen(...) from builtins.PyCapsule is_hydrogen(*args, **kwargs) Overloaded function.   1. is_hydrogen(rosetta.core.chemical.Atom) -> bool   2. is_hydrogen(self : rosetta.core.chemical.Atom, setting : bool) -> NoneType is_polar_hydrogen(...) from builtins.PyCapsule is_polar_hydrogen(*args, **kwargs) Overloaded function.   1. is_polar_hydrogen(rosetta.core.chemical.Atom) -> bool   Get whether or not this hydrogen atom is polar.   2. is_polar_hydrogen(self : rosetta.core.chemical.Atom, setting : bool) -> NoneType   Set whether or not this hydrogen atom is polar. is_virtual(...) from builtins.PyCapsule is_virtual(*args, **kwargs) Overloaded function.   1. is_virtual(rosetta.core.chemical.Atom) -> bool   Get whether or not this atom is virtual.   2. is_virtual(self : rosetta.core.chemical.Atom, setting : bool) -> NoneType   Set whether or not this atom is virtual. mm_atom_type_index(...) from builtins.PyCapsule mm_atom_type_index(*args, **kwargs) Overloaded function.   1. mm_atom_type_index(rosetta.core.chemical.Atom) -> int   2. mm_atom_type_index(self : rosetta.core.chemical.Atom, mm_atom_type_index : int) -> NoneType mm_name(...) from builtins.PyCapsule mm_name(*args, **kwargs) Overloaded function.   1. mm_name(rosetta.core.chemical.Atom) -> str   2. mm_name(self : rosetta.core.chemical.Atom, name : str) -> NoneType name(...) from builtins.PyCapsule name(*args, **kwargs) Overloaded function.   1. name(rosetta.core.chemical.Atom) -> str   2. name(self : rosetta.core.chemical.Atom, name : str) -> NoneType properties(...) from builtins.PyCapsule properties(rosetta.core.chemical.Atom) -> rosetta.core.chemical.AtomProperties   Access the collection of properties for this Atom. set_absolute_stereochemistry(...) from builtins.PyCapsule set_absolute_stereochemistry(self : rosetta.core.chemical.Atom, setting : str) -> NoneType   Set the absolute stereochemistry (R/S designation) of this stereocenter. set_property(...) from builtins.PyCapsule set_property(*args, **kwargs) Overloaded function.   1. set_property(self : rosetta.core.chemical.Atom, property : str, setting : bool) -> NoneType   Generic property setting.   2. set_property(self : rosetta.core.chemical.Atom, property : rosetta.core.chemical.AtomProperty, setting : bool) -> NoneType   class AtomICoor(builtins.object)     A basic class containing info of internal coordinates needed for building an atom within a ResidueType   In atom tree, each atom is defined by its internal coordinates, which include a bond distance, a bond angle and a torsion angle. Of course, all these internal coordinates are only meaningful in the context of three reference (stub) atoms. AtomICoor information is stored in the residue param files and some terms are defined as following: - bond distance d_ is that between the atom to be built (child) and stub_atom1 (parent) - bond angle theta_ is that defined by child-parent-stub2(angle) - torsion angle phi_ is that defined by child-parent-stub2-stub3(torsion)     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.AtomICoor) -> NoneType   2. __init__(self : rosetta.core.chemical.AtomICoor, built_atom_name : str, phi_in : float, theta_in : float, d_in : float, stub_atom1_name : str, stub_atom2_name : str, stub_atom3_name : str, rsd_type : core::chemical::ResidueType) -> NoneType   3. __init__(self : rosetta.core.chemical.AtomICoor, capsule, built_atom_vd : float, phi_in : float, theta_in : float, capsule, capsule, capsule, d_in : core::chemical::ResidueType) -> NoneType   4. __init__(self : rosetta.core.chemical.AtomICoor, built_atom_name : str, phi_in : float, theta_in : float, d_in : float, stub_atom1 : rosetta.core.chemical.ICoorAtomID, stub_atom2 : rosetta.core.chemical.ICoorAtomID, stub_atom3 : rosetta.core.chemical.ICoorAtomID, rsd_type : core::chemical::ResidueType) -> NoneType   5. __init__(self : rosetta.core.chemical.AtomICoor,  : rosetta.core.chemical.AtomICoor) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AtomICoor,  : rosetta.core.chemical.AtomICoor) -> rosetta.core.chemical.AtomICoor build(...) from builtins.PyCapsule build(*args, **kwargs) Overloaded function.   1. build(self : rosetta.core.chemical.AtomICoor, rsd : core::conformation::Residue, conformation : core::conformation::Conformation) -> rosetta.numeric.xyzVector_double_t   2. build(self : rosetta.core.chemical.AtomICoor, rsd_type : core::chemical::ResidueType) -> rosetta.numeric.xyzVector_double_t   3. build(self : rosetta.core.chemical.AtomICoor, rsd : core::conformation::Residue) -> rosetta.numeric.xyzVector_double_t   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. built_atom_vertex(...) from builtins.PyCapsule built_atom_vertex(*args, **kwargs) Overloaded function.   1. built_atom_vertex(self : rosetta.core.chemical.AtomICoor, capsule) -> NoneType   2. built_atom_vertex(rosetta.core.chemical.AtomICoor) -> capsule   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) d(...) from builtins.PyCapsule d(rosetta.core.chemical.AtomICoor) -> float depends_on_polymer_lower(...) from builtins.PyCapsule depends_on_polymer_lower(rosetta.core.chemical.AtomICoor) -> bool depends_on_polymer_upper(...) from builtins.PyCapsule depends_on_polymer_upper(rosetta.core.chemical.AtomICoor) -> bool depends_on_residue_connection(...) from builtins.PyCapsule depends_on_residue_connection(*args, **kwargs) Overloaded function.   1. depends_on_residue_connection(self : rosetta.core.chemical.AtomICoor, connid : int) -> bool   Returns true if any of the stub atoms is the specified connection ID.   2. depends_on_residue_connection(rosetta.core.chemical.AtomICoor) -> bool   Returns true if any of the stub atoms is a connection ID.      Vikram K. Mulligan (vmullig.edu) is_internal(...) from builtins.PyCapsule is_internal(rosetta.core.chemical.AtomICoor) -> bool phi(...) from builtins.PyCapsule phi(rosetta.core.chemical.AtomICoor) -> float   accessor to stub_atom1 ICoorAtomID stub_atom(...) from builtins.PyCapsule stub_atom(*args, **kwargs) Overloaded function.   1. stub_atom(self : rosetta.core.chemical.AtomICoor, atm : int) -> rosetta.core.chemical.ICoorAtomID   accessor to stub_atom ICoorAtomID   2. stub_atom(self : rosetta.core.chemical.AtomICoor, atm : int) -> rosetta.core.chemical.ICoorAtomID   constant accessor to stub_atom ICoorAtomID stub_atom1(...) from builtins.PyCapsule stub_atom1(rosetta.core.chemical.AtomICoor) -> rosetta.core.chemical.ICoorAtomID stub_atom2(...) from builtins.PyCapsule stub_atom2(rosetta.core.chemical.AtomICoor) -> rosetta.core.chemical.ICoorAtomID   accessor to stub_atom2 ICoorAtomID stub_atom3(...) from builtins.PyCapsule stub_atom3(rosetta.core.chemical.AtomICoor) -> rosetta.core.chemical.ICoorAtomID   accessor to stub_atom3 ICoorAtomID theta(...) from builtins.PyCapsule theta(rosetta.core.chemical.AtomICoor) -> float   class AtomProperties(builtins.object)     This is a container class for storing properties specific to a ResidueType's atoms. These properties belong to a particular ResidueType's Atoms; they do not belong to an AtomType. chemical::Atoms store both AtomTypes and AtomProperties.     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(self : rosetta.core.chemical.AtomProperties, properties : rosetta.core.chemical.AtomProperties) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.chemical.AtomProperties) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.AtomProperties) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AtomProperties, object_to_copy : rosetta.core.chemical.AtomProperties) -> rosetta.core.chemical.AtomProperties get_list_of_properties(...) from builtins.PyCapsule get_list_of_properties(rosetta.core.chemical.AtomProperties) -> rosetta.utility.vector1_std_string   Generate and return a list of strings representing the properties of this Atom. has_property(...) from builtins.PyCapsule has_property(*args, **kwargs) Overloaded function.   1. has_property(self : rosetta.core.chemical.AtomProperties, property : rosetta.core.chemical.AtomProperty) -> bool   Get whether or not this Atom has the requested property.   2. has_property(self : rosetta.core.chemical.AtomProperties, property : str) -> bool   Get whether or not this Atom has the requested property by string. set_property(...) from builtins.PyCapsule set_property(*args, **kwargs) Overloaded function.   1. set_property(self : rosetta.core.chemical.AtomProperties, property : rosetta.core.chemical.AtomProperty, setting : bool) -> NoneType   Set the status of the given property for this Atom.   2. set_property(self : rosetta.core.chemical.AtomProperties, property : str, setting : bool) -> NoneType   Set the status of the given property for this Atom by string.   class AtomPropertiesManager(rosetta.utility.SingletonBase_core_chemical_AtomPropertiesManager_t)     This class is a singleton and manages AtomProperties enum mappings.     Method resolution order: AtomPropertiesManager rosetta.utility.SingletonBase_core_chemical_AtomPropertiesManager_t builtins.object Methods defined here: __init__(self, /, *args, **kwargs) Initialize self.  See help(type(self)) for accurate signature. __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. property_from_string(...) from builtins.PyCapsule property_from_string(property : str) -> rosetta.core.chemical.AtomProperty string_from_property(...) from builtins.PyCapsule string_from_property(property : rosetta.core.chemical.AtomProperty) -> str Methods inherited from rosetta.utility.SingletonBase_core_chemical_AtomPropertiesManager_t: get_instance(...) from builtins.PyCapsule get_instance() -> core::chemical::AtomPropertiesManager   class AtomProperty(builtins.object)     Enumerators for all the properties that can be assigned to a chemical::Atom.     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.AtomProperty, rosetta.core.chemical.AtomProperty) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.AtomProperty) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.AtomProperty, int) -> NoneType   2. __init__(rosetta.core.chemical.AtomProperty, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.AtomProperty) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.AtomProperty, rosetta.core.chemical.AtomProperty) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.AtomProperty) -> str Data and other attributes defined here: AROMATIC_CARBON_WITH_FREE_VALENCE = AtomProperty.N_ATOM_PROPERTIES AROMATIC_HYDROGEN = AtomProperty.AROMATIC_HYDROGEN FIRST_ATOM_PROPERTY = AtomProperty.FIRST_ATOM_PROPERTY HAS_ORBITALS = AtomProperty.HAS_ORBITALS H_ACCEPTOR = AtomProperty.H_ACCEPTOR H_DONOR = AtomProperty.H_DONOR NO_ATOM_PROPERTY = AtomProperty.NO_ATOM_PROPERTY N_ATOM_PROPERTIES = AtomProperty.N_ATOM_PROPERTIES POLAR_HYDROGEN = AtomProperty.POLAR_HYDROGEN REPULSIVE = AtomProperty.REPULSIVE VIRTUAL_ATOM = AtomProperty.VIRTUAL_ATOM   class AtomType(builtins.object)     basic atom type     name, element, certain properties and parameters     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.chemical.AtomType, name_in : str, element_in : str) -> NoneType   2. __init__(self : rosetta.core.chemical.AtomType, src : rosetta.core.chemical.AtomType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.AtomType) -> str add_property(...) from builtins.PyCapsule add_property(self : rosetta.core.chemical.AtomType, property : str) -> NoneType   set standard property to true, or set the specified hybridization assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AtomType,  : rosetta.core.chemical.AtomType) -> rosetta.core.chemical.AtomType atom_has_orbital(...) from builtins.PyCapsule atom_has_orbital(rosetta.core.chemical.AtomType) -> bool   atom has an orbital attached atom_type_name(...) from builtins.PyCapsule atom_type_name(rosetta.core.chemical.AtomType) -> str clear_properties(...) from builtins.PyCapsule clear_properties(rosetta.core.chemical.AtomType) -> NoneType   set all standard properties to false, set hybridization to UNKNOWN_HYBRID, and clear extra properties element(...) from builtins.PyCapsule element(rosetta.core.chemical.AtomType) -> str   returns the one- or two-letter element type extra_parameter(...) from builtins.PyCapsule extra_parameter(self : rosetta.core.chemical.AtomType, index : int) -> float   return an additional, non-hardcoded property get_all_properties(...) from builtins.PyCapsule get_all_properties(rosetta.core.chemical.AtomType) -> rosetta.utility.vector1_std_string hybridization(...) from builtins.PyCapsule hybridization(rosetta.core.chemical.AtomType) -> rosetta.core.chemical.Hybridization   retrieve an atom's hybridization status. is_acceptor(...) from builtins.PyCapsule is_acceptor(rosetta.core.chemical.AtomType) -> bool   whether atom is a hydrogen bond acceptor is_aromatic(...) from builtins.PyCapsule is_aromatic(rosetta.core.chemical.AtomType) -> bool   whether atom is aromatic is_donor(...) from builtins.PyCapsule is_donor(rosetta.core.chemical.AtomType) -> bool   whether atom is a hydrogen bond donor is_h2o(...) from builtins.PyCapsule is_h2o(rosetta.core.chemical.AtomType) -> bool   whether atom is a water is_haro(...) from builtins.PyCapsule is_haro(rosetta.core.chemical.AtomType) -> bool   is the H atom aromatic? is_heavyatom(...) from builtins.PyCapsule is_heavyatom(rosetta.core.chemical.AtomType) -> bool   whether atom is a heavy atom is_hydrogen(...) from builtins.PyCapsule is_hydrogen(rosetta.core.chemical.AtomType) -> bool   whether atom is a hydrogen atom is_polar_hydrogen(...) from builtins.PyCapsule is_polar_hydrogen(rosetta.core.chemical.AtomType) -> bool   whether atom is a polar hydrogen atom is_repulsive(...) from builtins.PyCapsule is_repulsive(rosetta.core.chemical.AtomType) -> bool   is atom type repulsive (REPL, REPLS, HREPS) is_virtual(...) from builtins.PyCapsule is_virtual(rosetta.core.chemical.AtomType) -> bool   is atom type virtual? lj_radius(...) from builtins.PyCapsule lj_radius(rosetta.core.chemical.AtomType) -> float   Lennard-Jones 6-12 potential parameter -- atom radius          There are two functionally identical versions of the Lennard-Jones potential:      E ~ 4eps(sigma1/d)^12 - (sigma1/d)^6 and       and    E ~ eps(sigma2/d)^12 - 2*(sigma2/d)^6    where sigma1 and sigma2 represent two different interpretations of the radius. eps represents the depth of the potential well.  Sigma1 represents the distance between the two atoms where the Lennard-Jones energy is 0, i.e. where a collision is just forming/resolving.  Sigma2 represents the distance between the two atoms where the derivative of the Lennard-Jones energy is 0, i.e. the minimum of the well depth.    In rosetta, we mean sigma2 when we talk about radii, but PyMol usually sets the radii to sigma1.   If you see two atoms overlapping using the Rosetta radii, they're not necessarily in collision. They are just not   at their minimum value.    The distances are related as sigma2 = 2^(1.0/6)*sigma1;  sigma2 ~= 1.22*sigma1 lj_wdepth(...) from builtins.PyCapsule lj_wdepth(rosetta.core.chemical.AtomType) -> float   Lennard-Jones 6-12 potential parameter -- well depth lk_dgfree(...) from builtins.PyCapsule lk_dgfree(rosetta.core.chemical.AtomType) -> float   Lazaridis and Karplus solvation parameter -- dgfree lk_lambda(...) from builtins.PyCapsule lk_lambda(rosetta.core.chemical.AtomType) -> float   Lazaridis and Karplus solvation parameter -- lambda lk_volume(...) from builtins.PyCapsule lk_volume(rosetta.core.chemical.AtomType) -> float   Lazaridis and Karplus solvation parameter -- volume name(...) from builtins.PyCapsule name(*args, **kwargs) Overloaded function.   1. name(self : rosetta.core.chemical.AtomType, setting : str) -> NoneType   2. name(rosetta.core.chemical.AtomType) -> str set_all_extra_parameters(...) from builtins.PyCapsule set_all_extra_parameters(self : rosetta.core.chemical.AtomType, extra_parameters : rosetta.utility.vector1_double) -> NoneType   all the extra parameters at once set_extra_parameter(...) from builtins.PyCapsule set_extra_parameter(self : rosetta.core.chemical.AtomType, index : int, setting : float) -> NoneType   return an additional, non-hardcoded property set_parameter(...) from builtins.PyCapsule set_parameter(self : rosetta.core.chemical.AtomType, param : str, setting : float) -> NoneType   set LJ and LK solvation parameter for this atom type set_property(...) from builtins.PyCapsule set_property(self : rosetta.core.chemical.AtomType, property : str, setting : bool) -> NoneType   set relevant properties for this atom type hh   class AtomTypeDatabaseIO(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.chemical.AtomTypeDatabaseIO) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AtomTypeDatabaseIO,  : rosetta.core.chemical.AtomTypeDatabaseIO) -> rosetta.core.chemical.AtomTypeDatabaseIO get_all_atom_types_in_database(...) from builtins.PyCapsule get_all_atom_types_in_database(self : rosetta.core.chemical.AtomTypeDatabaseIO, db_session : rosetta.utility.sql_database.session) -> rosetta.utility.vector1_std_string initialize(...) from builtins.PyCapsule initialize(self : rosetta.core.chemical.AtomTypeDatabaseIO, db_session : rosetta.utility.sql_database.session) -> NoneType   write the schema write_atom_type_set_to_database(...) from builtins.PyCapsule write_atom_type_set_to_database(self : rosetta.core.chemical.AtomTypeDatabaseIO, atom_type_set : core::chemical::AtomTypeSet, db_session : rosetta.utility.sql_database.session) -> NoneType write_schema_to_db(...) from builtins.PyCapsule write_schema_to_db(self : rosetta.core.chemical.AtomTypeDatabaseIO, db_session : rosetta.utility.sql_database.session) -> NoneType   generate the table schemas and write them to the database   class AtomTypeSet(builtins.object)     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     Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(*args, **kwargs) Overloaded function.   1. __getitem__(self : rosetta.core.chemical.AtomTypeSet, index : int) -> rosetta.core.chemical.AtomType   [ ] operator, simulating vector index behavior      look up an AtomTypeSet by 1-based indexing   2. __getitem__(self : rosetta.core.chemical.AtomTypeSet, index : int) -> rosetta.core.chemical.AtomType   [ ] operator, simulating vector index behavior, non-const version      look up an AtomTypeSet by 1-based indexing __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.chemical.AtomTypeSet, directory : str) -> NoneType   2. __init__(self : rosetta.core.chemical.AtomTypeSet, name : str, db_session : rosetta.utility.sql_database.session) -> NoneType   3. __init__(self : rosetta.core.chemical.AtomTypeSet,  : rosetta.core.chemical.AtomTypeSet) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_parameters_from_file(...) from builtins.PyCapsule add_parameters_from_file(self : rosetta.core.chemical.AtomTypeSet, filename : str) -> NoneType   additional file I/O assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.AtomTypeSet,  : rosetta.core.chemical.AtomTypeSet) -> rosetta.core.chemical.AtomTypeSet atom_type_index(...) from builtins.PyCapsule atom_type_index(self : rosetta.core.chemical.AtomTypeSet, atom_type_name : str) -> int   lookup the atom_type by the atom_type_name string directory(...) from builtins.PyCapsule directory(rosetta.core.chemical.AtomTypeSet) -> str   Get the source directory, eg to open an additional file in that directory extra_parameter_index(...) from builtins.PyCapsule extra_parameter_index(self : rosetta.core.chemical.AtomTypeSet, name : str) -> int   SLOW extra_parameter_indices(...) from builtins.PyCapsule extra_parameter_indices(rosetta.core.chemical.AtomTypeSet) -> rosetta.std.map_std_string_int has_atom(...) from builtins.PyCapsule has_atom(self : rosetta.core.chemical.AtomTypeSet, atom_type_name : str) -> bool   Check if atom is present has_extra_parameter(...) from builtins.PyCapsule has_extra_parameter(self : rosetta.core.chemical.AtomTypeSet, name : str) -> bool n_atomtypes(...) from builtins.PyCapsule n_atomtypes(rosetta.core.chemical.AtomTypeSet) -> int   number of atom types in the set name(...) from builtins.PyCapsule name(rosetta.core.chemical.AtomTypeSet) -> str   the name of the AtomTypeSet read_file(...) from builtins.PyCapsule read_file(self : rosetta.core.chemical.AtomTypeSet, filename : str) -> NoneType   file I/O   class AutomorphismIterator(builtins.object)     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.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.AutomorphismIterator, rosetta.core.chemical.ResidueType) -> NoneType   doc   2. __init__(self : rosetta.core.chemical.AutomorphismIterator, restype : rosetta.core.chemical.ResidueType, includeH : bool) -> NoneType   3. __init__(rosetta.core.chemical.AutomorphismIterator, rosetta.core.chemical.ResidueType, rosetta.core.chemical.ResidueType) -> NoneType   doc   4. __init__(self : rosetta.core.chemical.AutomorphismIterator, restype : rosetta.core.chemical.ResidueType, restype2 : rosetta.core.chemical.ResidueType, includeH : bool) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. next(...) from builtins.PyCapsule next(rosetta.core.chemical.AutomorphismIterator) -> rosetta.utility.vector1_unsigned_long   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.   class Bond(builtins.object)     basic chemical Bond     name, element, certain properties and parameters from .params file     Methods defined here: GetMaximumElectrons(...) from builtins.PyCapsule GetMaximumElectrons(rosetta.core.chemical.Bond) -> int GetMinimumElectrons(...) from builtins.PyCapsule GetMinimumElectrons(rosetta.core.chemical.Bond) -> int GetNumberOfElectrons(...) from builtins.PyCapsule GetNumberOfElectrons(rosetta.core.chemical.Bond) -> int GetSDAltFileID(...) from builtins.PyCapsule GetSDAltFileID(rosetta.core.chemical.Bond) -> int GetSDFileID(...) from builtins.PyCapsule GetSDFileID(rosetta.core.chemical.Bond) -> int IsBondInRing(...) from builtins.PyCapsule IsBondInRing(rosetta.core.chemical.Bond) -> bool IsBondOrderKnown(...) from builtins.PyCapsule IsBondOrderKnown(rosetta.core.chemical.Bond) -> bool SetSDFType(...) from builtins.PyCapsule SetSDFType(self : rosetta.core.chemical.Bond, SDF_ID : int) -> NoneType   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) __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.Bond) -> NoneType   2. __init__(rosetta.core.chemical.Bond, float, rosetta.core.chemical.BondName) -> NoneType   doc   3. __init__(self : rosetta.core.chemical.Bond, d : float, name : rosetta.core.chemical.BondName, cut_bond : bool) -> NoneType   4. __init__(rosetta.core.chemical.Bond, float, rosetta.core.chemical.BondOrder, rosetta.core.chemical.BondConjugability, rosetta.core.chemical.BondAromaticity) -> NoneType   doc   5. __init__(rosetta.core.chemical.Bond, float, rosetta.core.chemical.BondOrder, rosetta.core.chemical.BondConjugability, rosetta.core.chemical.BondAromaticity, rosetta.core.chemical.BondRingness) -> NoneType   doc   6. __init__(rosetta.core.chemical.Bond, float, rosetta.core.chemical.BondOrder, rosetta.core.chemical.BondConjugability, rosetta.core.chemical.BondAromaticity, rosetta.core.chemical.BondRingness, rosetta.core.chemical.BondIsometry) -> NoneType   doc   7. __init__(self : rosetta.core.chemical.Bond, d : float, order : rosetta.core.chemical.BondOrder, conj : rosetta.core.chemical.BondConjugability, aroma : rosetta.core.chemical.BondAromaticity, ring : rosetta.core.chemical.BondRingness, isom : rosetta.core.chemical.BondIsometry, cut_bond : bool) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.Bond) -> str aromaticity(...) from builtins.PyCapsule aromaticity(*args, **kwargs) Overloaded function.   1. aromaticity(self : rosetta.core.chemical.Bond, aroma : rosetta.core.chemical.BondAromaticity) -> NoneType   2. aromaticity(rosetta.core.chemical.Bond) -> rosetta.core.chemical.BondAromaticity bond_name(...) from builtins.PyCapsule bond_name(*args, **kwargs) Overloaded function.   1. bond_name(self : rosetta.core.chemical.Bond, bond_name : rosetta.core.chemical.BondName) -> NoneType   2. bond_name(rosetta.core.chemical.Bond) -> rosetta.core.chemical.BondName conjugability(...) from builtins.PyCapsule conjugability(*args, **kwargs) Overloaded function.   1. conjugability(self : rosetta.core.chemical.Bond, conjug : rosetta.core.chemical.BondConjugability) -> NoneType   2. conjugability(rosetta.core.chemical.Bond) -> rosetta.core.chemical.BondConjugability cut_bond(...) from builtins.PyCapsule cut_bond(*args, **kwargs) Overloaded function.   1. cut_bond(self : rosetta.core.chemical.Bond, cut_bond : bool) -> NoneType   2. cut_bond(rosetta.core.chemical.Bond) -> bool distance(...) from builtins.PyCapsule distance(*args, **kwargs) Overloaded function.   1. distance(self : rosetta.core.chemical.Bond, distance : float) -> NoneType   2. distance(rosetta.core.chemical.Bond) -> float is_fake(...) from builtins.PyCapsule is_fake(rosetta.core.chemical.Bond) -> bool   Return true if this bond represents a non-physical bond isometry(...) from builtins.PyCapsule isometry(*args, **kwargs) Overloaded function.   1. isometry(self : rosetta.core.chemical.Bond, isom : rosetta.core.chemical.BondIsometry) -> NoneType   2. isometry(rosetta.core.chemical.Bond) -> rosetta.core.chemical.BondIsometry order(...) from builtins.PyCapsule order(*args, **kwargs) Overloaded function.   1. order(self : rosetta.core.chemical.Bond, order : rosetta.core.chemical.BondOrder) -> NoneType   2. order(rosetta.core.chemical.Bond) -> rosetta.core.chemical.BondOrder ringness(...) from builtins.PyCapsule ringness(*args, **kwargs) Overloaded function.   1. ringness(self : rosetta.core.chemical.Bond, ring : rosetta.core.chemical.BondRingness) -> NoneType   2. ringness(rosetta.core.chemical.Bond) -> rosetta.core.chemical.BondRingness   class BondAromaticity(builtins.object)     Proper aromaticity implies participation in a 4n+2 electron ring system. For simple single-double alternation, see conjugatable bond.     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.BondAromaticity, rosetta.core.chemical.BondAromaticity) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.BondAromaticity) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.BondAromaticity, int) -> NoneType   2. __init__(rosetta.core.chemical.BondAromaticity, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.BondAromaticity) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.BondAromaticity, rosetta.core.chemical.BondAromaticity) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.BondAromaticity) -> str Data and other attributes defined here: IsAromaticBond = BondAromaticity.IsAromaticBond NonaromaticBond = BondAromaticity.NonaromaticBond UnknownAromaticity = BondAromaticity.UnknownAromaticity   class BondConjugability(builtins.object)     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     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.BondConjugability, rosetta.core.chemical.BondConjugability) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.BondConjugability) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.BondConjugability, int) -> NoneType   2. __init__(rosetta.core.chemical.BondConjugability, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.BondConjugability) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.BondConjugability, rosetta.core.chemical.BondConjugability) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.BondConjugability) -> str Data and other attributes defined here: ConjugableBond = BondConjugability.ConjugableBond NotConjugableBond = BondConjugability.NotConjugableBond UnknownConjugability = BondConjugability.UnknownConjugability   class BondIsometry(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.BondIsometry, rosetta.core.chemical.BondIsometry) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.BondIsometry) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.BondIsometry, int) -> NoneType   2. __init__(rosetta.core.chemical.BondIsometry, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.BondIsometry) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.BondIsometry, rosetta.core.chemical.BondIsometry) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.BondIsometry) -> str Data and other attributes defined here: EIsometry = BondIsometry.EIsometry NoBondIsometry = BondIsometry.NoBondIsometry UnknownIsometry = BondIsometry.UnknownIsometry ZIsometry = BondIsometry.ZIsometry   class BondName(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.BondName, rosetta.core.chemical.BondName) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.BondName) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.BondName, int) -> NoneType   2. __init__(rosetta.core.chemical.BondName, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.BondName) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.BondName, rosetta.core.chemical.BondName) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.BondName) -> str Data and other attributes defined here: AromaticBond = BondName.AromaticBond DoubleBond = BondName.DoubleBond OrbitalBond = BondName.OrbitalBond SingleBond = BondName.SingleBond TripleBond = BondName.TripleBond UnknownBond = BondName.UnknownBond   class BondOrder(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.BondOrder, rosetta.core.chemical.BondOrder) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.BondOrder) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.BondOrder, int) -> NoneType   2. __init__(rosetta.core.chemical.BondOrder, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.BondOrder) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.BondOrder, rosetta.core.chemical.BondOrder) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.BondOrder) -> str Data and other attributes defined here: DoubleBondOrder = BondOrder.DoubleBondOrder OrbitalBondOrder = BondOrder.OrbitalBondOrder PseudoBondOrder = BondOrder.PseudoBondOrder SingleBondOrder = BondOrder.SingleBondOrder TripleBondOrder = BondOrder.TripleBondOrder UnknownBondOrder = BondOrder.UnknownBondOrder   class BondRingness(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.BondRingness, rosetta.core.chemical.BondRingness) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.BondRingness) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.BondRingness, int) -> NoneType   2. __init__(rosetta.core.chemical.BondRingness, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.BondRingness) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.BondRingness, rosetta.core.chemical.BondRingness) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.BondRingness) -> str Data and other attributes defined here: BondInRing = BondRingness.BondInRing BondNotInRing = BondRingness.BondNotInRing UnknownRingness = BondRingness.UnknownRingness   class ChangeAncestory(PatchOperation)       Method resolution order: ChangeAncestory PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, target_atom : str, which_ancestor : rosetta.core.chemical.Ancestor, ancestor_name : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ChangeAncestory) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ChangeAncestory, rsd : core::chemical::ResidueType) -> bool   change the ancestory, but leave the icoors intact. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ChangeAncestory,  : rosetta.core.chemical.ChangeAncestory) -> rosetta.core.chemical.ChangeAncestory Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ChangeBondType(PatchOperation)     ////////////////////////////////////////////////////////////////////////////      A patch operation for changing the bond type of a given bond.       See residue_io.cc for a description of bond types.     Labonte <JWLabonte.edu>     Method resolution order: ChangeBondType PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom1_in : str, atom2_in : str, old_bond_type_in : str, new_bond_type_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ChangeBondType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ChangeBondType, rsd : core::chemical::ResidueType) -> bool   Apply this patch to the given ResidueType. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ChangeBondType,  : rosetta.core.chemical.ChangeBondType) -> rosetta.core.chemical.ChangeBondType Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ChemicalManager(rosetta.utility.SingletonBase_core_chemical_ChemicalManager_t)     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.     Method resolution order: ChemicalManager rosetta.utility.SingletonBase_core_chemical_ChemicalManager_t builtins.object Methods defined here: __init__(self, /, *args, **kwargs) Initialize self.  See help(type(self)) for accurate signature. __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atom_type_set(...) from builtins.PyCapsule atom_type_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> rosetta.core.chemical.AtomTypeSet   query atom_type_set by a name tag element_set(...) from builtins.PyCapsule element_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> core::chemical::ElementSet   query atom_type_set by a name tag gasteiger_atom_type_set(...) from builtins.PyCapsule gasteiger_atom_type_set(*args, **kwargs) Overloaded function.   1. gasteiger_atom_type_set(rosetta.core.chemical.ChemicalManager) -> core::chemical::gasteiger::GasteigerAtomTypeSet   query gasteiger_atom_type_set by a name tag   2. gasteiger_atom_type_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> core::chemical::gasteiger::GasteigerAtomTypeSet   query gasteiger_atom_type_set by a name tag has_residue_type_set(...) from builtins.PyCapsule has_residue_type_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> bool   Check if residue_type_set is instantiated... ideal_bond_length_set(...) from builtins.PyCapsule ideal_bond_length_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> core::chemical::IdealBondLengthSet   query ideal_bond_lengths mm_atom_type_set(...) from builtins.PyCapsule mm_atom_type_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> core::chemical::MMAtomTypeSet   query mm_atom_type_set by a name tag nonconst_residue_type_set(...) from builtins.PyCapsule nonconst_residue_type_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> core::chemical::ResidueTypeSet   query residue_type_set by a name tag nonconst_residue_type_set_op(...) from builtins.PyCapsule nonconst_residue_type_set_op(self : rosetta.core.chemical.ChemicalManager, tag : str) -> core::chemical::ResidueTypeSet orbital_type_set(...) from builtins.PyCapsule orbital_type_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> core::chemical::orbitals::OrbitalTypeSet   query orbital_type_set by a name tag residue_type_set(...) from builtins.PyCapsule residue_type_set(self : rosetta.core.chemical.ChemicalManager, tag : str) -> core::chemical::ResidueTypeSet   query residue_type_set by a name tag Methods inherited from rosetta.utility.SingletonBase_core_chemical_ChemicalManager_t: get_instance(...) from builtins.PyCapsule get_instance() -> core::chemical::ChemicalManager   class ChiralFlipAtoms(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Execute chiral flip (primarily: at CA)     Method resolution order: ChiralFlipAtoms PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ChiralFlipAtoms, rsd : core::chemical::ResidueType) -> bool   set the NCAA rotamer library path in the residue type assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ChiralFlipAtoms,  : rosetta.core.chemical.ChiralFlipAtoms) -> rosetta.core.chemical.ChiralFlipAtoms Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ChiralFlipNaming(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Execute chiral flip (primarily: at CA)     Method resolution order: ChiralFlipNaming PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.ChiralFlipNaming) -> bool apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ChiralFlipNaming, rsd : core::chemical::ResidueType) -> bool   set the NCAA rotamer library path in the residue type assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ChiralFlipNaming,  : rosetta.core.chemical.ChiralFlipNaming) -> rosetta.core.chemical.ChiralFlipNaming may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.ChiralFlipNaming) -> bool   Generates a new aa Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3.   class ClearChiRotamers(PatchOperation)     ////////////////////////////////////////////////////////////////////////////      A patch operation for clearing all rotamer bins from the chi of a ResidueType.       This is useful if one has redefined a chi.     Labonte <JWLabonte.edu>     Method resolution order: ClearChiRotamers PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : handle, chi_no_in : int) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ClearChiRotamers, rsd : core::chemical::ResidueType) -> bool   Apply this patch to the given ResidueType. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ClearChiRotamers,  : rosetta.core.chemical.ClearChiRotamers) -> rosetta.core.chemical.ClearChiRotamers Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ConnectSulfurAndMakeVirtualProton(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Add a connection to the residue's sulfur and make a virtual proton to track the position of the connection atom     Method resolution order: ConnectSulfurAndMakeVirtualProton PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ConnectSulfurAndMakeVirtualProton, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ConnectSulfurAndMakeVirtualProton,  : rosetta.core.chemical.ConnectSulfurAndMakeVirtualProton) -> rosetta.core.chemical.ConnectSulfurAndMakeVirtualProton Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class DeleteActCoordAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Delete an act coord atom    Added by Andrew M. Watkins in April 2015     Method resolution order: DeleteActCoordAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.DeleteActCoordAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.DeleteActCoordAtom, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.DeleteActCoordAtom,  : rosetta.core.chemical.DeleteActCoordAtom) -> rosetta.core.chemical.DeleteActCoordAtom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class DeleteAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     delete an atom     Method resolution order: DeleteAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.DeleteAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.DeleteAtom, rsd : core::chemical::ResidueType) -> bool   delete an atom from ResidueType rsd assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.DeleteAtom,  : rosetta.core.chemical.DeleteAtom) -> rosetta.core.chemical.DeleteAtom deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.DeleteAtom) -> str Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class DeleteChildProton(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     delete child proton     Method resolution order: DeleteChildProton PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.DeleteChildProton) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.DeleteChildProton, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.DeleteChildProton,  : rosetta.core.chemical.DeleteChildProton) -> rosetta.core.chemical.DeleteChildProton Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class DeleteMetalbindingAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Delete a metal binding atom    Added by Andrew M. Watkins in April 2015     Method resolution order: DeleteMetalbindingAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.DeleteMetalbindingAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.DeleteMetalbindingAtom, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.DeleteMetalbindingAtom,  : rosetta.core.chemical.DeleteMetalbindingAtom) -> rosetta.core.chemical.DeleteMetalbindingAtom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class DeleteProperty(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     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)     Method resolution order: DeleteProperty PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, property_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.DeleteProperty) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.DeleteProperty, rsd : core::chemical::ResidueType) -> bool   delete a property assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.DeleteProperty,  : rosetta.core.chemical.DeleteProperty) -> rosetta.core.chemical.DeleteProperty deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.DeleteProperty) -> str   Which property, if any, is deleted. Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class DeleteTerminalChi(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Delete terminal chi angle    Added by Andrew M. Watkins in April 2015     Method resolution order: DeleteTerminalChi PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.DeleteTerminalChi, rsd : core::chemical::ResidueType) -> bool   redefine a chi angle assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.DeleteTerminalChi,  : rosetta.core.chemical.DeleteTerminalChi) -> rosetta.core.chemical.DeleteTerminalChi Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class DeleteVariantType(PatchOperation)     ////////////////////////////////////////////////////////////////////////////      A patch operation for deleting a VariantType from a ResidueType.     Labonte <JWLabonte.edu>     Method resolution order: DeleteVariantType PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, variant_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.DeleteVariantType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.DeleteVariantType, rsd : core::chemical::ResidueType) -> bool   Apply this patch to the given ResidueType. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.DeleteVariantType,  : rosetta.core.chemical.DeleteVariantType) -> rosetta.core.chemical.DeleteVariantType deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.DeleteVariantType) -> str   Which variant, if any, is deleted. Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ElectronConfiguration(builtins.object)     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////         describes the electron configuration of atoms     Describes the electron configuration of an atom on quantum chemistry level.     Methods defined here: AngularMomentumQuantumNumber_strings(...) from builtins.PyCapsule AngularMomentumQuantumNumber_strings() -> rosetta.std.vector_std_string PrincipalQuantumNumber_strings(...) from builtins.PyCapsule PrincipalQuantumNumber_strings() -> rosetta.std.vector_std_string __call__(...) from builtins.PyCapsule __call__(*args, **kwargs) Overloaded function.   1. __call__(self : rosetta.core.chemical.ElectronConfiguration, PRINCIPAL_QUANTUM_NUMBER : rosetta.core.chemical.PrincipalQuantumNumber, ANGULAR_MOMENTUM_QUANTUM_NUMBER : rosetta.core.chemical.AngularMomentumQuantumNumber) -> int   number of electrons in that orbital      1, 2, 3, 4, 5, 6. or 7      S, P, D, or F      number of electrons in that particular orbital indicated by PRINCIPAL_QUANTUM_NUMBER and ANGULAR_MOMENTUM_QUANTUM_NUMBER   2. __call__(self : rosetta.core.chemical.ElectronConfiguration, ANGULAR_MOMENTUM_QUANTUM_NUMBER : rosetta.core.chemical.AngularMomentumQuantumNumber) -> int   number of electrons in the valence orbital      S, P, D, or F      number of electrons in the valence orbital indicated by ANGULAR_MOMENTUM_QUANTUM_NUMBER __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.ElectronConfiguration) -> NoneType   2. __init__(self : rosetta.core.chemical.ElectronConfiguration, 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 : int) -> NoneType   3. __init__(self : rosetta.core.chemical.ElectronConfiguration,  : rosetta.core.chemical.ElectronConfiguration) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.ElectronConfiguration) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ElectronConfiguration,  : rosetta.core.chemical.ElectronConfiguration) -> rosetta.core.chemical.ElectronConfiguration get_angular_momentum_quantum_number(...) from builtins.PyCapsule get_angular_momentum_quantum_number(STR : str) -> rosetta.core.chemical.AngularMomentumQuantumNumber   AngularMomentumQuantumNumber as string      NUM the AngularMomentumQuantumNumber desired      AngularMomentumQuantumNumber as string get_descriptor(...) from builtins.PyCapsule get_descriptor(*args, **kwargs) Overloaded function.   1. get_descriptor(NUM : rosetta.core.chemical.PrincipalQuantumNumber) -> str   PrincipalQuantumNumber as string      the PrincipalQuantumNumber desired      the PrincipalQuantumNumber as string   2. get_descriptor(NUM : rosetta.core.chemical.AngularMomentumQuantumNumber) -> str   AngularMomentumQuantumNumber as string      the AngularMomentumQuantumNumber desired      the AngularMomentumQuantumNumber as string get_principal_quantum_number(...) from builtins.PyCapsule get_principal_quantum_number(STR : str) -> rosetta.core.chemical.PrincipalQuantumNumber   PrincipalQuantumNumber from string      NUM the PrincipalQuantumNumber desired      PrincipalQuantumNumber as string max_valence_electrons_sp(...) from builtins.PyCapsule max_valence_electrons_sp(rosetta.core.chemical.ElectronConfiguration) -> int   the maximum number of electrons in SP orbitals for the noble gas in this period unpaired_valence_electrons_sp(...) from builtins.PyCapsule unpaired_valence_electrons_sp(rosetta.core.chemical.ElectronConfiguration) -> int   return the number of valence electrons in SP orbitals valence_electrons_p(...) from builtins.PyCapsule valence_electrons_p(rosetta.core.chemical.ElectronConfiguration) -> int   number ValenceElectrons in the pi valence orbitals valence_electrons_s(...) from builtins.PyCapsule valence_electrons_s(rosetta.core.chemical.ElectronConfiguration) -> int   return number ValenceElectrons in the sigma valence orbitals valence_electrons_sp(...) from builtins.PyCapsule valence_electrons_sp(rosetta.core.chemical.ElectronConfiguration) -> int   number valence_electrons_sp valence_electrons_spd(...) from builtins.PyCapsule valence_electrons_spd(rosetta.core.chemical.ElectronConfiguration) -> int   number valence_electrons_spd Data and other attributes defined here: AngularMomentumQuantumNumber = <class 'rosetta.core.chemical.ElectronConfiguration.AngularMomentumQuantumNumber'> MaxAngularMomentumQuantumNumber = AngularMomentumQuantumNumber.MaxAngularMomentumQuantumNumber MaxPrincipleQuantumNumber = PrincipalQuantumNumber.MaxPrincipleQuantumNumber PrincipalQuantumNumber = <class 'rosetta.core.chemical.ElectronConfiguration.PrincipalQuantumNumber'> e_1 = PrincipalQuantumNumber.e_1 e_2 = PrincipalQuantumNumber.e_2 e_3 = PrincipalQuantumNumber.e_3 e_4 = PrincipalQuantumNumber.e_4 e_5 = PrincipalQuantumNumber.e_5 e_6 = PrincipalQuantumNumber.e_6 e_7 = PrincipalQuantumNumber.e_7 e_D = AngularMomentumQuantumNumber.e_D e_F = AngularMomentumQuantumNumber.e_F e_P = AngularMomentumQuantumNumber.e_P e_S = AngularMomentumQuantumNumber.e_S   class Element(builtins.object)     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////         stores element properties     This is a low level helper class to store element properties     Methods defined here: Clone(...) from builtins.PyCapsule Clone(rosetta.core.chemical.Element) -> rosetta.core.chemical.Element   virtual copy constructor __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.Element) -> NoneType   2. __init__(self : rosetta.core.chemical.Element, ATOMIC_NUMBER : int, PERIOD : int, MAIN_GROUP : int, CHEMICAL_SYMBOL : str, CHEMICAL_NAME : str, MASS : float, COVALENT_RADIUS : float, VDW_RADIUS : float, ELECTRON_CONFIGURATION : rosetta.core.chemical.ElectronConfiguration) -> NoneType   3. __init__(self : rosetta.core.chemical.Element,  : rosetta.core.chemical.Element) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.Element) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Element,  : rosetta.core.chemical.Element) -> rosetta.core.chemical.Element element(...) from builtins.PyCapsule element(rosetta.core.chemical.Element) -> rosetta.core.chemical.element.Elements   The element enumeration get_atomic_number(...) from builtins.PyCapsule get_atomic_number(rosetta.core.chemical.Element) -> int   atomic number      atomic number get_chemical_name(...) from builtins.PyCapsule get_chemical_name(rosetta.core.chemical.Element) -> str   GetChemicalName      full chemical name get_chemical_symbol(...) from builtins.PyCapsule get_chemical_symbol(rosetta.core.chemical.Element) -> str   GetChemicalSymbol      chemical symbol one or two letters as AtomName get_electron_configuration(...) from builtins.PyCapsule get_electron_configuration(rosetta.core.chemical.Element) -> rosetta.core.chemical.ElectronConfiguration   electron configuration      the ElectronConfiguration get_main_group(...) from builtins.PyCapsule get_main_group(rosetta.core.chemical.Element) -> int   main Group # get_period(...) from builtins.PyCapsule get_period(rosetta.core.chemical.Element) -> int   Period get_property(...) from builtins.PyCapsule get_property(self : rosetta.core.chemical.Element, PROPERTY : rosetta.core.chemical.Properties) -> float   element type property as core::Real      the property desired      the property as core::Real get_property_name(...) from builtins.PyCapsule get_property_name(PROPERTY : rosetta.core.chemical.Properties) -> str   element type property as string      the property desired      the property as string is_conjugatable(...) from builtins.PyCapsule is_conjugatable(rosetta.core.chemical.Element) -> bool   tell whether this element type can participate in a conjugated system      true if this element can participate in a common conjugated system  Specifically tests if the element has 1-4 valence electrons in P orbitals is_fake(...) from builtins.PyCapsule is_fake(rosetta.core.chemical.Element) -> bool   Return true unless the element actually exists in the periodic table. weight(...) from builtins.PyCapsule weight(rosetta.core.chemical.Element) -> float   This is legacy code from old element set      Return the full name of the Element Data and other attributes defined here: CovalentRadius = Properties.CovalentRadius Mass = Properties.Mass NumberOfProperties = Properties.NumberOfProperties Properties = <class 'rosetta.core.chemical.Element.Properties'> enum  properties for element types VDWaalsRadius = Properties.VDWaalsRadius   class ElementSet(builtins.object)     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.     Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.ElementSet, index : int) -> rosetta.core.chemical.Element   Lookup an Element by 1-based indexing __init__(...) from builtins.PyCapsule __init__(rosetta.core.chemical.ElementSet) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ElementSet,  : rosetta.core.chemical.ElementSet) -> rosetta.core.chemical.ElementSet contains_element_type(...) from builtins.PyCapsule contains_element_type(self : rosetta.core.chemical.ElementSet, element_symbol : str) -> bool   Check if there is an element_type associated with an element_symbol string element(...) from builtins.PyCapsule element(*args, **kwargs) Overloaded function.   1. element(self : rosetta.core.chemical.ElementSet, ele : rosetta.core.chemical.element.Elements) -> rosetta.core.chemical.Element   Lookup the element index by the element enum;   2. element(self : rosetta.core.chemical.ElementSet, element_symbol : str) -> rosetta.core.chemical.Element   Lookup the element object by the element_symbol string element_index(...) from builtins.PyCapsule element_index(*args, **kwargs) Overloaded function.   1. element_index(self : rosetta.core.chemical.ElementSet, ele : rosetta.core.chemical.element.Elements) -> int   Lookup the element index by the element enum   2. element_index(self : rosetta.core.chemical.ElementSet, element_symbol : str) -> int   Lookup the element index by the element_symbol string n_elements(...) from builtins.PyCapsule n_elements(rosetta.core.chemical.ElementSet) -> int   Number of elements in the set read_file(...) from builtins.PyCapsule read_file(self : rosetta.core.chemical.ElementSet, filename : str) -> NoneType   Load the ElementSet from a file   class GreekDistance(builtins.object)     Enumerators for the Greek distance from the atom with the functional group of highest priority.     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.GreekDistance, rosetta.core.chemical.GreekDistance) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.GreekDistance) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.GreekDistance, int) -> NoneType   2. __init__(rosetta.core.chemical.GreekDistance, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.GreekDistance) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.GreekDistance, rosetta.core.chemical.GreekDistance) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.GreekDistance) -> str Data and other attributes defined here: ALPHA_ATOM = GreekDistance.ALPHA_ATOM BETA_ATOM = GreekDistance.BETA_ATOM CHI_ATOM = GreekDistance.CHI_ATOM DELTA_ATOM = GreekDistance.DELTA_ATOM EPSILON_ATOM = GreekDistance.EPSILON_ATOM ETA_ATOM = GreekDistance.ETA_ATOM GAMMA_ATOM = GreekDistance.GAMMA_ATOM IOTA_ATOM = GreekDistance.IOTA_ATOM KAPPA_ATOM = GreekDistance.KAPPA_ATOM LAMBDA_ATOM = GreekDistance.LAMBDA_ATOM MU_ATOM = GreekDistance.MU_ATOM NA_GREEK_DISTANCE = GreekDistance.NA_GREEK_DISTANCE NU_ATOM = GreekDistance.NU_ATOM OMICRON_ATOM = GreekDistance.OMICRON_ATOM PHI_ATOM = GreekDistance.PHI_ATOM PI_ATOM = GreekDistance.PI_ATOM PRIMARY_ATOM = GreekDistance.PRIMARY_ATOM PSI_ATOM = GreekDistance.PSI_ATOM SIGMA_ATOM = GreekDistance.SIGMA_ATOM TAU_ATOM = GreekDistance.TAU_ATOM THETA_ATOM = GreekDistance.THETA_ATOM UPSILON_ATOM = GreekDistance.UPSILON_ATOM XI_ATOM = GreekDistance.XI_ATOM ZETA_ATOM = GreekDistance.ZETA_ATOM   class HeavyAtomFilter(builtins.object)     The filter responsible for obtaining all heavy atoms.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.HeavyAtomFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.HeavyAtomFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.HeavyAtomFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>, atom_types : rosetta.std.weak_ptr_const_core_chemical_AtomTypeSet_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.HeavyAtomFilter,  : rosetta.core.chemical.HeavyAtomFilter) -> rosetta.core.chemical.HeavyAtomFilter   class HeavyAtomWithHydrogensFilter(builtins.object)     The filter responsible for finding heavy atoms with hydrogens.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.HeavyAtomWithHydrogensFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.HeavyAtomWithHydrogensFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.HeavyAtomWithHydrogensFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>, atom_types : rosetta.std.weak_ptr_const_core_chemical_AtomTypeSet_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.HeavyAtomWithHydrogensFilter,  : rosetta.core.chemical.HeavyAtomWithHydrogensFilter) -> rosetta.core.chemical.HeavyAtomWithHydrogensFilter   class HeavyAtomWithPolarHydrogensFilter(builtins.object)     The filter responsible for obtaining all heavy atoms with polar hydrogens attached to them.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.HeavyAtomWithPolarHydrogensFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.HeavyAtomWithPolarHydrogensFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.HeavyAtomWithPolarHydrogensFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>, atom_types : rosetta.std.weak_ptr_const_core_chemical_AtomTypeSet_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.HeavyAtomWithPolarHydrogensFilter,  : rosetta.core.chemical.HeavyAtomWithPolarHydrogensFilter) -> rosetta.core.chemical.HeavyAtomWithPolarHydrogensFilter   class Hybridization(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.Hybridization, rosetta.core.chemical.Hybridization) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.Hybridization) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.Hybridization, int) -> NoneType   2. __init__(rosetta.core.chemical.Hybridization, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.Hybridization) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.Hybridization, rosetta.core.chemical.Hybridization) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.Hybridization) -> str Data and other attributes defined here: HYBRID_MAX = Hybridization.HYBRID_MAX RING_HYBRID = Hybridization.RING_HYBRID SP2_HYBRID = Hybridization.SP2_HYBRID SP3_HYBRID = Hybridization.SP3_HYBRID UNKNOWN_HYBRID = Hybridization.HYBRID_MAX   class HydrogenAtomFilter(builtins.object)     The filter responsible for all hydrogens.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.HydrogenAtomFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.HydrogenAtomFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.HydrogenAtomFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>, atom_types : rosetta.std.weak_ptr_const_core_chemical_AtomTypeSet_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.HydrogenAtomFilter,  : rosetta.core.chemical.HydrogenAtomFilter) -> rosetta.core.chemical.HydrogenAtomFilter   class ICoorAtomID(builtins.object)     Atom 's ID in internal coordinates in a ResidueType     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.ICoorAtomID) -> NoneType   2. __init__(self : rosetta.core.chemical.ICoorAtomID, name : str, rsd_type : core::chemical::ResidueType) -> NoneType   3. __init__(self : rosetta.core.chemical.ICoorAtomID, capsule, vd : core::chemical::ResidueType) -> NoneType   4. __init__(self : rosetta.core.chemical.ICoorAtomID, id : rosetta.core.chemical.ICoorAtomID) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ICoorAtomID,  : rosetta.core.chemical.ICoorAtomID) -> rosetta.core.chemical.ICoorAtomID atom_id(...) from builtins.PyCapsule atom_id(self : rosetta.core.chemical.ICoorAtomID, seqpos : int, conformation : core::conformation::Conformation) -> core::id::AtomID atomno(...) from builtins.PyCapsule atomno(*args, **kwargs) Overloaded function.   1. atomno(rosetta.core.chemical.ICoorAtomID) -> int   get ICoorAtomID atomno   2. atomno(self : rosetta.core.chemical.ICoorAtomID, atomno_in : int) -> NoneType   set ICoorAtomID atomno is_connect(...) from builtins.PyCapsule is_connect(*args, **kwargs) Overloaded function.   1. is_connect(self : rosetta.core.chemical.ICoorAtomID, connid : int) -> bool   Returns true if this is the specified connection id   2. is_connect(rosetta.core.chemical.ICoorAtomID) -> bool   Returns true if this is a connection.      Vikram K. Mulligan (vmullig.edu) is_internal(...) from builtins.PyCapsule is_internal(rosetta.core.chemical.ICoorAtomID) -> bool is_polymer_lower(...) from builtins.PyCapsule is_polymer_lower(rosetta.core.chemical.ICoorAtomID) -> bool is_polymer_upper(...) from builtins.PyCapsule is_polymer_upper(rosetta.core.chemical.ICoorAtomID) -> bool type(...) from builtins.PyCapsule type(rosetta.core.chemical.ICoorAtomID) -> rosetta.core.chemical.Type   get ICoordAtomID type vertex(...) from builtins.PyCapsule vertex(*args, **kwargs) Overloaded function.   1. vertex(rosetta.core.chemical.ICoorAtomID) -> capsule   2. vertex(self : rosetta.core.chemical.ICoorAtomID, capsule) -> NoneType xyz(...) from builtins.PyCapsule xyz(*args, **kwargs) Overloaded function.   1. xyz(self : rosetta.core.chemical.ICoorAtomID, rsd : core::conformation::Residue, conformation : core::conformation::Conformation) -> rosetta.numeric.xyzVector_double_t   2. xyz(self : rosetta.core.chemical.ICoorAtomID, rsd_type : core::chemical::ResidueType) -> rosetta.numeric.xyzVector_double_t   3. xyz(self : rosetta.core.chemical.ICoorAtomID, rsd : core::conformation::Residue) -> rosetta.numeric.xyzVector_double_t   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. Data and other attributes defined here: CONNECT = Type.CONNECT INTERNAL = Type.INTERNAL POLYMER_LOWER = Type.POLYMER_LOWER POLYMER_UPPER = Type.POLYMER_UPPER Type = <class 'rosetta.core.chemical.ICoorAtomID.Type'> ICoordAtomID type   - INTERNAL: atoms which inherently belong to this ResidueType - POLYMER_LOWER: atom at the polymer lower connection, such as backbone C in the previous residue (N-term side) - POLYMER_UPPER: atom at the polymer upper connection, such as backbone N in the next residue (C-term side) - CONNECT: atoms from a non-adjacent residue which connect to this residue by non-polymer connection, such as disulfide   class IdealBondLengthSet(builtins.object)     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.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.chemical.IdealBondLengthSet) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.IdealBondLengthSet,  : rosetta.core.chemical.IdealBondLengthSet) -> rosetta.core.chemical.IdealBondLengthSet contains_bond_length(...) from builtins.PyCapsule contains_bond_length(*args, **kwargs) Overloaded function.   1. contains_bond_length(self : rosetta.core.chemical.IdealBondLengthSet, atom_type_name1 : str, atom_type_name2 : str) -> bool   Check if an ideal bond length is known for this pair of atom types...   2. contains_bond_length(self : rosetta.core.chemical.IdealBondLengthSet, atom_type_index1 : int, atom_type_index2 : int) -> bool get_bond_length(...) from builtins.PyCapsule get_bond_length(*args, **kwargs) Overloaded function.   1. get_bond_length(self : rosetta.core.chemical.IdealBondLengthSet, atom_type_name1 : str, atom_type_name2 : str) -> float   Lookup the element index by the element_symbol string   2. get_bond_length(self : rosetta.core.chemical.IdealBondLengthSet, atom_type_index1 : int, atom_type_index2 : int) -> float print_all_bond_lengths(...) from builtins.PyCapsule print_all_bond_lengths(rosetta.core.chemical.IdealBondLengthSet) -> NoneType   Print all of the symbols of all of the Elements in the set. Usefull for debuging. read_file(...) from builtins.PyCapsule read_file(self : rosetta.core.chemical.IdealBondLengthSet, filename : str) -> NoneType   Load the IdealBondLengthSet from a file   class MMAtomType(builtins.object)     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     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.chemical.MMAtomType, name_in : str) -> NoneType   2. __init__(self : rosetta.core.chemical.MMAtomType,  : rosetta.core.chemical.MMAtomType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. lj_radius(...) from builtins.PyCapsule lj_radius(rosetta.core.chemical.MMAtomType) -> float   Return the LJ radius of the atom type lj_radius_sq(...) from builtins.PyCapsule lj_radius_sq(rosetta.core.chemical.MMAtomType) -> float   Return the squared LJ radius of the atom type lj_three_bond_radius(...) from builtins.PyCapsule lj_three_bond_radius(rosetta.core.chemical.MMAtomType) -> float   Return the LJ radius for use when atoms types are seperated by 3 bonds lj_three_bond_radius_sq(...) from builtins.PyCapsule lj_three_bond_radius_sq(rosetta.core.chemical.MMAtomType) -> float   Return the squaredLJ radius for use when atoms types are seperated by 3 bonds lj_three_bond_wdepth(...) from builtins.PyCapsule lj_three_bond_wdepth(rosetta.core.chemical.MMAtomType) -> float   Return the LJ well depth for use when atoms types are seperated by 3 bonds lj_wdepth(...) from builtins.PyCapsule lj_wdepth(rosetta.core.chemical.MMAtomType) -> float   Return the LJ well depth of the atom type name(...) from builtins.PyCapsule name(rosetta.core.chemical.MMAtomType) -> str   Return the name of the MMAtomType set_parameter(...) from builtins.PyCapsule set_parameter(self : rosetta.core.chemical.MMAtomType, param : str, setting : float) -> NoneType   set LJ and LK solvation parameter for this atom type   class MMAtomTypeSet(builtins.object)     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.     Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.MMAtomTypeSet, index : int) -> rosetta.core.chemical.MMAtomType   Lookup an MMAtomType by 1-based indexing __init__(...) from builtins.PyCapsule __init__(rosetta.core.chemical.MMAtomTypeSet) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.MMAtomTypeSet,  : rosetta.core.chemical.MMAtomTypeSet) -> rosetta.core.chemical.MMAtomTypeSet atom_type_index(...) from builtins.PyCapsule atom_type_index(self : rosetta.core.chemical.MMAtomTypeSet, atom_type_name : str) -> int   Lookup the atom_type by the atom_type_name string contains_atom_type(...) from builtins.PyCapsule contains_atom_type(self : rosetta.core.chemical.MMAtomTypeSet, atom_type_name : str) -> bool   Check if there is an atom_type associated with an atom_type_name string n_atomtypes(...) from builtins.PyCapsule n_atomtypes(rosetta.core.chemical.MMAtomTypeSet) -> int   Number of MM atom types in the set print_all_types(...) from builtins.PyCapsule print_all_types(rosetta.core.chemical.MMAtomTypeSet) -> NoneType   Print all of the names of all of the MMAtomTypes in the set. Usefull for debuging. read_file(...) from builtins.PyCapsule read_file(self : rosetta.core.chemical.MMAtomTypeSet, filename : str) -> NoneType   Load the MMAtomTypeSet from a file   class MergeBehaviorManager(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : rosetta.core.chemical.MergeBehaviorManager, database_directory : str) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. merge_behavior_for_name3(...) from builtins.PyCapsule merge_behavior_for_name3(self : rosetta.core.chemical.MergeBehaviorManager, name3 : str) -> (rosetta.core.chemical.merge_residue_behavior, rosetta.std.map_std_string_std_string)   class Metapatch(builtins.object)     /////////////////////////////////////////////////////////////////////////////////////     A class patching basic ResidueType to create variant types, containing multiple PatchCase     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.chemical.Metapatch) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. applies_to(...) from builtins.PyCapsule applies_to(self : rosetta.core.chemical.Metapatch, rsd : rosetta.core.chemical.ResidueType) -> bool   can I operate on this residue type? assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Metapatch,  : rosetta.core.chemical.Metapatch) -> rosetta.core.chemical.Metapatch atoms(...) from builtins.PyCapsule atoms(self : rosetta.core.chemical.Metapatch, rsd_type : rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string get_one_patch(...) from builtins.PyCapsule get_one_patch(self : rosetta.core.chemical.Metapatch, atom_name : str) -> rosetta.core.chemical.Patch meets_requirements(...) from builtins.PyCapsule meets_requirements(self : rosetta.core.chemical.Metapatch, r : rosetta.core.chemical.ResidueType, i : int) -> bool name(...) from builtins.PyCapsule name(rosetta.core.chemical.Metapatch) -> str   unique name of this patch, eg Nter-simple, Cter-full, Phospho, ... ? read_file(...) from builtins.PyCapsule read_file(self : rosetta.core.chemical.Metapatch, filename : str) -> NoneType   constructor from file types(...) from builtins.PyCapsule types(rosetta.core.chemical.Metapatch) -> rosetta.utility.vector1_std_string   the variant types created by applying this patch   class NCAARotLibPath(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set the path to a rotamer library for an NCAA that is not in dunbrack     Method resolution order: NCAARotLibPath PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, path_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.NCAARotLibPath) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.NCAARotLibPath, rsd : core::chemical::ResidueType) -> bool   set the NCAA rotamer library path in the residue type assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.NCAARotLibPath,  : rosetta.core.chemical.NCAARotLibPath) -> rosetta.core.chemical.NCAARotLibPath Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class Orbital(builtins.object)     basic chemical atom     name, element, certain properties and parameters from .params file     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.Orbital) -> NoneType   2. __init__(self : rosetta.core.chemical.Orbital, name_in : str, orbital_type_index : int, xyz : rosetta.numeric.xyzVector_double_t) -> NoneType   3. __init__(self : rosetta.core.chemical.Orbital, src : rosetta.core.chemical.Orbital) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.Orbital) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Orbital,  : rosetta.core.chemical.Orbital) -> rosetta.core.chemical.Orbital icoor(...) from builtins.PyCapsule icoor(*args, **kwargs) Overloaded function.   1. icoor(rosetta.core.chemical.Orbital) -> rosetta.core.chemical.orbitals.ICoorOrbitalData   2. icoor(rosetta.core.chemical.Orbital) -> rosetta.core.chemical.orbitals.ICoorOrbitalData   3. icoor(self : rosetta.core.chemical.Orbital, icoor : rosetta.core.chemical.orbitals.ICoorOrbitalData) -> NoneType ideal_xyz(...) from builtins.PyCapsule ideal_xyz(*args, **kwargs) Overloaded function.   1. ideal_xyz(rosetta.core.chemical.Orbital) -> rosetta.numeric.xyzVector_double_t   2. ideal_xyz(self : rosetta.core.chemical.Orbital, xyz : rosetta.numeric.xyzVector_double_t) -> NoneType name(...) from builtins.PyCapsule name(*args, **kwargs) Overloaded function.   1. name(rosetta.core.chemical.Orbital) -> str   2. name(self : rosetta.core.chemical.Orbital, name : str) -> NoneType new_icoor(...) from builtins.PyCapsule new_icoor(*args, **kwargs) Overloaded function.   1. new_icoor(rosetta.core.chemical.Orbital) -> rosetta.core.chemical.orbitals.ICoorOrbitalData   2. new_icoor(rosetta.core.chemical.Orbital) -> rosetta.core.chemical.orbitals.ICoorOrbitalData   3. new_icoor(self : rosetta.core.chemical.Orbital, new_icoor : rosetta.core.chemical.orbitals.ICoorOrbitalData) -> NoneType orbital_type_index(...) from builtins.PyCapsule orbital_type_index(*args, **kwargs) Overloaded function.   1. orbital_type_index(rosetta.core.chemical.Orbital) -> int   2. orbital_type_index(self : rosetta.core.chemical.Orbital, atom_type_index : int) -> NoneType   class Patch(builtins.object)     /////////////////////////////////////////////////////////////////////////////////////     A class patching basic ResidueType to create variant types, containing multiple PatchCase     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, res_type_set_name : str) -> NoneType   3. __init__(handle, rosetta.core.chemical.Patch) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_case(...) from builtins.PyCapsule add_case(self : rosetta.core.chemical.Patch, pcase : rosetta.core.chemical.PatchCase) -> NoneType adds_atoms(...) from builtins.PyCapsule adds_atoms(self : rosetta.core.chemical.Patch, rsd_in : rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string   returns list of added atom names, useful for identifying patches that go with PDB residues adds_properties(...) from builtins.PyCapsule adds_properties(self : rosetta.core.chemical.Patch, rsd_in : rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string   returns list of added property names, useful for identifying patches that go with PDB residues applies_to(...) from builtins.PyCapsule applies_to(self : rosetta.core.chemical.Patch, rsd : rosetta.core.chemical.ResidueType) -> bool   can I operate on this residue type? apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.chemical.Patch, rsd_type : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   returns patched residue, 0 if patch failed   2. apply(self : rosetta.core.chemical.Patch, rsd_type : rosetta.core.chemical.ResidueType, instantiate : bool) -> rosetta.core.chemical.ResidueType   returns patched residue, 0 if patch failed assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Patch,  : rosetta.core.chemical.Patch) -> rosetta.core.chemical.Patch deletes_atoms(...) from builtins.PyCapsule deletes_atoms(self : rosetta.core.chemical.Patch, rsd_in : rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string   returns list of deleted atom names, useful for identifying patches that go with PDB residues deletes_properties(...) from builtins.PyCapsule deletes_properties(self : rosetta.core.chemical.Patch, rsd_in : rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string   returns list of deleted property names, useful for identifying patches that go with PDB residues deletes_variants(...) from builtins.PyCapsule deletes_variants(self : rosetta.core.chemical.Patch, rsd_in : rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string   returns list of deleted variant names, useful for identifying patches that go with PDB residues generates_aa(...) from builtins.PyCapsule generates_aa(self : rosetta.core.chemical.Patch, rsd_in : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.AA   returns new AA, if changed. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(self : rosetta.core.chemical.Patch, rsd_in : rosetta.core.chemical.ResidueType) -> str   returns new interchangeability_group, if changed. Only one new interchangeability_group allowed. generates_new_name3(...) from builtins.PyCapsule generates_new_name3(self : rosetta.core.chemical.Patch, rsd_in : rosetta.core.chemical.ResidueType) -> str   returns new name3, if changed. Only one new name3 allowed. name(...) from builtins.PyCapsule name(rosetta.core.chemical.Patch) -> str   unique name of this patch, eg Nter-simple, Cter-full, Phospho, ... ? read_file(...) from builtins.PyCapsule read_file(self : rosetta.core.chemical.Patch, filename : str) -> NoneType   constructor from file replaces(...) from builtins.PyCapsule replaces(self : rosetta.core.chemical.Patch, rsd : rosetta.core.chemical.ResidueType) -> bool   do I replace this residue type? replaces_residue_type(...) from builtins.PyCapsule replaces_residue_type(self : rosetta.core.chemical.Patch, replaces : bool) -> NoneType set_name(...) from builtins.PyCapsule set_name(self : rosetta.core.chemical.Patch, name : str) -> NoneType set_selector(...) from builtins.PyCapsule set_selector(self : rosetta.core.chemical.Patch, selector : rosetta.core.chemical.ResidueTypeSelector) -> NoneType types(...) from builtins.PyCapsule types(*args, **kwargs) Overloaded function.   1. types(rosetta.core.chemical.Patch) -> rosetta.utility.vector1_std_string   the variant types created by applying this patch   2. types(self : rosetta.core.chemical.Patch, types : rosetta.utility.vector1_std_string) -> NoneType   class PatchCase(builtins.object)     A single case of a patch, eg proline Nterminus is a case of NtermProteinFull     Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_operation(...) from builtins.PyCapsule add_operation(self : rosetta.core.chemical.PatchCase, operation : rosetta.core.chemical.PatchOperation) -> NoneType   add one more operation in this PatchCase adds_atoms(...) from builtins.PyCapsule adds_atoms(rosetta.core.chemical.PatchCase) -> rosetta.utility.vector1_std_string   returns list of added atom names, useful for identifying patches that go with PDB residues adds_properties(...) from builtins.PyCapsule adds_properties(rosetta.core.chemical.PatchCase) -> rosetta.utility.vector1_std_string   returns list of added property names, useful for identifying patches that go with PDB residues applies_to(...) from builtins.PyCapsule applies_to(self : rosetta.core.chemical.PatchCase, rsd : rosetta.core.chemical.ResidueType) -> bool   whether the PatchCase is applicable to this ResidueType? apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.chemical.PatchCase, rsd_in : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   returns patched residue, 0 if patch failed   2. apply(self : rosetta.core.chemical.PatchCase, rsd_in : rosetta.core.chemical.ResidueType, instantiate : bool) -> rosetta.core.chemical.ResidueType   returns patched residue, 0 if patch failed assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.PatchCase,  : rosetta.core.chemical.PatchCase) -> rosetta.core.chemical.PatchCase deletes_atoms(...) from builtins.PyCapsule deletes_atoms(rosetta.core.chemical.PatchCase) -> rosetta.utility.vector1_std_string   returns list of deleted atom names, useful for identifying patches that go with PDB residues deletes_properties(...) from builtins.PyCapsule deletes_properties(rosetta.core.chemical.PatchCase) -> rosetta.utility.vector1_std_string   returns list of deleted property names, useful for identifying patches that go with PDB residues deletes_variants(...) from builtins.PyCapsule deletes_variants(rosetta.core.chemical.PatchCase) -> rosetta.utility.vector1_std_string   returns list of deleted variant names, useful for identifying patches that go with PDB residues generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchCase) -> str   returns interchangeability group, if set. generates_new_name3(...) from builtins.PyCapsule generates_new_name3(rosetta.core.chemical.PatchCase) -> str   returns new name3, if changed may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchCase) -> bool selector(...) from builtins.PyCapsule selector(rosetta.core.chemical.PatchCase) -> rosetta.core.chemical.ResidueTypeSelector   to which ResidueTypes this PatchCase applies to? set_selector(...) from builtins.PyCapsule set_selector(self : rosetta.core.chemical.PatchCase, selector : rosetta.core.chemical.ResidueTypeSelector) -> NoneType   class PatchOperation(builtins.object)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     A single operation that needs to be applied in a residue patch     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.PatchOperation, rosetta.core.chemical.PatchOperation) -> NoneType   2. __init__(rosetta.core.chemical.PatchOperation) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.PatchOperation, rsd : core::chemical::ResidueType) -> bool   Returns true to signal failure, false to indicate success. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.PatchOperation,  : rosetta.core.chemical.PatchOperation) -> rosetta.core.chemical.PatchOperation deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class PolarHydrogenFilter(builtins.object)     The filter responsible for all polar hydrogens.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.PolarHydrogenFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.PolarHydrogenFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.PolarHydrogenFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>, atom_types : rosetta.std.weak_ptr_const_core_chemical_AtomTypeSet_t) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.PolarHydrogenFilter,  : rosetta.core.chemical.PolarHydrogenFilter) -> rosetta.core.chemical.PolarHydrogenFilter   class PrependMainchainAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     add a mainchain atom before the first mainchain atom     Method resolution order: PrependMainchainAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.PrependMainchainAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.PrependMainchainAtom, rsd : core::chemical::ResidueType) -> bool   set an atom to be the first mainchain atom assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.PrependMainchainAtom,  : rosetta.core.chemical.PrependMainchainAtom) -> rosetta.core.chemical.PrependMainchainAtom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class RealFilter(builtins.object)     A filtered graph that doesn't contain fake/virtual atoms and fake/virtual bonds.     Methods defined here: __call__(...) from builtins.PyCapsule __call__(self : rosetta.core.chemical.RealFilter, capsule) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.RealFilter) -> NoneType   2. __init__(self : rosetta.core.chemical.RealFilter, graph : boost::undirected_graph<core::chemical::Atom, core::chemical::Bond, boost::no_property>) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.RealFilter,  : rosetta.core.chemical.RealFilter) -> rosetta.core.chemical.RealFilter   class RedefineChi(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Redefine a chi angle    Added by Andy M. Chen in June 2009    This is needed for certain PTMs     Method resolution order: RedefineChi PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, chino_in : int, atom1_in : str, atom2_in : str, atom3_in : str, atom4_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.RedefineChi) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.RedefineChi, rsd : core::chemical::ResidueType) -> bool   redefine a chi angle assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.RedefineChi,  : rosetta.core.chemical.RedefineChi) -> rosetta.core.chemical.RedefineChi Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceMainchainAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace a mainchain atom     Method resolution order: ReplaceMainchainAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, target : str, new_atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceMainchainAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceMainchainAtom, rsd : core::chemical::ResidueType) -> bool   set an atom to be the last mainchain atom assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceMainchainAtom,  : rosetta.core.chemical.ReplaceMainchainAtom) -> rosetta.core.chemical.ReplaceMainchainAtom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithBromine(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with bromine     Method resolution order: ReplaceProtonWithBromine PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithBromine) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithBromine, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithBromine,  : rosetta.core.chemical.ReplaceProtonWithBromine) -> rosetta.core.chemical.ReplaceProtonWithBromine Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithChlorine(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with chlorine     Method resolution order: ReplaceProtonWithChlorine PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithChlorine) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithChlorine, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithChlorine,  : rosetta.core.chemical.ReplaceProtonWithChlorine) -> rosetta.core.chemical.ReplaceProtonWithChlorine Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithEthyl(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with methyl     Method resolution order: ReplaceProtonWithEthyl PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithEthyl) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithEthyl, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithEthyl,  : rosetta.core.chemical.ReplaceProtonWithEthyl) -> rosetta.core.chemical.ReplaceProtonWithEthyl Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithFluorine(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with fluorine     Method resolution order: ReplaceProtonWithFluorine PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithFluorine) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithFluorine, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithFluorine,  : rosetta.core.chemical.ReplaceProtonWithFluorine) -> rosetta.core.chemical.ReplaceProtonWithFluorine Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithHydroxyl(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with hydroxyl     Method resolution order: ReplaceProtonWithHydroxyl PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithHydroxyl) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithHydroxyl, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithHydroxyl,  : rosetta.core.chemical.ReplaceProtonWithHydroxyl) -> rosetta.core.chemical.ReplaceProtonWithHydroxyl Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithIodine(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with iodine     Method resolution order: ReplaceProtonWithIodine PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithIodine) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithIodine, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithIodine,  : rosetta.core.chemical.ReplaceProtonWithIodine) -> rosetta.core.chemical.ReplaceProtonWithIodine Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithMethoxy(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with methyl     Method resolution order: ReplaceProtonWithMethoxy PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithMethoxy) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithMethoxy, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithMethoxy,  : rosetta.core.chemical.ReplaceProtonWithMethoxy) -> rosetta.core.chemical.ReplaceProtonWithMethoxy Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithMethyl(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with methyl     Method resolution order: ReplaceProtonWithMethyl PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithMethyl) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithMethyl, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithMethyl,  : rosetta.core.chemical.ReplaceProtonWithMethyl) -> rosetta.core.chemical.ReplaceProtonWithMethyl Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ReplaceProtonWithTrifluoromethyl(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     replace proton with trifluoromethyl     Method resolution order: ReplaceProtonWithTrifluoromethyl PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.ReplaceProtonWithTrifluoromethyl) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ReplaceProtonWithTrifluoromethyl, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ReplaceProtonWithTrifluoromethyl,  : rosetta.core.chemical.ReplaceProtonWithTrifluoromethyl) -> rosetta.core.chemical.ReplaceProtonWithTrifluoromethyl Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ResConnID(builtins.object)     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.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.ResConnID) -> NoneType   2. __init__(self : rosetta.core.chemical.ResConnID,  : rosetta.core.chemical.ResConnID) -> NoneType   3. __init__(self : rosetta.core.chemical.ResConnID, resid : int, connid : int) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResConnID,  : rosetta.core.chemical.ResConnID) -> rosetta.core.chemical.ResConnID connid(...) from builtins.PyCapsule connid(*args, **kwargs) Overloaded function.   1. connid(rosetta.core.chemical.ResConnID) -> int   2. connid(self : rosetta.core.chemical.ResConnID,  : int) -> NoneType incomplete(...) from builtins.PyCapsule incomplete(rosetta.core.chemical.ResConnID) -> bool mark_incomplete(...) from builtins.PyCapsule mark_incomplete(rosetta.core.chemical.ResConnID) -> NoneType resid(...) from builtins.PyCapsule resid(*args, **kwargs) Overloaded function.   1. resid(rosetta.core.chemical.ResConnID) -> int   2. resid(self : rosetta.core.chemical.ResConnID,  : int) -> NoneType   class ResetBondLength(PatchOperation)     ////////////////////////////////////////////////////////////////////////////      A patch operation for resetting the length of a bond within a ResidueType.       This is useful for when an atom is rehybridized within a patch file.     Labonte <JWLabonte.edu>     Method resolution order: ResetBondLength PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atm_in : str, d_in : float) -> NoneType   2. __init__(handle, rosetta.core.chemical.ResetBondLength) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.ResetBondLength, rsd : core::chemical::ResidueType) -> bool   Apply this patch to the given ResidueType. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResetBondLength,  : rosetta.core.chemical.ResetBondLength) -> rosetta.core.chemical.ResetBondLength Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class ResidueConnection(builtins.object)     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.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.ResidueConnection) -> NoneType   2. __init__(self : rosetta.core.chemical.ResidueConnection, atomno_in : int, capsule) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. atomno(...) from builtins.PyCapsule atomno(*args, **kwargs) Overloaded function.   1. atomno(rosetta.core.chemical.ResidueConnection) -> int   get atom index number   2. atomno(self : rosetta.core.chemical.ResidueConnection, atomno_in : int) -> NoneType   set atom index number icoor(...) from builtins.PyCapsule icoor(*args, **kwargs) Overloaded function.   1. icoor(rosetta.core.chemical.ResidueConnection) -> rosetta.core.chemical.AtomICoor   get atom's AtomICoor   2. icoor(self : rosetta.core.chemical.ResidueConnection, ic : rosetta.core.chemical.AtomICoor) -> NoneType   set atom's AtomICoor index(...) from builtins.PyCapsule index(*args, **kwargs) Overloaded function.   1. index(rosetta.core.chemical.ResidueConnection) -> int   2. index(self : rosetta.core.chemical.ResidueConnection, index_in : int) -> NoneType vertex(...) from builtins.PyCapsule vertex(*args, **kwargs) Overloaded function.   1. vertex(rosetta.core.chemical.ResidueConnection) -> capsule   get the vetex associated with this residue connection   2. vertex(self : rosetta.core.chemical.ResidueConnection, capsule) -> NoneType   set the vertex of this residue connection   class ResidueDatabaseIO(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.chemical.ResidueDatabaseIO) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueDatabaseIO,  : rosetta.core.chemical.ResidueDatabaseIO) -> rosetta.core.chemical.ResidueDatabaseIO get_all_residues_in_database(...) from builtins.PyCapsule get_all_residues_in_database(self : rosetta.core.chemical.ResidueDatabaseIO, db_session : rosetta.utility.sql_database.session) -> rosetta.utility.vector1_std_string get_version(...) from builtins.PyCapsule get_version(rosetta.core.chemical.ResidueDatabaseIO) -> float initialize(...) from builtins.PyCapsule initialize(self : rosetta.core.chemical.ResidueDatabaseIO, db_session : rosetta.utility.sql_database.session) -> NoneType   write the schema read_residuetype_from_database(...) from builtins.PyCapsule read_residuetype_from_database(self : rosetta.core.chemical.ResidueDatabaseIO, atom_types : rosetta.core.chemical.AtomTypeSet, elements : rosetta.core.chemical.ElementSet, mm_atom_types : rosetta.core.chemical.MMAtomTypeSet, orbital_atom_types : core::chemical::orbitals::OrbitalTypeSet, residue_type_set_name : str, residue_type_name : str, db_session : rosetta.utility.sql_database.session) -> rosetta.core.chemical.ResidueType write_residuetype_to_database(...) from builtins.PyCapsule write_residuetype_to_database(self : rosetta.core.chemical.ResidueDatabaseIO, residue_type_set_name : str, res_type : rosetta.core.chemical.ResidueType, db_session : rosetta.utility.sql_database.session) -> NoneType write_schema_to_db(...) from builtins.PyCapsule write_schema_to_db(self : rosetta.core.chemical.ResidueDatabaseIO, db_session : rosetta.utility.sql_database.session) -> NoneType   generate the table schemas and write them to the database   class ResidueLoader(rosetta.basic.resource_manager.ResourceLoader)       Method resolution order: ResidueLoader rosetta.basic.resource_manager.ResourceLoader builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueLoader,  : rosetta.core.chemical.ResidueLoader) -> rosetta.core.chemical.ResidueLoader default_options(...) from builtins.PyCapsule default_options(rosetta.core.chemical.ResidueLoader) -> rosetta.basic.resource_manager.ResourceOptions   class ResidueLoaderCreator(rosetta.basic.resource_manager.ResourceLoaderCreator)       Method resolution order: ResidueLoaderCreator rosetta.basic.resource_manager.ResourceLoaderCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueLoaderCreator,  : rosetta.core.chemical.ResidueLoaderCreator) -> rosetta.core.chemical.ResidueLoaderCreator create_resource_loader(...) from builtins.PyCapsule create_resource_loader(rosetta.core.chemical.ResidueLoaderCreator) -> rosetta.basic.resource_manager.ResourceLoader loader_type(...) from builtins.PyCapsule loader_type(rosetta.core.chemical.ResidueLoaderCreator) -> str   class ResidueLoaderOptions(rosetta.basic.resource_manager.ResourceOptions)       Method resolution order: ResidueLoaderOptions rosetta.basic.resource_manager.ResourceOptions builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.chemical.ResidueLoaderOptions) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueLoaderOptions,  : rosetta.core.chemical.ResidueLoaderOptions) -> rosetta.core.chemical.ResidueLoaderOptions atom_type_set_tag(...) from builtins.PyCapsule atom_type_set_tag(rosetta.core.chemical.ResidueLoaderOptions) -> str element_set_tag(...) from builtins.PyCapsule element_set_tag(rosetta.core.chemical.ResidueLoaderOptions) -> str mm_atom_type_set_tag(...) from builtins.PyCapsule mm_atom_type_set_tag(rosetta.core.chemical.ResidueLoaderOptions) -> str orbital_set_tag(...) from builtins.PyCapsule orbital_set_tag(rosetta.core.chemical.ResidueLoaderOptions) -> str parse_my_tag(...) from builtins.PyCapsule parse_my_tag(self : rosetta.core.chemical.ResidueLoaderOptions, tag : utility::tag::Tag) -> NoneType residue_type_set_tag(...) from builtins.PyCapsule residue_type_set_tag(rosetta.core.chemical.ResidueLoaderOptions) -> str type(...) from builtins.PyCapsule type(rosetta.core.chemical.ResidueLoaderOptions) -> str Methods inherited from rosetta.basic.resource_manager.ResourceOptions: __str__(...) from builtins.PyCapsule __str__(rosetta.basic.resource_manager.ResourceOptions) -> str name(...) from builtins.PyCapsule name(*args, **kwargs) Overloaded function.   1. name(rosetta.basic.resource_manager.ResourceOptions) -> str   A name given to a particular ResourceOptions instance.  This function allows for better error message delivery.   2. name(self : rosetta.basic.resource_manager.ResourceOptions, setting : str) -> NoneType   Set the name for this %ResoureOptions instance.   class ResidueLoaderOptionsCreator(rosetta.basic.resource_manager.ResourceOptionsCreator)       Method resolution order: ResidueLoaderOptionsCreator rosetta.basic.resource_manager.ResourceOptionsCreator builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueLoaderOptionsCreator,  : rosetta.core.chemical.ResidueLoaderOptionsCreator) -> rosetta.core.chemical.ResidueLoaderOptionsCreator create_options(...) from builtins.PyCapsule create_options(rosetta.core.chemical.ResidueLoaderOptionsCreator) -> rosetta.basic.resource_manager.ResourceOptions options_type(...) from builtins.PyCapsule options_type(rosetta.core.chemical.ResidueLoaderOptionsCreator) -> str   class ResidueProperties(builtins.object)     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.     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     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, residue_type : rosetta.core.chemical.ResidueType) -> NoneType   2. __init__(self : handle, object_to_copy : rosetta.core.chemical.ResidueProperties, new_owner : rosetta.core.chemical.ResidueType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.ResidueProperties) -> str add_numeric_property(...) from builtins.PyCapsule add_numeric_property(self : rosetta.core.chemical.ResidueProperties, tag : str, value : float) -> NoneType   Add a numeric property. add_string_property(...) from builtins.PyCapsule add_string_property(self : rosetta.core.chemical.ResidueProperties, tag : str, value : str) -> NoneType   Add a string property. enable_custom_variant_types(...) from builtins.PyCapsule enable_custom_variant_types(rosetta.core.chemical.ResidueProperties) -> NoneType   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. get_list_of_custom_variants(...) from builtins.PyCapsule get_list_of_custom_variants(rosetta.core.chemical.ResidueProperties) -> rosetta.utility.vector1_std_string   Return a list of custom VariantTypes only for this ResidueType. get_list_of_custom_variants_by_reference(...) from builtins.PyCapsule get_list_of_custom_variants_by_reference(rosetta.core.chemical.ResidueProperties) -> rosetta.utility.vector1_std_string   Get a const-access reference to the list of custom VariantType strings for this ResidueType.      This will not include enum-based standard variants.      Vikram K. Mulligan (vmullig.edu) get_list_of_properties(...) from builtins.PyCapsule get_list_of_properties(rosetta.core.chemical.ResidueProperties) -> rosetta.utility.vector1_std_string   Generate and return a list of strings representing the properties of this ResidueType. get_list_of_variant_enums(...) from builtins.PyCapsule get_list_of_variant_enums(rosetta.core.chemical.ResidueProperties) -> rosetta.utility.vector1_core_chemical_VariantType   Return a list of VariantType enums for this ResidueType.      This will not include custom, string-based variant types generated on the fly.      Vikram K. Mulligan (vmullig.edu) get_list_of_variants(...) from builtins.PyCapsule get_list_of_variants(rosetta.core.chemical.ResidueProperties) -> rosetta.utility.vector1_std_string   Generate and return a list of strings representing the VariantTypes of this ResidueType.      This will include both custom, string-based variants made on-the-fly AND the standard  variants that are enumerated. get_property_from_string(...) from builtins.PyCapsule get_property_from_string(property : str) -> rosetta.core.chemical.ResidueProperty   Static constant data access      Get the ResidueProperty enum value from the corresponding string.  This private static class method is defined in ResidueProperty_mappings.cc,  which is auto-generated by the add_ResidueType_enum_files.py script.  Note -- made public because it's a handy function for other code to use (VKM, 22 July 2015). get_string_from_property(...) from builtins.PyCapsule get_string_from_property(property : rosetta.core.chemical.ResidueProperty) -> str   Get a string from the corresponding ResidueProperty enum value.      This private static class method is defined in ResidueProperty_mappings.cc,  which is auto-generated by the add_ResidueType_enum_files.py script.  Note -- made public because it's a handy function for other code to use (VKM, 22 July 2015). get_string_from_variant(...) from builtins.PyCapsule get_string_from_variant(variant : rosetta.core.chemical.VariantType) -> str get_variant_from_string(...) from builtins.PyCapsule get_variant_from_string(variant : str) -> rosetta.core.chemical.VariantType has_custom_variant_types(...) from builtins.PyCapsule has_custom_variant_types(rosetta.core.chemical.ResidueProperties) -> bool   Does this ResidueType contain additional VariantTypes than the standard list? has_property(...) from builtins.PyCapsule has_property(*args, **kwargs) Overloaded function.   1. has_property(self : rosetta.core.chemical.ResidueProperties, property : rosetta.core.chemical.ResidueProperty) -> bool   Get whether or not this ResidueType has the requested property.   2. has_property(self : rosetta.core.chemical.ResidueProperties, property : str) -> bool   Get whether or not this ResidueType has the requested property by string. is_variant_type(...) from builtins.PyCapsule is_variant_type(*args, **kwargs) Overloaded function.   1. is_variant_type(self : rosetta.core.chemical.ResidueProperties, variant_type : rosetta.core.chemical.VariantType) -> bool   Get whether or not this ResidueType is of the requested VariantType.   2. is_variant_type(self : rosetta.core.chemical.ResidueProperties, variant_type : str) -> bool   Get whether or not this ResidueType is of the requested VariantType by string. numeric_properties(...) from builtins.PyCapsule numeric_properties(rosetta.core.chemical.ResidueProperties) -> rosetta.std.map_std_string_double set_property(...) from builtins.PyCapsule set_property(*args, **kwargs) Overloaded function.   1. set_property(self : rosetta.core.chemical.ResidueProperties, property : rosetta.core.chemical.ResidueProperty, setting : bool) -> NoneType   Set the status of the given property for this ResidueType.   2. set_property(self : rosetta.core.chemical.ResidueProperties, property : str, setting : bool) -> NoneType   Set the status of the given property for this ResidueType by string. set_variant_type(...) from builtins.PyCapsule set_variant_type(*args, **kwargs) Overloaded function.   1. set_variant_type(self : rosetta.core.chemical.ResidueProperties, variant_type : rosetta.core.chemical.VariantType, setting : bool) -> NoneType   Set the status of a given VariantType for this ResidueType.   2. set_variant_type(self : rosetta.core.chemical.ResidueProperties, variant_type : str, setting : bool) -> NoneType   Set the status of a given VariantType for this ResidueType by string. string_properties(...) from builtins.PyCapsule string_properties(rosetta.core.chemical.ResidueProperties) -> rosetta.std.map_std_string_std_string   class ResidueProperty(builtins.object)     Enumerators for all the properties that can be assigned to a ResidueType.     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.ResidueProperty, rosetta.core.chemical.ResidueProperty) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.ResidueProperty) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.ResidueProperty, int) -> NoneType   2. __init__(rosetta.core.chemical.ResidueProperty, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.ResidueProperty) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.ResidueProperty, rosetta.core.chemical.ResidueProperty) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.ResidueProperty) -> str Data and other attributes defined here: ACETYLAMINO_SUGAR = ResidueProperty.ACETYLAMINO_SUGAR ACETYLATED_NTERMINUS = ResidueProperty.ACETYLATED_NTERMINUS ACETYL_SUGAR = ResidueProperty.ACETYL_SUGAR ACHIRAL_BACKBONE = ResidueProperty.ACHIRAL_BACKBONE ADDUCT = ResidueProperty.ADDUCT ALDONIC_ACID = ResidueProperty.ALDONIC_ACID ALDOSE = ResidueProperty.ALDOSE ALIPHATIC = ResidueProperty.ALIPHATIC ALPHA_AA = ResidueProperty.ALPHA_AA ALPHA_SUGAR = ResidueProperty.ALPHA_SUGAR AMINO_SUGAR = ResidueProperty.AMINO_SUGAR AROMATIC = ResidueProperty.AROMATIC BETA_AA = ResidueProperty.BETA_AA BETA_SUGAR = ResidueProperty.BETA_SUGAR BRANCH_LOWER_TERMINUS = ResidueProperty.BRANCH_LOWER_TERMINUS BRANCH_POINT = ResidueProperty.BRANCH_POINT C1_MODIFIED = ResidueProperty.C1_MODIFIED C2_MODIFIED = ResidueProperty.C2_MODIFIED C3_MODIFIED = ResidueProperty.C3_MODIFIED C4_MODIFIED = ResidueProperty.C4_MODIFIED C5_MODIFIED = ResidueProperty.C5_MODIFIED C6_MODIFIED = ResidueProperty.C6_MODIFIED C7_MODIFIED = ResidueProperty.C7_MODIFIED C8_MODIFIED = ResidueProperty.C8_MODIFIED C9_MODIFIED = ResidueProperty.C9_MODIFIED CANONICAL_AA = ResidueProperty.CANONICAL_AA CANONICAL_NUCLEIC = ResidueProperty.CANONICAL_NUCLEIC CARBOHYDRATE = ResidueProperty.CARBOHYDRATE CHARGED = ResidueProperty.CHARGED COARSE = ResidueProperty.COARSE CYCLIC = ResidueProperty.CYCLIC C_METHYLATED_SUGAR = ResidueProperty.C_METHYLATED_SUGAR DEOXY_SUGAR = ResidueProperty.DEOXY_SUGAR DISULFIDE_BONDED = ResidueProperty.DISULFIDE_BONDED DNA = ResidueProperty.DNA D_AA = ResidueProperty.D_AA D_SUGAR = ResidueProperty.D_SUGAR ELECTROPHILE = ResidueProperty.ELECTROPHILE FIRST_PROPERTY = ResidueProperty.POLYMER FRAGMENT = ResidueProperty.FRAGMENT FURANOSE = ResidueProperty.FURANOSE GAMMA_AA = ResidueProperty.GAMMA_AA GLYCOSIDE = ResidueProperty.GLYCOSIDE HEPTOSE = ResidueProperty.HEPTOSE HEXOSE = ResidueProperty.HEXOSE HYDROPHOBIC = ResidueProperty.HYDROPHOBIC INVERTED_VIRTUAL_RESIDUE = ResidueProperty.INVERTED_VIRTUAL_RESIDUE KETOSE = ResidueProperty.KETOSE LIGAND = ResidueProperty.LIGAND LIPID = ResidueProperty.LIPID LOWERTERM_CAP = ResidueProperty.LOWERTERM_CAP LOWERTERM_TRUNC = ResidueProperty.LOWERTERM_TRUNC LOWER_TERMINUS = ResidueProperty.LOWER_TERMINUS L_AA = ResidueProperty.L_AA L_SUGAR = ResidueProperty.L_SUGAR MEMBRANE = ResidueProperty.MEMBRANE METAL = ResidueProperty.METAL METALBINDING = ResidueProperty.METALBINDING METHYLATED_CTERMINUS = ResidueProperty.METHYLATED_CTERMINUS NEGATIVE_CHARGE = ResidueProperty.NEGATIVE_CHARGE NONOSE = ResidueProperty.NONOSE NO_PROPERTY = ResidueProperty.NO_PROPERTY N_PROPERTIES = ResidueProperty.N_PROPERTIES OCTOSE = ResidueProperty.OCTOSE OXETOSE = ResidueProperty.OXETOSE OXIROSE = ResidueProperty.OXIROSE PENTOSE = ResidueProperty.PENTOSE PEPTOID = ResidueProperty.PEPTOID PHOSPHATE = ResidueProperty.N_PROPERTIES PHOSPHONATE = ResidueProperty.PHOSPHONATE PHOSPHONATE_UPPER = ResidueProperty.PHOSPHONATE_UPPER PNA = ResidueProperty.PNA POLAR = ResidueProperty.POLAR POLYMER = ResidueProperty.POLYMER POSITIVE_CHARGE = ResidueProperty.POSITIVE_CHARGE PROTEIN = ResidueProperty.PROTEIN PYRANOSE = ResidueProperty.PYRANOSE R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = ResidueProperty.R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR RNA = ResidueProperty.RNA SC_ORBITALS = ResidueProperty.SC_ORBITALS SEPTANOSE = ResidueProperty.SEPTANOSE SIALIC_ACID = ResidueProperty.SIALIC_ACID SIDECHAIN_AMINE = ResidueProperty.SIDECHAIN_AMINE SIDECHAIN_THIOL = ResidueProperty.SIDECHAIN_THIOL SOLVENT = ResidueProperty.SOLVENT SRI = ResidueProperty.SRI SULFATED_SUGAR = ResidueProperty.SULFATED_SUGAR SULFOAMINO_SUGAR = ResidueProperty.SULFOAMINO_SUGAR SURFACE = ResidueProperty.SURFACE TAUTOMER = ResidueProperty.TAUTOMER TERMINUS = ResidueProperty.TERMINUS TETROSE = ResidueProperty.TETROSE TRIAZOLE_LINKER = ResidueProperty.TRIAZOLE_LINKER TRIOSE = ResidueProperty.TRIOSE UPPERTERM_CAP = ResidueProperty.UPPERTERM_CAP UPPERTERM_TRUNC = ResidueProperty.UPPERTERM_TRUNC UPPER_TERMINUS = ResidueProperty.UPPER_TERMINUS URONIC_ACID = ResidueProperty.URONIC_ACID VIRTUAL_RESIDUE = ResidueProperty.VIRTUAL_RESIDUE WATER = ResidueProperty.WATER   class ResidueType(builtins.object)     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_; ring_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.     Methods defined here: Haro_index(...) from builtins.PyCapsule Haro_index(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   return indices of aromatic Hydrogens Hpol_index(...) from builtins.PyCapsule Hpol_index(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   return indices of polar Hydrogens Hpos_apolar(...) from builtins.PyCapsule Hpos_apolar(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   indices of non-polar hydrogens as potential carbon Hbond donors Hpos_polar(...) from builtins.PyCapsule Hpos_polar(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   indices of polar hydrogens as Hbond donors Hpos_polar_sc(...) from builtins.PyCapsule Hpos_polar_sc(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long RNA_type(...) from builtins.PyCapsule RNA_type(rosetta.core.chemical.ResidueType) -> core::chemical::rna::RNA_ResidueType   //////////////////////////////////////////////////////////// __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.chemical.ResidueType, atom_types : rosetta.core.chemical.AtomTypeSet, element_types : rosetta.core.chemical.ElementSet, mm_atom_types : rosetta.core.chemical.MMAtomTypeSet, orbital_types : core::chemical::orbitals::OrbitalTypeSet) -> NoneType   2. __init__(self : rosetta.core.chemical.ResidueType, residue_type : rosetta.core.chemical.ResidueType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.chemical.ResidueType) -> str aa(...) from builtins.PyCapsule aa(*args, **kwargs) Overloaded function.   1. aa(self : rosetta.core.chemical.ResidueType, type : rosetta.core.chemical.AA) -> NoneType   set our aa-type (could be "UNK")   2. aa(self : rosetta.core.chemical.ResidueType, type : str) -> NoneType   set our aa-type (could be "UNK")   3. aa(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.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. abase2(...) from builtins.PyCapsule abase2(self : rosetta.core.chemical.ResidueType, atomno : int) -> int   get index of an atom's second base atom accpt_pos(...) from builtins.PyCapsule accpt_pos(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   indices of atoms as Hbond acceptors accpt_pos_sc(...) from builtins.PyCapsule accpt_pos_sc(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   indices of atoms as Hbond acceptors actcoord_atoms(...) from builtins.PyCapsule actcoord_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   get indices for atoms used to define actcoord add_actcoord_atom(...) from builtins.PyCapsule add_actcoord_atom(self : rosetta.core.chemical.ResidueType, atom : str) -> NoneType   add an atom to the list for calculating actcoord center add_adduct(...) from builtins.PyCapsule add_adduct(self : rosetta.core.chemical.ResidueType, adduct_in : rosetta.core.chemical.Adduct) -> NoneType add_atom(...) from builtins.PyCapsule add_atom(*args, **kwargs) Overloaded function.   1. add_atom(self : rosetta.core.chemical.ResidueType, atom_name : str, atom_type_name : str, mm_atom_type_name : str, charge : float) -> capsule   add an atom into this residue  Will return the vertex descriptor of the added atom.   2. add_atom(rosetta.core.chemical.ResidueType) -> capsule   add an atom into this residue, with just the name.  Will return the vertex descriptor of the added atom.   3. add_atom(self : rosetta.core.chemical.ResidueType, atom_name : str) -> capsule   add an atom into this residue, with just the name.  Will return the vertex descriptor of the added atom.   4. add_atom(self : rosetta.core.chemical.ResidueType, atom : rosetta.core.chemical.Atom, icoor : rosetta.core.chemical.AtomICoor) -> capsule add_atom_alias(...) from builtins.PyCapsule add_atom_alias(self : rosetta.core.chemical.ResidueType, rosetta_atom : str, alias : str) -> NoneType   Add an alias name for an atom. add_bond(...) from builtins.PyCapsule add_bond(*args, **kwargs) Overloaded function.   1. add_bond(self : rosetta.core.chemical.ResidueType, atom_name1 : str, atom_name2 : str) -> NoneType   add a bond between atom1 and atom2, specifying a bond type (SingleBond, DoubleBond, TripleBond, AromaticBond)   2. add_bond(self : rosetta.core.chemical.ResidueType, atom_name1 : str, atom_name2 : str, bondLabel : rosetta.core.chemical.BondName) -> NoneType   add a bond between atom1 and atom2, specifying a bond type (SingleBond, DoubleBond, TripleBond, AromaticBond)   3. add_bond(self : rosetta.core.chemical.ResidueType, capsule, capsule) -> NoneType   add a bond between atom1 and atom2, specifying a bond type (SingleBond, DoubleBond, TripleBond, AromaticBond)   4. add_bond(self : rosetta.core.chemical.ResidueType, capsule, capsule, atom1 : rosetta.core.chemical.BondName) -> NoneType   add a bond between atom1 and atom2, specifying a bond type (SingleBond, DoubleBond, TripleBond, AromaticBond) add_chi(...) from builtins.PyCapsule add_chi(*args, **kwargs) Overloaded function.   1. add_chi(self : rosetta.core.chemical.ResidueType, chino : int, capsule, capsule, capsule, capsule) -> NoneType   Add a chi (side-chain) angle defined by four atoms.   2. add_chi(self : rosetta.core.chemical.ResidueType, capsule, capsule, capsule, capsule) -> NoneType   Add a chi (side-chain) angle defined by four atoms.   3. add_chi(self : rosetta.core.chemical.ResidueType, chino : int, atom_name1 : str, atom_name2 : str, atom_name3 : str, atom_name4 : str) -> NoneType   Add a chi (side-chain) angle defined by four atoms.   4. add_chi(self : rosetta.core.chemical.ResidueType, atom_name1 : str, atom_name2 : str, atom_name3 : str, atom_name4 : str) -> NoneType   Add a chi (side-chain) angle defined by four atoms to the end of the list of chis. add_chi_rotamer(...) from builtins.PyCapsule add_chi_rotamer(self : rosetta.core.chemical.ResidueType, chino : int, mean : float, sdev : float) -> NoneType   Add a rotamer bin for a given chi. add_chi_rotamer_to_last_chi(...) from builtins.PyCapsule add_chi_rotamer_to_last_chi(self : rosetta.core.chemical.ResidueType, mean : float, sdev : float) -> NoneType   Adds a chi rotamer bin to the highest-indexed chi in the list of chis for this ResidueType. add_cut_bond(...) from builtins.PyCapsule add_cut_bond(self : rosetta.core.chemical.ResidueType, atom_name1 : str, atom_name2 : str) -> NoneType   add a bond between atom1 and atom2, if bond type is not specified, default to a SingleBond add_metalbinding_atom(...) from builtins.PyCapsule add_metalbinding_atom(self : rosetta.core.chemical.ResidueType, atom_name : str) -> NoneType   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.edu) add_metapatch_connect(...) from builtins.PyCapsule add_metapatch_connect(self : rosetta.core.chemical.ResidueType, atom : str) -> NoneType add_nu(...) from builtins.PyCapsule add_nu(self : rosetta.core.chemical.ResidueType, nu_index : int, atom_name1 : str, atom_name2 : str, atom_name3 : str, atom_name4 : str) -> NoneType   Add a nu (internal cyclic) angle defined by four atoms. add_numeric_property(...) from builtins.PyCapsule add_numeric_property(self : rosetta.core.chemical.ResidueType, tag : str, value : float) -> NoneType   Add a numeric property. add_orbital(...) from builtins.PyCapsule add_orbital(self : rosetta.core.chemical.ResidueType, orbital_name : str, orbital_type_name : str) -> NoneType   add an orbital onto a residue based upon atom add_orbital_bond(...) from builtins.PyCapsule add_orbital_bond(self : rosetta.core.chemical.ResidueType, atom_name1 : str, orbital_name : str) -> NoneType   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. add_property(...) from builtins.PyCapsule add_property(self : rosetta.core.chemical.ResidueType, property : str) -> NoneType   Add a property to this ResidueType. add_residue_connection(...) from builtins.PyCapsule add_residue_connection(self : rosetta.core.chemical.ResidueType, atom_name : str) -> 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? add_ring(...) from builtins.PyCapsule add_ring(self : rosetta.core.chemical.ResidueType, ring_num : int, ring_atoms : rosetta.utility.vector1_std_string) -> NoneType   Add a ring definition. add_string_property(...) from builtins.PyCapsule add_string_property(self : rosetta.core.chemical.ResidueType, tag : str, value : str) -> NoneType   Add a string property. add_variant_type(...) from builtins.PyCapsule add_variant_type(*args, **kwargs) Overloaded function.   1. add_variant_type(self : rosetta.core.chemical.ResidueType, variant_type : rosetta.core.chemical.VariantType) -> NoneType   Add a variant type to this ResidueType.   2. add_variant_type(self : rosetta.core.chemical.ResidueType, variant_type : str) -> NoneType   Add a variant type to this ResidueType by string. all_bb_atoms(...) from builtins.PyCapsule all_bb_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   Indices of all backbone atoms, hydrogens and heavyatoms all_sc_atoms(...) from builtins.PyCapsule all_sc_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   Indices of all sidechain atoms, hydrogens and heavyatoms assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueType, src : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   Copies  <src>  into the ResidueType assign_internal_coordinates(...) from builtins.PyCapsule assign_internal_coordinates(*args, **kwargs) Overloaded function.   1. assign_internal_coordinates(rosetta.core.chemical.ResidueType) -> NoneType   Assign internal coordinates from the set ideal xyz coordinates.  Note that it currently does not obey mainchain designations or cut bonds.   2. assign_internal_coordinates(self : rosetta.core.chemical.ResidueType, capsule) -> NoneType   @ recursive function to assign internal coordinates  Note that it currently does not work well with polymers. assign_neighbor_atom(...) from builtins.PyCapsule assign_neighbor_atom(rosetta.core.chemical.ResidueType) -> NoneType atom(...) from builtins.PyCapsule atom(*args, **kwargs) Overloaded function.   1. atom(self : rosetta.core.chemical.ResidueType, atom_index : int) -> rosetta.core.chemical.Atom   2. atom(self : rosetta.core.chemical.ResidueType, atom_index : int) -> rosetta.core.chemical.Atom   3. atom(self : rosetta.core.chemical.ResidueType, atom_name : str) -> rosetta.core.chemical.Atom   4. atom(self : rosetta.core.chemical.ResidueType, atom_name : str) -> rosetta.core.chemical.Atom   5. atom(self : rosetta.core.chemical.ResidueType, capsule) -> rosetta.core.chemical.Atom   6. atom(self : rosetta.core.chemical.ResidueType, capsule) -> rosetta.core.chemical.Atom atom_base(...) from builtins.PyCapsule atom_base(*args, **kwargs) Overloaded function.   1. atom_base(self : rosetta.core.chemical.ResidueType, atomno : int) -> int   get index of an atom's base atom   2. atom_base(self : rosetta.core.chemical.ResidueType, capsule) -> capsule   get vd of an atom's base atom atom_being_shadowed(...) from builtins.PyCapsule atom_being_shadowed(self : rosetta.core.chemical.ResidueType, atom_shadowing : int) -> 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. atom_forms_residue_connection(...) from builtins.PyCapsule atom_forms_residue_connection(self : rosetta.core.chemical.ResidueType, atomid : int) -> bool   Does an atom form any inter-residue chemical bonds? atom_index(...) from builtins.PyCapsule atom_index(*args, **kwargs) Overloaded function.   1. atom_index(self : rosetta.core.chemical.ResidueType, name : str) -> int   get atom index by name   2. atom_index(self : rosetta.core.chemical.ResidueType, capsule) -> int   get atom index by vertex descriptor atom_is_backbone(...) from builtins.PyCapsule atom_is_backbone(self : rosetta.core.chemical.ResidueType, atomno : int) -> bool   is a backbone atom (heavy or hydrogen)? atom_is_hydrogen(...) from builtins.PyCapsule atom_is_hydrogen(self : rosetta.core.chemical.ResidueType, atomno : int) -> 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. atom_is_polar_hydrogen(...) from builtins.PyCapsule atom_is_polar_hydrogen(self : rosetta.core.chemical.ResidueType, atomno : int) -> bool atom_iterators(...) from builtins.PyCapsule atom_iterators(rosetta.core.chemical.ResidueType) -> (std::_List_iterator<void*>, std::_List_iterator<void*>) atom_name(...) from builtins.PyCapsule atom_name(*args, **kwargs) Overloaded function.   1. atom_name(self : rosetta.core.chemical.ResidueType, index : int) -> str   get atom name by index   2. atom_name(self : rosetta.core.chemical.ResidueType, capsule) -> str   get atom name by vertex descriptor atom_type(...) from builtins.PyCapsule atom_type(*args, **kwargs) Overloaded function.   1. atom_type(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.core.chemical.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   2. atom_type(self : rosetta.core.chemical.ResidueType, capsule) -> rosetta.core.chemical.AtomType   Get the chemical atom_type for this atom by it index number in this residue atom_type_set(...) from builtins.PyCapsule atom_type_set(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.AtomTypeSet   access by reference the atomset for which this residue is constructed atom_type_set_ptr(...) from builtins.PyCapsule atom_type_set_ptr(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.AtomTypeSet   access by const pointer the atomset for which this residue is constructed atom_vertex(...) from builtins.PyCapsule atom_vertex(*args, **kwargs) Overloaded function.   1. atom_vertex(self : rosetta.core.chemical.ResidueType, name : str) -> capsule   get the vertex descriptor from the name of the atom.   2. atom_vertex(self : rosetta.core.chemical.ResidueType, atomno : int) -> capsule   Get the vertex descriptor from the atom index. atoms_are_bonded(...) from builtins.PyCapsule atoms_are_bonded(self : rosetta.core.chemical.ResidueType, atomindex1 : int, atomindex2 : int) -> 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 atoms_last_controlled_by_chi(...) from builtins.PyCapsule atoms_last_controlled_by_chi(*args, **kwargs) Overloaded function.   1. atoms_last_controlled_by_chi(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t   Read access to the atoms_last_controlled_by_chi_ array   2. atoms_last_controlled_by_chi(self : rosetta.core.chemical.ResidueType, chi : int) -> rosetta.utility.vector1_unsigned_long   Read access to the Atoms last controlled by a particular chi atoms_with_orb_index(...) from builtins.PyCapsule atoms_with_orb_index(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long atoms_within_one_bond_of_a_residue_connection(...) from builtins.PyCapsule atoms_within_one_bond_of_a_residue_connection(self : rosetta.core.chemical.ResidueType, resconn : int) -> rosetta.utility.vector1_utility_keys_Key2Tuple_unsigned_long_unsigned_long_t   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. atoms_within_two_bonds_of_a_residue_connection(...) from builtins.PyCapsule atoms_within_two_bonds_of_a_residue_connection(self : rosetta.core.chemical.ResidueType, resconn : int) -> rosetta.utility.vector1_utility_keys_Key3Tuple_unsigned_long_unsigned_long_unsigned_long_t   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. attached_H_begin(...) from builtins.PyCapsule attached_H_begin(*args, **kwargs) Overloaded function.   1. attached_H_begin(self : rosetta.core.chemical.ResidueType, atom : int) -> int   index number of the first attached Hydrogen on an atom   2. attached_H_begin(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   for all heavy atoms, index numbers of their first attached Hydrogen attached_H_end(...) from builtins.PyCapsule attached_H_end(*args, **kwargs) Overloaded function.   1. attached_H_end(self : rosetta.core.chemical.ResidueType, atom : int) -> int   index number of the last attached Hydrogen on an atom   2. attached_H_end(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   for all heavy atoms, index numbers of their last attached Hydrogen autodetermine_chi_bonds(...) from builtins.PyCapsule autodetermine_chi_bonds(*args, **kwargs) Overloaded function.   1. autodetermine_chi_bonds(rosetta.core.chemical.ResidueType) -> NoneType   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.   2. autodetermine_chi_bonds(self : rosetta.core.chemical.ResidueType, max_proton_chi_samples : int) -> NoneType   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. backbone_aa(...) from builtins.PyCapsule backbone_aa(*args, **kwargs) Overloaded function.   1. backbone_aa(self : rosetta.core.chemical.ResidueType, type : str) -> NoneType   AA to use for backbone scoring   2. backbone_aa(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.AA   Returns the amino acid type to be used for backbone scoring (rama and p_aa_pp). base_name(...) from builtins.PyCapsule base_name(*args, **kwargs) Overloaded function.   1. base_name(rosetta.core.chemical.ResidueType) -> str   Get this ResidueType's base name (shared with other residue types with the same base type).   2. base_name(self : rosetta.core.chemical.ResidueType, base_name_in : str) -> NoneType   Set this ResidueType's base name (shared with other residue types with the same base type). bond(...) from builtins.PyCapsule bond(*args, **kwargs) Overloaded function.   1. bond(self : rosetta.core.chemical.ResidueType, atom1 : str, atom2 : str) -> rosetta.core.chemical.Bond   2. bond(self : rosetta.core.chemical.ResidueType, atom1 : str, atom2 : str) -> rosetta.core.chemical.Bond bondangle(...) from builtins.PyCapsule bondangle(self : rosetta.core.chemical.ResidueType, bondang : int) -> rosetta.utility.keys.Key3Tuple_unsigned_long_unsigned_long_unsigned_long_t   Return the indices for the set of atoms that define a particular  intraresidue angle bondangles_for_atom(...) from builtins.PyCapsule bondangles_for_atom(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.utility.vector1_unsigned_long   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. bonded_neighbor(...) from builtins.PyCapsule bonded_neighbor(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.utility.vector1_unsigned_long bonded_orbitals(...) from builtins.PyCapsule bonded_orbitals(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.utility.vector1_unsigned_long   indices of the orbitals bonded to an atom branch_connect_atom_names(...) from builtins.PyCapsule branch_connect_atom_names(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string   Return a list of names of atoms at non-polymer connections. branch_connect_atoms(...) from builtins.PyCapsule branch_connect_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   Return a list of indices of atoms at non-polymer connections. carbohydrate_info(...) from builtins.PyCapsule carbohydrate_info(rosetta.core.chemical.ResidueType) -> core::chemical::carbohydrates::CarbohydrateInfo   Return the CarbohydrateInfo object containing sugar-specific properties for this residue. change_bond_type(...) from builtins.PyCapsule change_bond_type(self : rosetta.core.chemical.ResidueType, atom_name1 : str, atom_name2 : str, old_bond_label : rosetta.core.chemical.BondName, new_bond_label : rosetta.core.chemical.BondName) -> NoneType   Change the bond type of the given bond from one type to another. chi_2_proton_chi(...) from builtins.PyCapsule chi_2_proton_chi(self : rosetta.core.chemical.ResidueType, chi_index : int) -> int chi_atom_vds(...) from builtins.PyCapsule chi_atom_vds(self : rosetta.core.chemical.ResidueType, chino : int) -> rosetta.utility.vector1_void_*   VDs of the atoms which are used to define a given chi angle (chino) chi_atoms(...) from builtins.PyCapsule chi_atoms(*args, **kwargs) Overloaded function.   1. chi_atoms(self : rosetta.core.chemical.ResidueType, chino : int) -> rosetta.utility.vector1_unsigned_long   indices of the atoms which are used to define a given chi angle (chino)   2. chi_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t   indices of the atoms which are used to define all the chi angles chi_rotamers(...) from builtins.PyCapsule chi_rotamers(self : rosetta.core.chemical.ResidueType, chino : int) -> rosetta.utility.vector1_std_pair_double_double_t   all rotamers bins (mean, std) for a given chi angle clear_chi_rotamers(...) from builtins.PyCapsule clear_chi_rotamers(self : rosetta.core.chemical.ResidueType, chi_no : int) -> NoneType   Delete all of the chi rotamer bins from the specified chi for this ResidueType. clear_orbitals(...) from builtins.PyCapsule clear_orbitals(rosetta.core.chemical.ResidueType) -> NoneType   clear orbitals clone(...) from builtins.PyCapsule clone(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   make a copy custom_variant_types(...) from builtins.PyCapsule custom_variant_types(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string   Get a list of custom VariantType strings for this ResidueType (by const reference).      This ONLY includes custom, on-the-fly variants, not standard variants.      Vikram K. Mulligan (vmullig.edu) cut_bond_neighbor(...) from builtins.PyCapsule cut_bond_neighbor(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.utility.vector1_unsigned_long   indices of the bonded neighbors for an atom debug_dump_icoor(...) from builtins.PyCapsule debug_dump_icoor(rosetta.core.chemical.ResidueType) -> NoneType   Dump out atomnames and icoor values defined_adducts(...) from builtins.PyCapsule defined_adducts(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_core_chemical_Adduct   get the adducts defined for this residue delete_act_coord_atom(...) from builtins.PyCapsule delete_act_coord_atom(self : rosetta.core.chemical.ResidueType, atom_name : str) -> NoneType   Remove an atom from the list of act coord atoms  (used in patching when it kills the valence that is thus used)      Andrew Watkins (amw579.edu) delete_atom(...) from builtins.PyCapsule delete_atom(*args, **kwargs) Overloaded function.   1. delete_atom(self : rosetta.core.chemical.ResidueType, name : str) -> NoneType   flag an atom for deletion by adding its index to the delete_atom_ list   2. delete_atom(self : rosetta.core.chemical.ResidueType, index : int) -> NoneType delete_atom_alias(...) from builtins.PyCapsule delete_atom_alias(self : rosetta.core.chemical.ResidueType, alias : str) -> NoneType   Remove a given alias name for an atom. delete_child_proton(...) from builtins.PyCapsule delete_child_proton(self : rosetta.core.chemical.ResidueType, atom : str) -> NoneType delete_metalbinding_atom(...) from builtins.PyCapsule delete_metalbinding_atom(self : rosetta.core.chemical.ResidueType, atom_name : str) -> NoneType   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.edu) delete_property(...) from builtins.PyCapsule delete_property(self : rosetta.core.chemical.ResidueType, property : str) -> NoneType   Add a property of this ResidueType. delete_terminal_chi(...) from builtins.PyCapsule delete_terminal_chi(rosetta.core.chemical.ResidueType) -> NoneType   delete terminal chi angle dihedral(...) from builtins.PyCapsule dihedral(self : rosetta.core.chemical.ResidueType, dihe : int) -> rosetta.utility.keys.Key4Tuple_unsigned_long_unsigned_long_unsigned_long_unsigned_long_t   Return the indices for the set of atoms that define a particular  intraresidue dihedral dihedrals_for_atom(...) from builtins.PyCapsule dihedrals_for_atom(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.utility.vector1_unsigned_long   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. dump_vd_info(...) from builtins.PyCapsule dump_vd_info(rosetta.core.chemical.ResidueType) -> NoneType element_set(...) from builtins.PyCapsule element_set(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ElementSet   access by reference the element set for which this residue is constructed element_set_ptr(...) from builtins.PyCapsule element_set_ptr(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ElementSet   access by const pointer the element set for which this residue is constructed enable_custom_variant_types(...) from builtins.PyCapsule enable_custom_variant_types(rosetta.core.chemical.ResidueType) -> NoneType   Turn on the ability to create VariantTypes "on-the-fly". fill_ideal_xyz_from_icoor(...) from builtins.PyCapsule fill_ideal_xyz_from_icoor(rosetta.core.chemical.ResidueType) -> NoneType finalize(...) from builtins.PyCapsule finalize(rosetta.core.chemical.ResidueType) -> NoneType   recalculate derived data, potentially reordering atom-indices finalized(...) from builtins.PyCapsule finalized(rosetta.core.chemical.ResidueType) -> bool   finalized? should always be true, except in very special case early in on-the-fly ResidueTypeSet. first_sidechain_atom(...) from builtins.PyCapsule first_sidechain_atom(rosetta.core.chemical.ResidueType) -> int   index of the first sidechain atom (heavy or hydrogen) first_sidechain_hydrogen(...) from builtins.PyCapsule first_sidechain_hydrogen(rosetta.core.chemical.ResidueType) -> int   index of the first sidehchain hydrogen force_nbr_atom_orient(...) from builtins.PyCapsule force_nbr_atom_orient(*args, **kwargs) Overloaded function.   1. force_nbr_atom_orient(self : rosetta.core.chemical.ResidueType, force_orient : bool) -> NoneType   Set force_nbr_atom_orient_, used to control orient atoms selected by select_orient_atoms   2. force_nbr_atom_orient(rosetta.core.chemical.ResidueType) -> bool   Return force_nbr_atom_orient_, used to control orient atoms selected by select_orient_atoms gasteiger_atom_type(...) from builtins.PyCapsule gasteiger_atom_type(self : rosetta.core.chemical.ResidueType, atomno : int) -> core::chemical::gasteiger::GasteigerAtomTypeData   Get the MM atom_type for this atom by its index number in this residue gasteiger_atom_typeset(...) from builtins.PyCapsule gasteiger_atom_typeset(rosetta.core.chemical.ResidueType) -> core::chemical::gasteiger::GasteigerAtomTypeSet get_base_type_cop(...) from builtins.PyCapsule get_base_type_cop(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   Get a pointer to this ResidueType's base ResidueType.      Returns the base_type_cop_ pointer if not null, self pointer if null. get_disulfide_atom_name(...) from builtins.PyCapsule get_disulfide_atom_name(rosetta.core.chemical.ResidueType) -> str   Gets disulfide atom name      Andrew M. Watkins (amw579.edu). get_metal_binding_atoms(...) from builtins.PyCapsule get_metal_binding_atoms(*args, **kwargs) Overloaded function.   1. get_metal_binding_atoms(self : rosetta.core.chemical.ResidueType, metal_binding_indices : rosetta.utility.vector1_unsigned_long) -> NoneType   Gets indices of all atoms that can form bonds to metals      Vikram K. Mulligan (vmullig.edu).   2. get_metal_binding_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string get_numeric_property(...) from builtins.PyCapsule get_numeric_property(self : rosetta.core.chemical.ResidueType, tag : str) -> float   Get a numeric property, if it exists. get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   self pointers   2. get_self_ptr(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType get_self_weak_ptr(...) from builtins.PyCapsule get_self_weak_ptr(*args, **kwargs) Overloaded function.   1. get_self_weak_ptr(rosetta.core.chemical.ResidueType) -> rosetta.std.weak_ptr_const_core_chemical_ResidueType_t   2. get_self_weak_ptr(rosetta.core.chemical.ResidueType) -> rosetta.std.weak_ptr_core_chemical_ResidueType_t get_string_property(...) from builtins.PyCapsule get_string_property(self : rosetta.core.chemical.ResidueType, tag : str) -> str   Get a string property, if it exists. has(...) from builtins.PyCapsule has(*args, **kwargs) Overloaded function.   1. has(self : rosetta.core.chemical.ResidueType, atom_name : str) -> bool   is this atom present in this residue?   2. has(self : rosetta.core.chemical.ResidueType, capsule) -> bool   is this vertex descriptor present in this residue? has_orbital(...) from builtins.PyCapsule has_orbital(self : rosetta.core.chemical.ResidueType, orbital_name : str) -> bool   is this orbital present in this residue? has_property(...) from builtins.PyCapsule has_property(*args, **kwargs) Overloaded function.   1. has_property(self : rosetta.core.chemical.ResidueType, property : str) -> bool   Generic property access.   2. has_property(self : rosetta.core.chemical.ResidueType, property : rosetta.core.chemical.ResidueProperty) -> bool   Generic property access, by ResidueProperty. has_sc_orbitals(...) from builtins.PyCapsule has_sc_orbitals(rosetta.core.chemical.ResidueType) -> bool   does this residue have sidechain orbitals? has_shadow_atoms(...) from builtins.PyCapsule has_shadow_atoms(rosetta.core.chemical.ResidueType) -> bool   Returns true if this residue has shadow atoms, false otherwise. has_variant_type(...) from builtins.PyCapsule has_variant_type(*args, **kwargs) Overloaded function.   1. has_variant_type(self : rosetta.core.chemical.ResidueType, variant_type : rosetta.core.chemical.VariantType) -> bool   Generic variant access.   2. has_variant_type(self : rosetta.core.chemical.ResidueType, variant_type : str) -> bool   Generic variant access by string. heavyatom_has_polar_hydrogens(...) from builtins.PyCapsule heavyatom_has_polar_hydrogens(self : rosetta.core.chemical.ResidueType, atomno : int) -> bool heavyatom_is_an_acceptor(...) from builtins.PyCapsule heavyatom_is_an_acceptor(self : rosetta.core.chemical.ResidueType, atomno : int) -> bool icoor(...) from builtins.PyCapsule icoor(*args, **kwargs) Overloaded function.   1. icoor(self : rosetta.core.chemical.ResidueType, atm : int) -> rosetta.core.chemical.AtomICoor   AtomICoord of an atom   2. icoor(self : rosetta.core.chemical.ResidueType, capsule) -> rosetta.core.chemical.AtomICoor   AtomICoord of an atom improper_dihedral(...) from builtins.PyCapsule improper_dihedral(self : rosetta.core.chemical.ResidueType, dihe : int) -> rosetta.utility.keys.Key4Tuple_unsigned_long_unsigned_long_unsigned_long_unsigned_long_t   Return the indices for the set of atoms that define a particular  intraresidue improper dihedral improper_dihedrals_for_atom(...) from builtins.PyCapsule improper_dihedrals_for_atom(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.utility.vector1_unsigned_long   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. in_residue_type_set(...) from builtins.PyCapsule in_residue_type_set(rosetta.core.chemical.ResidueType) -> bool interchangeability_group(...) from builtins.PyCapsule interchangeability_group(*args, **kwargs) Overloaded function.   1. interchangeability_group(rosetta.core.chemical.ResidueType) -> 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.   2. interchangeability_group(self : rosetta.core.chemical.ResidueType, setting : str) -> NoneType   set our interchangeability-group id is_DNA(...) from builtins.PyCapsule is_DNA(rosetta.core.chemical.ResidueType) -> bool   is DNA? is_NA(...) from builtins.PyCapsule is_NA(rosetta.core.chemical.ResidueType) -> bool   is Nucleic Acid? is_RNA(...) from builtins.PyCapsule is_RNA(rosetta.core.chemical.ResidueType) -> bool   is RNA? is_acetylated_nterminus(...) from builtins.PyCapsule is_acetylated_nterminus(rosetta.core.chemical.ResidueType) -> bool   is acetylated n terminus is_achiral_backbone(...) from builtins.PyCapsule is_achiral_backbone(rosetta.core.chemical.ResidueType) -> bool   is this an achiral backbone? is_adduct(...) from builtins.PyCapsule is_adduct(rosetta.core.chemical.ResidueType) -> bool   is an adduct-modified residue? is_alpha_aa(...) from builtins.PyCapsule is_alpha_aa(rosetta.core.chemical.ResidueType) -> bool   Is this an alpha-amino acid? is_aromatic(...) from builtins.PyCapsule is_aromatic(rosetta.core.chemical.ResidueType) -> bool   is aromatic? is_base_type(...) from builtins.PyCapsule is_base_type(rosetta.core.chemical.ResidueType) -> bool   Is this ResidueType a base type? is_beta_aa(...) from builtins.PyCapsule is_beta_aa(rosetta.core.chemical.ResidueType) -> bool   Is this a beta-amino acid? is_branch_lower_terminus(...) from builtins.PyCapsule is_branch_lower_terminus(rosetta.core.chemical.ResidueType) -> bool   is lower terminus of a branch? is_branch_point(...) from builtins.PyCapsule is_branch_point(rosetta.core.chemical.ResidueType) -> bool   is a branch-point residue? is_canonical(...) from builtins.PyCapsule is_canonical(rosetta.core.chemical.ResidueType) -> bool   Is this a canonical residue type (nucleic acid or amino acid)?      Calls is_canonical_aa() and is_canonical_nucleic().      Vikram K. Mulligan (vmullig.edu). is_canonical_aa(...) from builtins.PyCapsule is_canonical_aa(rosetta.core.chemical.ResidueType) -> bool   Is this a canonical amino acid (CANONICAL_AA property)?      Only the standard amino acid types (ACDEFGHIKLMNPQRSTVWY) are canonical.      Vikram K. Mulligan (vmullig.edu). is_canonical_nucleic(...) from builtins.PyCapsule is_canonical_nucleic(rosetta.core.chemical.ResidueType) -> bool   Is this a canonical nucleic acid (CANONICAL_NUCLEIC property)?      Only the standard nucliec acid types (dA, dC, dG, dT, A, C, G, U) are canonical.      Vikram K. Mulligan (vmullig.edu). is_carbohydrate(...) from builtins.PyCapsule is_carbohydrate(rosetta.core.chemical.ResidueType) -> bool   is carbohydrate? is_charged(...) from builtins.PyCapsule is_charged(rosetta.core.chemical.ResidueType) -> bool   is charged? is_coarse(...) from builtins.PyCapsule is_coarse(rosetta.core.chemical.ResidueType) -> bool   is coarse? is_cyclic(...) from builtins.PyCapsule is_cyclic(rosetta.core.chemical.ResidueType) -> bool   is cyclic? is_d_aa(...) from builtins.PyCapsule is_d_aa(rosetta.core.chemical.ResidueType) -> bool   is this a d-amino acid? is_disulfide_bonded(...) from builtins.PyCapsule is_disulfide_bonded(rosetta.core.chemical.ResidueType) -> bool   is disulfide? is_gamma_aa(...) from builtins.PyCapsule is_gamma_aa(rosetta.core.chemical.ResidueType) -> bool   Is this a gamma-amino acid? is_inverted_virtual_residue(...) from builtins.PyCapsule is_inverted_virtual_residue(rosetta.core.chemical.ResidueType) -> bool   Check if atom is an inverted virtual is_l_aa(...) from builtins.PyCapsule is_l_aa(rosetta.core.chemical.ResidueType) -> bool   is this an l-amino acid? is_ligand(...) from builtins.PyCapsule is_ligand(rosetta.core.chemical.ResidueType) -> bool   is ligand? is_lipid(...) from builtins.PyCapsule is_lipid(rosetta.core.chemical.ResidueType) -> bool   is lipid? is_lower_terminus(...) from builtins.PyCapsule is_lower_terminus(rosetta.core.chemical.ResidueType) -> bool   is lower terminus? is_membrane(...) from builtins.PyCapsule is_membrane(rosetta.core.chemical.ResidueType) -> bool   is membrane? is_metal(...) from builtins.PyCapsule is_metal(rosetta.core.chemical.ResidueType) -> bool   Return true if this residue type is a metal ion, false otherwise. is_metalbinding(...) from builtins.PyCapsule is_metalbinding(rosetta.core.chemical.ResidueType) -> 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. is_methylated_cterminus(...) from builtins.PyCapsule is_methylated_cterminus(rosetta.core.chemical.ResidueType) -> bool   is methylated c terminus is_peptoid(...) from builtins.PyCapsule is_peptoid(rosetta.core.chemical.ResidueType) -> bool   is peptoid? is_polar(...) from builtins.PyCapsule is_polar(rosetta.core.chemical.ResidueType) -> bool   is polar? is_polymer(...) from builtins.PyCapsule is_polymer(rosetta.core.chemical.ResidueType) -> bool   is polymer? is_protein(...) from builtins.PyCapsule is_protein(rosetta.core.chemical.ResidueType) -> bool   is protein? is_proton_chi(...) from builtins.PyCapsule is_proton_chi(self : rosetta.core.chemical.ResidueType, chino : int) -> bool   number of proton chis is_repulsive(...) from builtins.PyCapsule is_repulsive(self : rosetta.core.chemical.ResidueType, atomno : int) -> bool   Check if atom is repulsive. is_ring_atom(...) from builtins.PyCapsule is_ring_atom(self : rosetta.core.chemical.ResidueType, ring_num : int, atom_id : int) -> bool   Return whether this atom is in a particular ring is_sidechain_amine(...) from builtins.PyCapsule is_sidechain_amine(rosetta.core.chemical.ResidueType) -> bool   is sidechain amine? is_sidechain_thiol(...) from builtins.PyCapsule is_sidechain_thiol(rosetta.core.chemical.ResidueType) -> bool   is thiol? is_solvent(...) from builtins.PyCapsule is_solvent(rosetta.core.chemical.ResidueType) -> bool   Is this a solvent molecule (SOLVENT property)?      Vikram K. Mulligan (vmullig.edu). is_sri(...) from builtins.PyCapsule is_sri(rosetta.core.chemical.ResidueType) -> bool   Is this one of SRI's special heteropolymer building blocks? is_surface(...) from builtins.PyCapsule is_surface(rosetta.core.chemical.ResidueType) -> bool   is surface? (e.g. enamel) is_terminus(...) from builtins.PyCapsule is_terminus(rosetta.core.chemical.ResidueType) -> bool   is terminus? is_triazolemer(...) from builtins.PyCapsule is_triazolemer(rosetta.core.chemical.ResidueType) -> bool   Is this a triazolemer? is_upper_terminus(...) from builtins.PyCapsule is_upper_terminus(rosetta.core.chemical.ResidueType) -> bool   is upper terminus? is_virtual(...) from builtins.PyCapsule is_virtual(self : rosetta.core.chemical.ResidueType, atomno : int) -> bool   Check if atom is virtual. is_virtual_residue(...) from builtins.PyCapsule is_virtual_residue(rosetta.core.chemical.ResidueType) -> bool   Check if residue is 'VIRTUAL_RESIDUE' last_backbone_atom(...) from builtins.PyCapsule last_backbone_atom(rosetta.core.chemical.ResidueType) -> int   index of the last backbone heavy atom last_controlling_chi(...) from builtins.PyCapsule last_controlling_chi(*args, **kwargs) Overloaded function.   1. last_controlling_chi(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   Read access to the last_controlling_chi_ array   2. last_controlling_chi(self : rosetta.core.chemical.ResidueType, atomno : int) -> int   The last_controlling_chi for an atom.  0 if an atom is controlled by no chi. lower_connect(...) from builtins.PyCapsule lower_connect(rosetta.core.chemical.ResidueType) -> core::chemical::ResidueConnection lower_connect_atom(...) from builtins.PyCapsule lower_connect_atom(rosetta.core.chemical.ResidueType) -> int   index number of the atom which connects to the lower connection lower_connect_id(...) from builtins.PyCapsule lower_connect_id(rosetta.core.chemical.ResidueType) -> int mainchain_atom(...) from builtins.PyCapsule mainchain_atom(self : rosetta.core.chemical.ResidueType, atm : int) -> int   index of mainchain atom mainchain_atoms(...) from builtins.PyCapsule mainchain_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_unsigned_long   indices of all mainchain atoms mass(...) from builtins.PyCapsule mass(rosetta.core.chemical.ResidueType) -> float   get the molecular weight of this residue mm_atom_type(...) from builtins.PyCapsule mm_atom_type(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.core.chemical.MMAtomType   Get the MM atom_type for this atom by its index number in this residue mm_atom_types_ptr(...) from builtins.PyCapsule mm_atom_types_ptr(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.MMAtomTypeSet   Get the MM atom_type for this atom by its index number in this residue n_hbond_acceptors(...) from builtins.PyCapsule n_hbond_acceptors(rosetta.core.chemical.ResidueType) -> int   number of hbond_acceptors n_hbond_donors(...) from builtins.PyCapsule n_hbond_donors(rosetta.core.chemical.ResidueType) -> int   number of hbond_donors n_non_polymeric_residue_connections(...) from builtins.PyCapsule n_non_polymeric_residue_connections(rosetta.core.chemical.ResidueType) -> int n_nus(...) from builtins.PyCapsule n_nus(rosetta.core.chemical.ResidueType) -> int   Return number of nu (internal ring) angles. n_orbitals(...) from builtins.PyCapsule n_orbitals(rosetta.core.chemical.ResidueType) -> int   number of orbitals n_polymeric_residue_connections(...) from builtins.PyCapsule n_polymeric_residue_connections(rosetta.core.chemical.ResidueType) -> int n_possible_residue_connections(...) from builtins.PyCapsule n_possible_residue_connections(rosetta.core.chemical.ResidueType) -> int   number of ResidueConnections, counting polymeric residue connections n_proton_chi(...) from builtins.PyCapsule n_proton_chi(rosetta.core.chemical.ResidueType) -> int   number of proton chis n_residue_connections_for_atom(...) from builtins.PyCapsule n_residue_connections_for_atom(self : rosetta.core.chemical.ResidueType, atomid : int) -> int   How many inter-residue chemical bonds does a particular atom form? n_rings(...) from builtins.PyCapsule n_rings(rosetta.core.chemical.ResidueType) -> int   Return the number of rings in this residue. n_virtual_atoms(...) from builtins.PyCapsule n_virtual_atoms(rosetta.core.chemical.ResidueType) -> 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.edu) name(...) from builtins.PyCapsule name(*args, **kwargs) Overloaded function.   1. name(rosetta.core.chemical.ResidueType) -> str   get our (unique) residue name   2. name(self : rosetta.core.chemical.ResidueType, name_in : str) -> NoneType   set our (unique) residue name name1(...) from builtins.PyCapsule name1(*args, **kwargs) Overloaded function.   1. name1(rosetta.core.chemical.ResidueType) -> str   get our 1letter code.  This is set in the  ResidueType .params file through the IO_STRING  tag along with the name3 string.   2. name1(self : rosetta.core.chemical.ResidueType, code : str) -> NoneType   set our 1letter code name3(...) from builtins.PyCapsule name3(*args, **kwargs) Overloaded function.   1. name3(rosetta.core.chemical.ResidueType) -> str   get our 3letter code.  This is set in the  ResidueType .params file through the IO_STRING  tag along with the name1 string  NOTE: The "name3" is not necessarily three characters  long. e.g. Metal ions may be only two characters.      If you need three characters, the PDB convention  is to right pad.   2. name3(self : rosetta.core.chemical.ResidueType, name_in : str) -> NoneType   set our 3letter code natoms(...) from builtins.PyCapsule natoms(rosetta.core.chemical.ResidueType) -> int   number of atoms nbonds(...) from builtins.PyCapsule nbonds(*args, **kwargs) Overloaded function.   1. nbonds(rosetta.core.chemical.ResidueType) -> int   number of bonds   2. nbonds(self : rosetta.core.chemical.ResidueType, atom : int) -> int   number of bonds for given atom   3. nbonds(self : rosetta.core.chemical.ResidueType, capsule) -> int   number of bonds for given atom nbr_atom(...) from builtins.PyCapsule nbr_atom(*args, **kwargs) Overloaded function.   1. nbr_atom(self : rosetta.core.chemical.ResidueType, atom_name : str) -> NoneType   set nbr_atom used to define residue-level neighbors   2. nbr_atom(self : rosetta.core.chemical.ResidueType, capsule) -> NoneType   set nbr_atom used to define residue-level neighbors   3. nbr_atom(rosetta.core.chemical.ResidueType) -> int   get nbr_atom used to define residue-level neighbors nbr_radius(...) from builtins.PyCapsule nbr_radius(*args, **kwargs) Overloaded function.   1. nbr_radius(self : rosetta.core.chemical.ResidueType, radius : float) -> NoneType   set nbr_radius_ used to define residue-level neighbors   2. nbr_radius(rosetta.core.chemical.ResidueType) -> float   get nbr_radius_ used to define residue-level neighbors nbr_vertex(...) from builtins.PyCapsule nbr_vertex(rosetta.core.chemical.ResidueType) -> capsule   get VD  used to define residue-level neighbors nbrs(...) from builtins.PyCapsule nbrs(self : rosetta.core.chemical.ResidueType, atomno : int) -> rosetta.utility.vector1_unsigned_long   indices of the bonded neighbors for an atom, shortcut for bonded_neighbor(atomno) nchi(...) from builtins.PyCapsule nchi(rosetta.core.chemical.ResidueType) -> int   number of chi angles ndihe(...) from builtins.PyCapsule ndihe(rosetta.core.chemical.ResidueType) -> 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. new_orbital_icoor_data(...) from builtins.PyCapsule new_orbital_icoor_data(self : rosetta.core.chemical.ResidueType, orbital_index : int) -> core::chemical::orbitals::ICoorOrbitalData nheavyatoms(...) from builtins.PyCapsule nheavyatoms(rosetta.core.chemical.ResidueType) -> int   number of heavy atoms nondefault(...) from builtins.PyCapsule nondefault(self : rosetta.core.chemical.ResidueType, in : bool) -> NoneType nu_atoms(...) from builtins.PyCapsule nu_atoms(*args, **kwargs) Overloaded function.   1. nu_atoms(self : rosetta.core.chemical.ResidueType, nu_index : int) -> rosetta.utility.vector1_unsigned_long   Return indices of the atoms used to define a given nu (internal ring) angle.   2. nu_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t   Return list of indices of the atoms used to define all the nu (internal ring) angles. num_bondangles(...) from builtins.PyCapsule num_bondangles(rosetta.core.chemical.ResidueType) -> int   get number of intraresidue bond angles number_bonded_heavyatoms(...) from builtins.PyCapsule number_bonded_heavyatoms(self : rosetta.core.chemical.ResidueType, atomno : int) -> int   indicates how many heavyatom bonded neighbors an atom has number_bonded_hydrogens(...) from builtins.PyCapsule number_bonded_hydrogens(self : rosetta.core.chemical.ResidueType, atomno : int) -> int   indicates how many proton bonded neighbors an atom has orbital(...) from builtins.PyCapsule orbital(*args, **kwargs) Overloaded function.   1. orbital(self : rosetta.core.chemical.ResidueType, orbital_index : int) -> core::chemical::Orbital   2. orbital(self : rosetta.core.chemical.ResidueType, orbital_name : str) -> core::chemical::Orbital orbital_icoor_data(...) from builtins.PyCapsule orbital_icoor_data(self : rosetta.core.chemical.ResidueType, orbital_index : int) -> core::chemical::orbitals::ICoorOrbitalData orbital_index(...) from builtins.PyCapsule orbital_index(self : rosetta.core.chemical.ResidueType, name : str) -> int   get orbital index by name orbital_type(...) from builtins.PyCapsule orbital_type(self : rosetta.core.chemical.ResidueType, orbital_index : int) -> core::chemical::orbitals::OrbitalType   /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////          Orbital Functions     ////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// orbital_types_ptr(...) from builtins.PyCapsule orbital_types_ptr(rosetta.core.chemical.ResidueType) -> core::chemical::orbitals::OrbitalTypeSet   Get the MM atom_type for this atom by its index number in this residue path_distance(...) from builtins.PyCapsule path_distance(*args, **kwargs) Overloaded function.   1. path_distance(self : rosetta.core.chemical.ResidueType, at1 : int, at2 : int) -> int   path distance (number of bonds separated) between a pair of atoms   2. path_distance(self : rosetta.core.chemical.ResidueType, atom : int) -> rosetta.utility.vector1_int   shortest path distance for an atom to all other residue atoms path_distances(...) from builtins.PyCapsule path_distances(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_utility_vector1_int_std_allocator_int_t   accessor of path_distance_ data for this residue, which is a 2D array placeholder_clone(...) from builtins.PyCapsule placeholder_clone(rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   make a copy print_bondangles(...) from builtins.PyCapsule print_bondangles(rosetta.core.chemical.ResidueType) -> NoneType   print intraresidue bond angles to standard out print_dihedrals(...) from builtins.PyCapsule print_dihedrals(rosetta.core.chemical.ResidueType) -> NoneType print_pretty_path_distances(...) from builtins.PyCapsule print_pretty_path_distances(rosetta.core.chemical.ResidueType) -> NoneType   print chemical-bond path distances to standard out properties(...) from builtins.PyCapsule properties(rosetta.core.chemical.ResidueType) -> core::chemical::ResidueProperties   Access the collection of properties for this ResidueType. proton_chi_2_chi(...) from builtins.PyCapsule proton_chi_2_chi(self : rosetta.core.chemical.ResidueType, proton_chi_id : int) -> int   translate proton_chi to global chi proton_chi_extra_samples(...) from builtins.PyCapsule proton_chi_extra_samples(self : rosetta.core.chemical.ResidueType, proton_chi : int) -> rosetta.utility.vector1_double proton_chi_samples(...) from builtins.PyCapsule proton_chi_samples(self : rosetta.core.chemical.ResidueType, proton_chi : int) -> rosetta.utility.vector1_double redefine_chi(...) from builtins.PyCapsule redefine_chi(self : rosetta.core.chemical.ResidueType, chino : int, atom_name1 : str, atom_name2 : str, atom_name3 : str, atom_name4 : str) -> NoneType   redefine a chi angle based on four atoms remap_pdb_atom_names(...) from builtins.PyCapsule remap_pdb_atom_names(*args, **kwargs) Overloaded function.   1. remap_pdb_atom_names(self : rosetta.core.chemical.ResidueType, rename : bool) -> NoneType   Turn on geometry-based atom renaming when loading this residue type from PDB files   2. remap_pdb_atom_names(rosetta.core.chemical.ResidueType) -> bool   Are we using geometry-based atom renaming when loading this residue type from PDB remove_variant_type(...) from builtins.PyCapsule remove_variant_type(*args, **kwargs) Overloaded function.   1. remove_variant_type(self : rosetta.core.chemical.ResidueType, variant_type : rosetta.core.chemical.VariantType) -> NoneType   Remove a variant type to this ResidueType.   2. remove_variant_type(self : rosetta.core.chemical.ResidueType, variant_type : str) -> NoneType   Remove a variant type to this ResidueType by string. report_adducts(...) from builtins.PyCapsule report_adducts(rosetta.core.chemical.ResidueType) -> NoneType require_final(...) from builtins.PyCapsule require_final(rosetta.core.chemical.ResidueType) -> NoneType   an assertion function to ensure an ResidueType has been finalized requires_actcoord(...) from builtins.PyCapsule requires_actcoord(rosetta.core.chemical.ResidueType) -> bool   require actcoord? reset_base_type_cop(...) from builtins.PyCapsule reset_base_type_cop(rosetta.core.chemical.ResidueType) -> NoneType   Reset the base type COP to be null.  This implies that this ResidueType is a base type. reset_bond_distance_to_atom(...) from builtins.PyCapsule reset_bond_distance_to_atom(self : rosetta.core.chemical.ResidueType, atm : str, d : float) -> NoneType   Reset the bond distance to an atom whose internal coordinates have already been set. residue_connect_atom_index(...) from builtins.PyCapsule residue_connect_atom_index(self : rosetta.core.chemical.ResidueType, resconn_id : int) -> int residue_connection(...) from builtins.PyCapsule residue_connection(*args, **kwargs) Overloaded function.   1. residue_connection(self : rosetta.core.chemical.ResidueType, i : int) -> core::chemical::ResidueConnection   Get a ResidueConection.   2. residue_connection(self : rosetta.core.chemical.ResidueType, i : int) -> core::chemical::ResidueConnection   Get a ResidueConection. residue_connection_id_for_atom(...) from builtins.PyCapsule residue_connection_id_for_atom(self : rosetta.core.chemical.ResidueType, atomid : int) -> int   Convenience access function for the residue connection  at a particular atom; requires that there is exactly one residue  connection at this atom. residue_connection_is_polymeric(...) from builtins.PyCapsule residue_connection_is_polymeric(self : rosetta.core.chemical.ResidueType, resconn_id : int) -> bool residue_connections_for_atom(...) from builtins.PyCapsule residue_connections_for_atom(self : rosetta.core.chemical.ResidueType, atomid : int) -> rosetta.utility.vector1_unsigned_long   /   Accessor for the full complement of residue connections for a single atom. residue_type_set(...) from builtins.PyCapsule residue_type_set(*args, **kwargs) Overloaded function.   1. residue_type_set(rosetta.core.chemical.ResidueType) -> core::chemical::ResidueTypeSet   Return an owning pointer to the ResidueTypeSet that this  ResidueType belongs to; it will return a null pointer if this  ResidueType does not belong to any ResidueTypeSet.   2. residue_type_set(self : rosetta.core.chemical.ResidueType, set_in : rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> NoneType   set the residue type set of origin. ring_atoms(...) from builtins.PyCapsule ring_atoms(*args, **kwargs) Overloaded function.   1. ring_atoms(self : rosetta.core.chemical.ResidueType, ring_num : int) -> rosetta.utility.vector1_unsigned_long   Return list of indices of the atoms within this residue's nth cycle, not counting virtual atoms.   2. ring_atoms(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t   Return list of indices of the atoms within this residue's cycles, not counting virtual atoms. ring_conformer_set(...) from builtins.PyCapsule ring_conformer_set(self : rosetta.core.chemical.ResidueType, ring_num : int) -> core::chemical::rings::RingConformerSet   Return a pointer to the object containing the set of ring  conformers possible for this residue's nth cycle. root_atom(...) from builtins.PyCapsule root_atom(rosetta.core.chemical.ResidueType) -> capsule   get root_atom used as the base of the icoor tree. rotamer_aa(...) from builtins.PyCapsule rotamer_aa(self : rosetta.core.chemical.ResidueType, type : str) -> NoneType   AA to use for rotamer scoring rotamer_library_specification(...) from builtins.PyCapsule rotamer_library_specification(*args, **kwargs) Overloaded function.   1. rotamer_library_specification(self : rosetta.core.chemical.ResidueType,  : core::chemical::rotamers::RotamerLibrarySpecification) -> NoneType   2. rotamer_library_specification(rosetta.core.chemical.ResidueType) -> core::chemical::rotamers::RotamerLibrarySpecification select_orient_atoms(...) from builtins.PyCapsule select_orient_atoms(self : rosetta.core.chemical.ResidueType, center : int, nbr1 : int, nbr2 : int) -> NoneType   Selects three atoms for orienting this residue type set_adduct_flag(...) from builtins.PyCapsule set_adduct_flag(self : rosetta.core.chemical.ResidueType, adduct_in : bool) -> NoneType set_atom_base(...) from builtins.PyCapsule set_atom_base(*args, **kwargs) Overloaded function.   1. set_atom_base(self : rosetta.core.chemical.ResidueType, atom_name1 : str, atom_name2 : str) -> NoneType   sets atom_base[ atom1 ] = atom2   2. set_atom_base(self : rosetta.core.chemical.ResidueType, capsule, capsule) -> NoneType   sets atom_base[ atom1 ] = atom2, vertex descriptor version set_atom_type(...) from builtins.PyCapsule set_atom_type(*args, **kwargs) Overloaded function.   1. set_atom_type(self : rosetta.core.chemical.ResidueType, atom_name : str, atom_type_name : str) -> NoneType   set atom type   2. set_atom_type(self : rosetta.core.chemical.ResidueType, capsule, atom : str) -> NoneType   set atom type set_backbone_heavyatom(...) from builtins.PyCapsule set_backbone_heavyatom(self : rosetta.core.chemical.ResidueType, name : str) -> NoneType   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_. set_base_type_cop(...) from builtins.PyCapsule set_base_type_cop(self : rosetta.core.chemical.ResidueType, new_base_type : rosetta.core.chemical.ResidueType) -> NoneType   Set the base type COP.  This implies that this ResidueType is NOT a base type. set_disulfide_atom_name(...) from builtins.PyCapsule set_disulfide_atom_name(self : rosetta.core.chemical.ResidueType, n : str) -> NoneType   Sets disulfide atom name      Andrew M. Watkins (amw579.edu). set_gasteiger_atom_type(...) from builtins.PyCapsule set_gasteiger_atom_type(*args, **kwargs) Overloaded function.   1. set_gasteiger_atom_type(self : rosetta.core.chemical.ResidueType, atom_name : str, gasteiger_atom_type_name : str) -> NoneType   set gasteiger atom type   2. set_gasteiger_atom_type(self : rosetta.core.chemical.ResidueType, capsule, atom : str) -> NoneType   set gasteiger atom type set_gasteiger_typeset(...) from builtins.PyCapsule set_gasteiger_typeset(self : rosetta.core.chemical.ResidueType, gasteiger_atom_types : core::chemical::gasteiger::GasteigerAtomTypeSet) -> NoneType   Manually set the gasteiger typeset - will use the default set otherwise set_icoor(...) from builtins.PyCapsule set_icoor(*args, **kwargs) Overloaded function.   1. set_icoor(self : rosetta.core.chemical.ResidueType, atm : str, phi : float, theta : float, d : float, stub_atom1 : str, stub_atom2 : str, stub_atom3 : str) -> NoneType   set AtomICoor for an atom      phi and theta are in radians   2. set_icoor(self : rosetta.core.chemical.ResidueType, atm : str, phi : float, theta : float, d : float, stub_atom1 : str, stub_atom2 : str, stub_atom3 : str, update_xyz : bool) -> NoneType   set AtomICoor for an atom      phi and theta are in radians   3. set_icoor(self : rosetta.core.chemical.ResidueType, capsule, atm : float, phi : float, theta : float, capsule, capsule, capsule) -> NoneType   set AtomICoor for an atom, vertex descriptor version      phi and theta are in radians   4. set_icoor(self : rosetta.core.chemical.ResidueType, capsule, atm : float, phi : float, theta : float, capsule, capsule, capsule, d : bool) -> NoneType   set AtomICoor for an atom, vertex descriptor version      phi and theta are in radians   5. set_icoor(self : rosetta.core.chemical.ResidueType, atm : str, phi : float, theta : float, d : float, stub_atom1 : rosetta.core.chemical.ICoorAtomID, stub_atom2 : rosetta.core.chemical.ICoorAtomID, stub_atom3 : rosetta.core.chemical.ICoorAtomID) -> NoneType   set AtomICoor for an atom      phi and theta are in radians   6. set_icoor(self : rosetta.core.chemical.ResidueType, atm : str, phi : float, theta : float, d : float, stub_atom1 : rosetta.core.chemical.ICoorAtomID, stub_atom2 : rosetta.core.chemical.ICoorAtomID, stub_atom3 : rosetta.core.chemical.ICoorAtomID, update_xyz : bool) -> NoneType   set AtomICoor for an atom      phi and theta are in radians set_ideal_xyz(...) from builtins.PyCapsule set_ideal_xyz(*args, **kwargs) Overloaded function.   1. set_ideal_xyz(self : rosetta.core.chemical.ResidueType, atm : str, xyz_in : rosetta.numeric.xyzVector_double_t) -> NoneType   2. set_ideal_xyz(self : rosetta.core.chemical.ResidueType, index : int, xyz_in : rosetta.numeric.xyzVector_double_t) -> NoneType   3. set_ideal_xyz(self : rosetta.core.chemical.ResidueType, capsule, atm : rosetta.numeric.xyzVector_double_t) -> NoneType set_low_energy_ring_conformers(...) from builtins.PyCapsule set_low_energy_ring_conformers(self : rosetta.core.chemical.ResidueType, ring_num : int, conformers : rosetta.utility.vector1_std_string) -> NoneType   Set this cyclic residue's low-energy ring conformers for the nth ring by IUPAC name. set_lower_connect_atom(...) from builtins.PyCapsule set_lower_connect_atom(self : rosetta.core.chemical.ResidueType, atm_name : str) -> NoneType   set the atom which connects to the lower connection set_lowest_energy_ring_conformer(...) from builtins.PyCapsule set_lowest_energy_ring_conformer(self : rosetta.core.chemical.ResidueType, ring_num : int, conformer : str) -> NoneType   Set this cyclic residue's lowest-energy ring conformer for the nth ring by IUPAC name. set_mainchain_atoms(...) from builtins.PyCapsule set_mainchain_atoms(self : rosetta.core.chemical.ResidueType, mainchain : rosetta.utility.vector1_unsigned_long) -> NoneType   set indices of all mainchain atoms set_mm_atom_type(...) from builtins.PyCapsule set_mm_atom_type(self : rosetta.core.chemical.ResidueType, atom_name : str, mm_atom_type_name : str) -> NoneType   set mm atom type set_orbital_icoor_id(...) from builtins.PyCapsule set_orbital_icoor_id(self : rosetta.core.chemical.ResidueType, orbital : str, phi : float, theta : float, d : float, stub_atom1 : str, stub_atom2 : str, stub_atom3 : str) -> NoneType   set OrbitalICoor for an orbital set_properties(...) from builtins.PyCapsule set_properties(self : rosetta.core.chemical.ResidueType, properties : core::chemical::ResidueProperties) -> NoneType   Set the collection of properties for this ResidueType. set_proton_chi(...) from builtins.PyCapsule set_proton_chi(self : rosetta.core.chemical.ResidueType, chino : int, dihedral_samples : rosetta.utility.vector1_double, extra_samples : rosetta.utility.vector1_double) -> NoneType   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 set_shadowing_atom(...) from builtins.PyCapsule set_shadowing_atom(self : rosetta.core.chemical.ResidueType, atom : str, atom_being_shadowed : str) -> NoneType set_upper_connect_atom(...) from builtins.PyCapsule set_upper_connect_atom(self : rosetta.core.chemical.ResidueType, atm_name : str) -> NoneType   set the atom which connects to the upper connection smallest_ring_size(...) from builtins.PyCapsule smallest_ring_size(*args, **kwargs) Overloaded function.   1. smallest_ring_size(self : rosetta.core.chemical.ResidueType, capsule) -> int   A graph-based function to determine the size of the smallest ring that involves a given atom.   2. smallest_ring_size(self : rosetta.core.chemical.ResidueType, capsule, atom : int) -> int   A graph-based function to determine the size of the smallest ring that involves a given atom. update_actcoord(...) from builtins.PyCapsule update_actcoord(self : rosetta.core.chemical.ResidueType, rot : core::conformation::Residue) -> NoneType   update actcoord upper_connect(...) from builtins.PyCapsule upper_connect(rosetta.core.chemical.ResidueType) -> core::chemical::ResidueConnection upper_connect_atom(...) from builtins.PyCapsule upper_connect_atom(rosetta.core.chemical.ResidueType) -> int   index number of the atom which connects to the upper connection upper_connect_id(...) from builtins.PyCapsule upper_connect_id(rosetta.core.chemical.ResidueType) -> int variant_type_enums(...) from builtins.PyCapsule variant_type_enums(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_core_chemical_VariantType   Get a vector of VariantType enums for this ResidueType.      This ONLY includes standard, enum-based variants, not on-the-fly custom variants.      Vikram K. Mulligan (vmullig.edu) variant_types(...) from builtins.PyCapsule variant_types(rosetta.core.chemical.ResidueType) -> rosetta.utility.vector1_std_string   get all the variant types for this ResidueType      This will include both on-the-fly custom variants defined by string AND string equivalents  of standard, enumerated variants.          -- rhiju (merging roccomoretti/restypeset_fiddle) within1bonds_sets_for_atom(...) from builtins.PyCapsule within1bonds_sets_for_atom(self : rosetta.core.chemical.ResidueType, atomid : int) -> rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t   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. within2bonds_sets_for_atom(...) from builtins.PyCapsule within2bonds_sets_for_atom(self : rosetta.core.chemical.ResidueType, atomid : int) -> rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t   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.   class ResidueTypeFinder(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.chemical.ResidueTypeFinder, residue_type_set : core::chemical::ResidueTypeSet) -> NoneType   2. __init__(self : rosetta.core.chemical.ResidueTypeFinder,  : rosetta.core.chemical.ResidueTypeFinder) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. aa(...) from builtins.PyCapsule aa(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.core.chemical.AA) -> rosetta.core.chemical.ResidueTypeFinder atom_names_soft(...) from builtins.PyCapsule atom_names_soft(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueTypeFinder base_property(...) from builtins.PyCapsule base_property(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.core.chemical.ResidueProperty) -> rosetta.core.chemical.ResidueTypeFinder base_type(...) from builtins.PyCapsule base_type(self : rosetta.core.chemical.ResidueTypeFinder, basetype : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueTypeFinder   Allow a base type to be specified rigidly.  Since any ResidueType's base type COP can now be accessed easily,  this is a far more efficient way to prune the set of possible ResidueTypes.      Vikram K. Mulligan (vmullig.edu). check_nucleic_acid_virtual_phosphates(...) from builtins.PyCapsule check_nucleic_acid_virtual_phosphates(self : rosetta.core.chemical.ResidueTypeFinder, setting : bool) -> rosetta.core.chemical.ResidueTypeFinder disallow_carboxyl_conjugation_at_glu_asp(...) from builtins.PyCapsule disallow_carboxyl_conjugation_at_glu_asp(self : rosetta.core.chemical.ResidueTypeFinder, setting : bool) -> rosetta.core.chemical.ResidueTypeFinder disallow_properties(...) from builtins.PyCapsule disallow_properties(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_core_chemical_ResidueProperty) -> rosetta.core.chemical.ResidueTypeFinder disallow_variants(...) from builtins.PyCapsule disallow_variants(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_core_chemical_VariantType) -> rosetta.core.chemical.ResidueTypeFinder get_all_possible_residue_types(...) from builtins.PyCapsule get_all_possible_residue_types(*args, **kwargs) Overloaded function.   1. get_all_possible_residue_types(rosetta.core.chemical.ResidueTypeFinder) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   2. get_all_possible_residue_types(self : rosetta.core.chemical.ResidueTypeFinder, allow_extra_variants : bool) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t get_best_match_residue_type_for_atom_names(...) from builtins.PyCapsule get_best_match_residue_type_for_atom_names(self : rosetta.core.chemical.ResidueTypeFinder, atom_names : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueType get_possible_base_custom_residue_types(...) from builtins.PyCapsule get_possible_base_custom_residue_types(rosetta.core.chemical.ResidueTypeFinder) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t get_possible_base_residue_types(...) from builtins.PyCapsule get_possible_base_residue_types(*args, **kwargs) Overloaded function.   1. get_possible_base_residue_types(rosetta.core.chemical.ResidueTypeFinder) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   2. get_possible_base_residue_types(self : rosetta.core.chemical.ResidueTypeFinder, include_custom : bool) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t get_possible_custom_residue_types(...) from builtins.PyCapsule get_possible_custom_residue_types(rosetta.core.chemical.ResidueTypeFinder) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t get_representative_type(...) from builtins.PyCapsule get_representative_type(rosetta.core.chemical.ResidueTypeFinder) -> rosetta.core.chemical.ResidueType ignore_atom_named_H(...) from builtins.PyCapsule ignore_atom_named_H(self : rosetta.core.chemical.ResidueTypeFinder, setting : bool) -> rosetta.core.chemical.ResidueTypeFinder interchangeability_group(...) from builtins.PyCapsule interchangeability_group(self : rosetta.core.chemical.ResidueTypeFinder, setting : str) -> rosetta.core.chemical.ResidueTypeFinder name1(...) from builtins.PyCapsule name1(self : rosetta.core.chemical.ResidueTypeFinder, setting : str) -> rosetta.core.chemical.ResidueTypeFinder name3(...) from builtins.PyCapsule name3(self : rosetta.core.chemical.ResidueTypeFinder, setting : str) -> rosetta.core.chemical.ResidueTypeFinder patch_names(...) from builtins.PyCapsule patch_names(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueTypeFinder properties(...) from builtins.PyCapsule properties(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_core_chemical_ResidueProperty) -> rosetta.core.chemical.ResidueTypeFinder residue_base_name(...) from builtins.PyCapsule residue_base_name(self : rosetta.core.chemical.ResidueTypeFinder, setting : str) -> rosetta.core.chemical.ResidueTypeFinder variant_exceptions(...) from builtins.PyCapsule variant_exceptions(*args, **kwargs) Overloaded function.   1. variant_exceptions(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueTypeFinder   2. variant_exceptions(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_core_chemical_VariantType) -> rosetta.core.chemical.ResidueTypeFinder variants(...) from builtins.PyCapsule variants(*args, **kwargs) Overloaded function.   1. variants(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_core_chemical_VariantType) -> rosetta.core.chemical.ResidueTypeFinder   2. variants(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueTypeFinder   3. variants(self : rosetta.core.chemical.ResidueTypeFinder, std_variants : rosetta.utility.vector1_core_chemical_VariantType, custom_variants : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueTypeFinder   Specify a list of standard variant types (by enum) and custom variant types (by string).      This is the most efficient way to handle variants, since it minimizes the string handling.  Everything that  can be handled by enum is handled by enum.      A vector of enums of standard variants that the ResidueTypeFinder should match.      A vector of strings of custom variant types that the ResidueTypeFinder should match.  Note that  standard types should NOT be included in this list.  There is no check for this!      Vikram K. Mulligan (vmullig.edu). variants_in_sets(...) from builtins.PyCapsule variants_in_sets(self : rosetta.core.chemical.ResidueTypeFinder, setting : rosetta.utility.vector1_utility_vector1_core_chemical_VariantType_std_allocator_core_chemical_VariantType_t) -> rosetta.core.chemical.ResidueTypeFinder   class ResidueTypeKinWriter(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.chemical.ResidueTypeKinWriter) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueTypeKinWriter,  : rosetta.core.chemical.ResidueTypeKinWriter) -> rosetta.core.chemical.ResidueTypeKinWriter   class ResidueTypeSelector(builtins.object)     /////////////////////////////////////////////////////////////////////////////////////     A class picking out a subset of ResidueType by multiple criteria     Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.ResidueTypeSelector, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.chemical.ResidueTypeSelector,  : rosetta.core.chemical.ResidueTypeSelector) -> NoneType   2. __init__(rosetta.core.chemical.ResidueTypeSelector) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_line(...) from builtins.PyCapsule add_line(self : rosetta.core.chemical.ResidueTypeSelector, line : str) -> rosetta.core.chemical.ResidueTypeSelector assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueTypeSelector,  : rosetta.core.chemical.ResidueTypeSelector) -> rosetta.core.chemical.ResidueTypeSelector clear(...) from builtins.PyCapsule clear(rosetta.core.chemical.ResidueTypeSelector) -> rosetta.core.chemical.ResidueTypeSelector exclude_variants(...) from builtins.PyCapsule exclude_variants(rosetta.core.chemical.ResidueTypeSelector) -> rosetta.core.chemical.ResidueTypeSelector match_variants(...) from builtins.PyCapsule match_variants(self : rosetta.core.chemical.ResidueTypeSelector, rsd_type_to_match : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueTypeSelector set_aa(...) from builtins.PyCapsule set_aa(self : rosetta.core.chemical.ResidueTypeSelector, aa : rosetta.core.chemical.AA) -> rosetta.core.chemical.ResidueTypeSelector set_name1(...) from builtins.PyCapsule set_name1(self : rosetta.core.chemical.ResidueTypeSelector, n : str) -> rosetta.core.chemical.ResidueTypeSelector set_property(...) from builtins.PyCapsule set_property(self : rosetta.core.chemical.ResidueTypeSelector, property : str) -> rosetta.core.chemical.ResidueTypeSelector   class ResidueTypeSelectorSingle(builtins.object)     /////////////////////////////////////////////////////////////////////////////////////     A base class for defining a ResidueTypeSelector by a single criterion     Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.ResidueTypeSelectorSingle, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.chemical.ResidueTypeSelectorSingle, result : bool) -> NoneType   2. __init__(rosetta.core.chemical.ResidueTypeSelectorSingle, rosetta.core.chemical.ResidueTypeSelectorSingle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueTypeSelectorSingle,  : rosetta.core.chemical.ResidueTypeSelectorSingle) -> rosetta.core.chemical.ResidueTypeSelectorSingle desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class ResidueTypeSet(builtins.object)     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)     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, name : str, directory : str) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_custom_residue_type(...) from builtins.PyCapsule add_custom_residue_type(*args, **kwargs) Overloaded function.   1. add_custom_residue_type(self : rosetta.core.chemical.ResidueTypeSet, new_type : rosetta.core.chemical.ResidueType) -> NoneType   adds a new residue type to the set, one that CANNOT be generated from a base_residue_type and patches   2. add_custom_residue_type(self : rosetta.core.chemical.ResidueTypeSet, filename : str) -> NoneType   adds a new residue type to the set, one that CANNOT be generated from a base_residue_type and patches apply_patches(...) from builtins.PyCapsule apply_patches(self : rosetta.core.chemical.ResidueTypeSet, patch_filenames : rosetta.utility.vector1_std_string, metapatch_filenames : rosetta.utility.vector1_std_string) -> NoneType   delete a custom residue type from the set (Use with care) atom_type_set(...) from builtins.PyCapsule atom_type_set(*args, **kwargs) Overloaded function.   1. atom_type_set(rosetta.core.chemical.ResidueTypeSet) -> rosetta.core.chemical.AtomTypeSet   2. atom_type_set(self : rosetta.core.chemical.ResidueTypeSet, atom_types : rosetta.core.chemical.AtomTypeSet) -> NoneType base_residue_types(...) from builtins.PyCapsule base_residue_types(rosetta.core.chemical.ResidueTypeSet) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   the residues with no patches applied custom_residue_types(...) from builtins.PyCapsule custom_residue_types(rosetta.core.chemical.ResidueTypeSet) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   the residues with no patches applied database_directory(...) from builtins.PyCapsule database_directory(rosetta.core.chemical.ResidueTypeSet) -> str   accessor for database_directory element_set(...) from builtins.PyCapsule element_set(*args, **kwargs) Overloaded function.   1. element_set(rosetta.core.chemical.ResidueTypeSet) -> rosetta.core.chemical.ElementSet   2. element_set(self : rosetta.core.chemical.ResidueTypeSet, elements : rosetta.core.chemical.ElementSet) -> NoneType generates_patched_residue_type_with_interchangeability_group(...) from builtins.PyCapsule generates_patched_residue_type_with_interchangeability_group(self : rosetta.core.chemical.ResidueTypeSet, base_residue_name : str, interchangeability_group : str) -> bool   Check if a base type (like "CYS") generates any types with a new interchangeability group (like "SCY" (via cys_acetylated)) generates_patched_residue_type_with_name3(...) from builtins.PyCapsule generates_patched_residue_type_with_name3(self : rosetta.core.chemical.ResidueTypeSet, base_residue_name : str, name3 : str) -> bool   Check if a base type (like "SER") generates any types with another name3 (like "SEP") get_all_types_with_variants_aa(...) from builtins.PyCapsule get_all_types_with_variants_aa(*args, **kwargs) Overloaded function.   1. get_all_types_with_variants_aa(self : rosetta.core.chemical.ResidueTypeSet, aa : rosetta.core.chemical.AA, variants : rosetta.utility.vector1_std_string) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   Gets all types with the given aa type and variants      The number of variants must match exactly. Variants can be custom variants.  (It's assumed that the passed VariantTypeList contains no duplicates.)   2. get_all_types_with_variants_aa(self : rosetta.core.chemical.ResidueTypeSet, aa : rosetta.core.chemical.AA, variants : rosetta.utility.vector1_std_string, exceptions : rosetta.utility.vector1_core_chemical_VariantType) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   Gets all types with the given aa type and variants, making exceptions for some variants.      The number of variants must match exactly. Variants can be custom variants, but exceptions must            be standard types, listed in VariantType.hh.  (It's assumed that the passed VariantTypeList contains no duplicates.) get_all_types_with_variants_name1(...) from builtins.PyCapsule get_all_types_with_variants_name1(self : rosetta.core.chemical.ResidueTypeSet, name1 : str, variants : rosetta.utility.vector1_std_string) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   Get all non-patched ResidueTypes with the given name1      The number of variants must match exactly.  (It's assumed that the passed VariantTypeList contains no duplicates.) get_all_types_with_variants_name3(...) from builtins.PyCapsule get_all_types_with_variants_name3(self : rosetta.core.chemical.ResidueTypeSet, name3 : str, variants : rosetta.utility.vector1_std_string) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   Get all non-patched ResidueTypes with the given name3      The number of variants must match exactly.  (It's assumed that the passed VariantTypeList contains no duplicates.) get_base_types_aa(...) from builtins.PyCapsule get_base_types_aa(self : rosetta.core.chemical.ResidueTypeSet, aa : rosetta.core.chemical.AA) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   Gets all non-patched types with the given aa type get_base_types_name1(...) from builtins.PyCapsule get_base_types_name1(self : rosetta.core.chemical.ResidueTypeSet, name1 : str) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   Get all non-patched ResidueTypes with the given name1 get_base_types_name3(...) from builtins.PyCapsule get_base_types_name3(self : rosetta.core.chemical.ResidueTypeSet, name3 : str) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t   Get all non-patched ResidueTypes with the given name3 get_d_equivalent(...) from builtins.PyCapsule get_d_equivalent(self : rosetta.core.chemical.ResidueTypeSet, l_rsd : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   Given a D-residue, get its L-equivalent.      Returns NULL if there is no equivalent, true otherwise.  Throws an error if this is not a D-residue.  Preserves variant types.      Vikram K. Mulligan (vmullig.edu). get_l_equivalent(...) from builtins.PyCapsule get_l_equivalent(self : rosetta.core.chemical.ResidueTypeSet, d_rsd : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   Given an L-residue, get its D-equivalent.      Returns NULL if there is no equivalent, true otherwise.  Throws an error if this is not an L-residue.  Preserves variant types.      Vikram K. Mulligan (vmullig.edu). get_mirrored_type(...) from builtins.PyCapsule get_mirrored_type(self : rosetta.core.chemical.ResidueTypeSet, original_rsd : rosetta.core.chemical.ResidueType) -> rosetta.core.chemical.ResidueType   Given a residue, get its mirror-image type.      Returns the same residue if this is an ACHIRAL type (e.g. gly), the D-equivalent for an L-residue, the L-equivalent of a D-residue,  or NULL if this is an L-residue with no D-equivalent (or a D- with no L-equivalent).  Preserves variant types. get_representative_type_aa(...) from builtins.PyCapsule get_representative_type_aa(*args, **kwargs) Overloaded function.   1. get_representative_type_aa(self : rosetta.core.chemical.ResidueTypeSet, aa : rosetta.core.chemical.AA, variants : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueType   Get the base ResidueType with the given aa type and variants      Returns 0 if one does not exist.  The returned type will have at least all the variants given, but may have more  if a minimal variant type isn't availible.   2. get_representative_type_aa(self : rosetta.core.chemical.ResidueTypeSet, aa : rosetta.core.chemical.AA) -> rosetta.core.chemical.ResidueType get_representative_type_name1(...) from builtins.PyCapsule get_representative_type_name1(*args, **kwargs) Overloaded function.   1. get_representative_type_name1(self : rosetta.core.chemical.ResidueTypeSet, name1 : str, variants : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueType   Get the base ResidueType with the given name1 and variants      Returns 0 if one does not exist.  The returned type will have at least all the variants given, but may have more  if a minimal variant type isn't availible.   2. get_representative_type_name1(self : rosetta.core.chemical.ResidueTypeSet, name1 : str) -> rosetta.core.chemical.ResidueType get_representative_type_name3(...) from builtins.PyCapsule get_representative_type_name3(*args, **kwargs) Overloaded function.   1. get_representative_type_name3(self : rosetta.core.chemical.ResidueTypeSet, name3 : str, variants : rosetta.utility.vector1_std_string) -> rosetta.core.chemical.ResidueType   Get the base ResidueType with the given name3 and variants      Returns 0 if one does not exist.  The returned type will have at least all the variants given, but may have more  if a minimal variant type isn't availible.   2. get_representative_type_name3(self : rosetta.core.chemical.ResidueTypeSet, name3 : str) -> rosetta.core.chemical.ResidueType get_residue_type_with_variant_added(...) from builtins.PyCapsule get_residue_type_with_variant_added(self : rosetta.core.chemical.ResidueTypeSet, init_rsd : rosetta.core.chemical.ResidueType, new_type : rosetta.core.chemical.VariantType) -> rosetta.core.chemical.ResidueType   Query a variant ResidueType by its base ResidueType and VariantType get_residue_type_with_variant_removed(...) from builtins.PyCapsule get_residue_type_with_variant_removed(self : rosetta.core.chemical.ResidueTypeSet, init_rsd : rosetta.core.chemical.ResidueType, old_type : rosetta.core.chemical.VariantType) -> rosetta.core.chemical.ResidueType   return the residuetype we get from variant rsd type after removing the desired variant type get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.core.chemical.ResidueTypeSet) -> rosetta.core.chemical.ResidueTypeSet   self pointers   2. get_self_ptr(rosetta.core.chemical.ResidueTypeSet) -> rosetta.core.chemical.ResidueTypeSet get_self_weak_ptr(...) from builtins.PyCapsule get_self_weak_ptr(rosetta.core.chemical.ResidueTypeSet) -> rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t has_interchangeability_group(...) from builtins.PyCapsule has_interchangeability_group(self : rosetta.core.chemical.ResidueTypeSet, name : str) -> bool   Does this ResidueTypeSet have ResidueTypes with the given interchangeability group? has_name(...) from builtins.PyCapsule has_name(self : rosetta.core.chemical.ResidueTypeSet, name : str) -> bool   query if a ResidueType of the unique residue id (name) is present. has_name3(...) from builtins.PyCapsule has_name3(self : rosetta.core.chemical.ResidueTypeSet, name3 : str) -> bool   query if any ResidueTypes in the set have a "name3" tat matches the input name3 init(...) from builtins.PyCapsule init(*args, **kwargs) Overloaded function.   1. init(rosetta.core.chemical.ResidueTypeSet) -> NoneType   2. init(self : rosetta.core.chemical.ResidueTypeSet, extra_res_param_files : rosetta.std.vector_std_string) -> NoneType   3. init(self : rosetta.core.chemical.ResidueTypeSet, extra_res_param_files : rosetta.std.vector_std_string, extra_patch_files : rosetta.std.vector_std_string) -> NoneType merge_behavior_manager(...) from builtins.PyCapsule merge_behavior_manager(rosetta.core.chemical.ResidueTypeSet) -> rosetta.core.chemical.MergeBehaviorManager   accessor for merge behavior manager metapatch(...) from builtins.PyCapsule metapatch(self : rosetta.core.chemical.ResidueTypeSet, name : str) -> rosetta.core.chemical.Metapatch metapatches(...) from builtins.PyCapsule metapatches(rosetta.core.chemical.ResidueTypeSet) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_Metapatch_t   the metapatches mm_atom_type_set(...) from builtins.PyCapsule mm_atom_type_set(*args, **kwargs) Overloaded function.   1. mm_atom_type_set(rosetta.core.chemical.ResidueTypeSet) -> rosetta.core.chemical.MMAtomTypeSet   2. mm_atom_type_set(self : rosetta.core.chemical.ResidueTypeSet, mm_atom_types : rosetta.core.chemical.MMAtomTypeSet) -> NoneType name(...) from builtins.PyCapsule name(rosetta.core.chemical.ResidueTypeSet) -> str   name of the residue type set name_map(...) from builtins.PyCapsule name_map(self : rosetta.core.chemical.ResidueTypeSet, name : str) -> rosetta.core.chemical.ResidueType   query ResidueType by its unique residue id.      since residue id is unique, it only returns  one residue type or exit without match. name_mapOP(...) from builtins.PyCapsule name_mapOP(self : rosetta.core.chemical.ResidueTypeSet, name : str) -> rosetta.core.chemical.ResidueType   Get ResidueType by exact name, returning COP  Will return null pointer for no matches orbital_type_set(...) from builtins.PyCapsule orbital_type_set(*args, **kwargs) Overloaded function.   1. orbital_type_set(rosetta.core.chemical.ResidueTypeSet) -> core::chemical::orbitals::OrbitalTypeSet   2. orbital_type_set(self : rosetta.core.chemical.ResidueTypeSet, orbital_types : core::chemical::orbitals::OrbitalTypeSet) -> NoneType patch_map(...) from builtins.PyCapsule patch_map(rosetta.core.chemical.ResidueTypeSet) -> rosetta.std.map_std_string_utility_vector1_std_shared_ptr_const_core_chemical_Patch_std_allocator_std_shared_ptr_const_core_chemical_Patch_t   the patches, index by name. patches(...) from builtins.PyCapsule patches(rosetta.core.chemical.ResidueTypeSet) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_Patch_t   the patches read_files_for_custom_residue_types(...) from builtins.PyCapsule read_files_for_custom_residue_types(self : rosetta.core.chemical.ResidueTypeSet, filenames : rosetta.utility.vector1_std_string) -> NoneType   adds new residue types, ones that CANNOT be generated from a base_residue_type and patches remove_base_residue_type_DO_NOT_USE(...) from builtins.PyCapsule remove_base_residue_type_DO_NOT_USE(self : rosetta.core.chemical.ResidueTypeSet, name : str) -> NoneType   delete a custom residue type from the set (Use with *extreme* care) remove_custom_residue_type(...) from builtins.PyCapsule remove_custom_residue_type(self : rosetta.core.chemical.ResidueTypeSet, name : str) -> NoneType   delete a custom residue type from the set (Use with care)   class ResidueTypeSetCache(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : rosetta.core.chemical.ResidueTypeSetCache, rsd_type_set : rosetta.core.chemical.ResidueTypeSet) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_prohibited(...) from builtins.PyCapsule add_prohibited(self : rosetta.core.chemical.ResidueTypeSetCache, rsd_name : str) -> NoneType add_residue_type(...) from builtins.PyCapsule add_residue_type(self : rosetta.core.chemical.ResidueTypeSetCache, residue_type : rosetta.core.chemical.ResidueType) -> NoneType clear_cached_maps(...) from builtins.PyCapsule clear_cached_maps(rosetta.core.chemical.ResidueTypeSetCache) -> NoneType generated_residue_types(...) from builtins.PyCapsule generated_residue_types(rosetta.core.chemical.ResidueTypeSetCache) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t get_all_types_with_variants_aa(...) from builtins.PyCapsule get_all_types_with_variants_aa(self : rosetta.core.chemical.ResidueTypeSetCache, aa : rosetta.core.chemical.AA, variants : rosetta.utility.vector1_std_string, exceptions : rosetta.utility.vector1_core_chemical_VariantType) -> rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t has_generated_residue_type(...) from builtins.PyCapsule has_generated_residue_type(*args, **kwargs) Overloaded function.   1. has_generated_residue_type(self : rosetta.core.chemical.ResidueTypeSetCache, rsd_type : rosetta.core.chemical.ResidueType) -> bool   2. has_generated_residue_type(self : rosetta.core.chemical.ResidueTypeSetCache, rsd_name : str) -> bool is_prohibited(...) from builtins.PyCapsule is_prohibited(self : rosetta.core.chemical.ResidueTypeSetCache, rsd_name : str) -> bool name_map(...) from builtins.PyCapsule name_map(self : rosetta.core.chemical.ResidueTypeSetCache, name_in : str) -> rosetta.core.chemical.ResidueType   Main accessor function into ResidueTypeSetCache remove_residue_type(...) from builtins.PyCapsule remove_residue_type(self : rosetta.core.chemical.ResidueTypeSetCache, name : str) -> NoneType update_residue_type(...) from builtins.PyCapsule update_residue_type(self : rosetta.core.chemical.ResidueTypeSetCache, residue_type_original : rosetta.core.chemical.ResidueType, residue_type_new : rosetta.core.chemical.ResidueType) -> NoneType   class Selector_AA(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////     Does the residue belong to ANY of these AAs?     Method resolution order: Selector_AA ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_AA, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, aas_in : rosetta.utility.vector1_core_chemical_AA, result : bool) -> NoneType   2. __init__(handle, rosetta.core.chemical.Selector_AA) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Selector_AA,  : rosetta.core.chemical.Selector_AA) -> rosetta.core.chemical.Selector_AA Methods inherited from ResidueTypeSelectorSingle: desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class Selector_CMDFLAG(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////      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     Method resolution order: Selector_CMDFLAG ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_CMDFLAG,  : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(self : handle, flags_in : str, result : bool) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Selector_CMDFLAG,  : rosetta.core.chemical.Selector_CMDFLAG) -> rosetta.core.chemical.Selector_CMDFLAG Methods inherited from ResidueTypeSelectorSingle: desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class Selector_MATCH_VARIANTS(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////     Does the residue have ALL of the variant types and no more     Method resolution order: Selector_MATCH_VARIANTS ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_MATCH_VARIANTS, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, variants_in : rosetta.utility.vector1_std_string, result : bool) -> NoneType   2. __init__(handle, rosetta.core.chemical.Selector_MATCH_VARIANTS) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Selector_MATCH_VARIANTS,  : rosetta.core.chemical.Selector_MATCH_VARIANTS) -> rosetta.core.chemical.Selector_MATCH_VARIANTS Methods inherited from ResidueTypeSelectorSingle: desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class Selector_NAME1(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////     Does the residue belong to ANY of these one-letter codes?     Method resolution order: Selector_NAME1 ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_NAME1, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, n : str, result : bool) -> NoneType   2. __init__(handle, rosetta.core.chemical.Selector_NAME1) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. Methods inherited from ResidueTypeSelectorSingle: assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.ResidueTypeSelectorSingle,  : rosetta.core.chemical.ResidueTypeSelectorSingle) -> rosetta.core.chemical.ResidueTypeSelectorSingle desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class Selector_NAME3(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////     Does the residue have to ANY of these three-letter codes?     Method resolution order: Selector_NAME3 ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_NAME3, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(self : handle, name3s_in : rosetta.utility.vector1_std_string, result : bool) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Selector_NAME3,  : rosetta.core.chemical.Selector_NAME3) -> rosetta.core.chemical.Selector_NAME3 Methods inherited from ResidueTypeSelectorSingle: desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class Selector_NO_VARIANTS(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////     Does the residue have NO variant types?     Method resolution order: Selector_NO_VARIANTS ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_NO_VARIANTS, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, result : bool) -> NoneType   2. __init__(handle, rosetta.core.chemical.Selector_NO_VARIANTS) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Selector_NO_VARIANTS,  : rosetta.core.chemical.Selector_NO_VARIANTS) -> rosetta.core.chemical.Selector_NO_VARIANTS Methods inherited from ResidueTypeSelectorSingle: desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class Selector_PROPERTY(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////     Does the residue have ANY of these properties?     Method resolution order: Selector_PROPERTY ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_PROPERTY, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, properties_in : rosetta.utility.vector1_std_string, result : bool) -> NoneType   2. __init__(handle, rosetta.core.chemical.Selector_PROPERTY) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Selector_PROPERTY,  : rosetta.core.chemical.Selector_PROPERTY) -> rosetta.core.chemical.Selector_PROPERTY Methods inherited from ResidueTypeSelectorSingle: desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class Selector_UPPER_POSITION(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////       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.     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     Method resolution order: Selector_UPPER_POSITION ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_UPPER_POSITION, rsd : rosetta.core.chemical.ResidueType) -> bool   Select by the position at which the upper connection is attached.       This is currently written to work only with carbohydrates, since only carbohydrates store their main-  chain position.  If needed for another residue subclass, one would need to modify this method.  OR, it would be  better to create a datum for storing the main-chain position in ResidueType. __init__(...) from builtins.PyCapsule __init__(self : handle, position : int, result : bool) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Selector_UPPER_POSITION,  : rosetta.core.chemical.Selector_UPPER_POSITION) -> rosetta.core.chemical.Selector_UPPER_POSITION Methods inherited from ResidueTypeSelectorSingle: desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class Selector_VARIANT_TYPE(ResidueTypeSelectorSingle)     /////////////////////////////////////////////////////////////////////////////////////     Does the residue have ANY of variant types?     Method resolution order: Selector_VARIANT_TYPE ResidueTypeSelectorSingle builtins.object Methods defined here: __getitem__(...) from builtins.PyCapsule __getitem__(self : rosetta.core.chemical.Selector_VARIANT_TYPE, rsd : rosetta.core.chemical.ResidueType) -> bool __init__(...) from builtins.PyCapsule __init__(self : handle, variants_in : rosetta.utility.vector1_std_string, result : bool) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.Selector_VARIANT_TYPE,  : rosetta.core.chemical.Selector_VARIANT_TYPE) -> rosetta.core.chemical.Selector_VARIANT_TYPE Methods inherited from ResidueTypeSelectorSingle: desired_result(...) from builtins.PyCapsule desired_result(rosetta.core.chemical.ResidueTypeSelectorSingle) -> bool   class SetAllAtomsRepulsive(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set the residue neighbor radius     Method resolution order: SetAllAtomsRepulsive PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetAllAtomsRepulsive, rsd : core::chemical::ResidueType) -> bool   set the residue neighbor atom assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetAllAtomsRepulsive,  : rosetta.core.chemical.SetAllAtomsRepulsive) -> rosetta.core.chemical.SetAllAtomsRepulsive Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetAtomType(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set atom's chemical type     Method resolution order: SetAtomType PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str, atom_type_name_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetAtomType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetAtomType, rsd : core::chemical::ResidueType) -> bool   set atom's chemical type assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetAtomType,  : rosetta.core.chemical.SetAtomType) -> rosetta.core.chemical.SetAtomType Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetAtomicCharge(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set an atom's charge     Method resolution order: SetAtomicCharge PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str, charge_in : float) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetAtomicCharge) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetAtomicCharge, rsd : core::chemical::ResidueType) -> bool   set an atom's charge assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetAtomicCharge,  : rosetta.core.chemical.SetAtomicCharge) -> rosetta.core.chemical.SetAtomicCharge Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetBackboneHeavyatom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set an atom as backbone heavy atom     Method resolution order: SetBackboneHeavyatom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetBackboneHeavyatom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetBackboneHeavyatom, rsd : core::chemical::ResidueType) -> bool   set an atom in ResidueType rsd as backbone heavy atom assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetBackboneHeavyatom,  : rosetta.core.chemical.SetBackboneHeavyatom) -> rosetta.core.chemical.SetBackboneHeavyatom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetFormalCharge(PatchOperation)     ////////////////////////////////////////////////////////////////////////////      A patch operation for setting the formal charge of a ResidueType's atom.     Labonte <JWLabonte.edu>     Method resolution order: SetFormalCharge PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str, charge_in : int) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetFormalCharge) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetFormalCharge, rsd : core::chemical::ResidueType) -> bool   Apply this patch to the given ResidueType. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetFormalCharge,  : rosetta.core.chemical.SetFormalCharge) -> rosetta.core.chemical.SetFormalCharge Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetICoor(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set an atom's AtomICoord     Method resolution order: SetICoor PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_in : str, phi_in : float, theta_in : float, d_in : float, stub1_in : str, stub2_in : str, stub3_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetICoor) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetICoor, rsd : core::chemical::ResidueType) -> bool   set an atom's AtomICoord assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetICoor,  : rosetta.core.chemical.SetICoor) -> rosetta.core.chemical.SetICoor Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetIO_String(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set residue's name1 and name3     Method resolution order: SetIO_String PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, name3 : str, name1 : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetIO_String) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.SetIO_String) -> bool apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetIO_String, rsd : core::chemical::ResidueType) -> bool   set atom's chemical type generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.SetIO_String) -> str   Generates name3. Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.PatchOperation,  : rosetta.core.chemical.PatchOperation) -> rosetta.core.chemical.PatchOperation deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetInterchangeabilityGroup_String(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set the interchangeability_group string for a ResidueType     Method resolution order: SetInterchangeabilityGroup_String PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, intgrp : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetInterchangeabilityGroup_String) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetInterchangeabilityGroup_String, rsd : core::chemical::ResidueType) -> bool generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.SetInterchangeabilityGroup_String) -> str Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.PatchOperation,  : rosetta.core.chemical.PatchOperation) -> rosetta.core.chemical.PatchOperation deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetMMAtomType(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set atom's MM chemical type     Method resolution order: SetMMAtomType PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str, mm_atom_type_name_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetMMAtomType) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetMMAtomType, rsd : core::chemical::ResidueType) -> bool   set atom's chemical type assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetMMAtomType,  : rosetta.core.chemical.SetMMAtomType) -> rosetta.core.chemical.SetMMAtomType Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetNbrAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set the residue neighbor atom     Method resolution order: SetNbrAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetNbrAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetNbrAtom, rsd : core::chemical::ResidueType) -> bool   set the residue neighbor atom assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetNbrAtom,  : rosetta.core.chemical.SetNbrAtom) -> rosetta.core.chemical.SetNbrAtom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetNbrRadius(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set the residue neighbor radius     Method resolution order: SetNbrRadius PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : handle, radius : float) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetNbrRadius, rsd : core::chemical::ResidueType) -> bool   set the residue neighbor atom assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetNbrRadius,  : rosetta.core.chemical.SetNbrRadius) -> rosetta.core.chemical.SetNbrRadius Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetOrientAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     Set orient atom selection mode.     Method resolution order: SetOrientAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(self : handle, force_nbr_atom_orient : bool) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetOrientAtom, rsd : core::chemical::ResidueType) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetOrientAtom,  : rosetta.core.chemical.SetOrientAtom) -> rosetta.core.chemical.SetOrientAtom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class SetPolymerConnectAtom(PatchOperation)     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     set an atom as polymer connection     Method resolution order: SetPolymerConnectAtom PatchOperation builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, atom_name_in : str, upper_lower_in : str) -> NoneType   2. __init__(handle, rosetta.core.chemical.SetPolymerConnectAtom) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.chemical.SetPolymerConnectAtom, rsd : core::chemical::ResidueType) -> bool   set an atom in ResidueType rsd as a polymer connection atom assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.SetPolymerConnectAtom,  : rosetta.core.chemical.SetPolymerConnectAtom) -> rosetta.core.chemical.SetPolymerConnectAtom Methods inherited from PatchOperation: adds_atom(...) from builtins.PyCapsule adds_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is added. Used for fast matching of ResidueType/Patches to PDB residues. adds_property(...) from builtins.PyCapsule adds_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is added. applies_to_placeholder(...) from builtins.PyCapsule applies_to_placeholder(rosetta.core.chemical.PatchOperation) -> bool   Special -- does this apply to 'minimal', placeholder types? Generally true, unless updating aa or name3. deletes_atom(...) from builtins.PyCapsule deletes_atom(rosetta.core.chemical.PatchOperation) -> str   Which atom, if any, is deleted. Used for fast matching of ResidueType/Patches to PDB residues. deletes_property(...) from builtins.PyCapsule deletes_property(rosetta.core.chemical.PatchOperation) -> str   Which property, if any, is deleted. deletes_variant(...) from builtins.PyCapsule deletes_variant(rosetta.core.chemical.PatchOperation) -> str   Which variant, if any, is deleted. generates_base_residue(...) from builtins.PyCapsule generates_base_residue(rosetta.core.chemical.PatchOperation) -> bool   Generates base residue -- legacy for D_AA -- do not use otherwise. generates_interchangeability_group(...) from builtins.PyCapsule generates_interchangeability_group(rosetta.core.chemical.PatchOperation) -> str   Generates interchangeability_group. generates_name3(...) from builtins.PyCapsule generates_name3(rosetta.core.chemical.PatchOperation) -> str   Generates name3. may_change_aa(...) from builtins.PyCapsule may_change_aa(rosetta.core.chemical.PatchOperation) -> bool   Generates a new aa   class VariantType(builtins.object)     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.     Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.VariantType, rosetta.core.chemical.VariantType) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.VariantType) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.VariantType, int) -> NoneType   2. __init__(rosetta.core.chemical.VariantType, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.VariantType) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.VariantType, rosetta.core.chemical.VariantType) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.VariantType) -> str Data and other attributes defined here: A3B_HBS_POST = VariantType.A3B_HBS_POST A3B_HBS_PRE = VariantType.A3B_HBS_PRE ACETYLATED_NTERMINUS_VARIANT = VariantType.ACETYLATED_NTERMINUS_VARIANT ACETYLATION = VariantType.ACETYLATION ADDUCT_VARIANT = VariantType.ADDUCT_VARIANT ALDONIC_ACID_VARIANT = VariantType.ALDONIC_ACID_VARIANT ALTERNATIVE_PROTONATION = VariantType.ALTERNATIVE_PROTONATION BLOCK_STACK_ABOVE = VariantType.BLOCK_STACK_ABOVE BLOCK_STACK_BELOW = VariantType.BLOCK_STACK_BELOW BRANCH_LOWER_TERMINUS_VARIANT = VariantType.BRANCH_LOWER_TERMINUS_VARIANT BULGE = VariantType.BULGE C1_ACETYLAMINO_SUGAR = VariantType.C1_ACETYLAMINO_SUGAR C1_AMINO_SUGAR = VariantType.C1_AMINO_SUGAR C1_BRANCH_POINT = VariantType.C1_BRANCH_POINT C1_DEOXY_SUGAR = VariantType.C1_DEOXY_SUGAR C1_METHYLATED_SUGAR = VariantType.C1_METHYLATED_SUGAR C1_PHOSPHATE = VariantType.C1_PHOSPHATE C1_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C1_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C1_SULFATED_SUGAR = VariantType.C1_SULFATED_SUGAR C1_SULFOAMINO_SUGAR = VariantType.C1_SULFOAMINO_SUGAR C2_ACETYLAMINO_SUGAR = VariantType.C2_ACETYLAMINO_SUGAR C2_AMINO_SUGAR = VariantType.C2_AMINO_SUGAR C2_BRANCH_POINT = VariantType.C2_BRANCH_POINT C2_DEOXY_SUGAR = VariantType.C2_DEOXY_SUGAR C2_KETOALDONIC_ACID = VariantType.C2_KETOALDONIC_ACID C2_METHYLATED_SUGAR = VariantType.C2_METHYLATED_SUGAR C2_PHOSPHATE = VariantType.C2_PHOSPHATE C2_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C2_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C2_SULFATED_SUGAR = VariantType.C2_SULFATED_SUGAR C2_SULFOAMINO_SUGAR = VariantType.C2_SULFOAMINO_SUGAR C3_ACETYLAMINO_SUGAR = VariantType.C3_ACETYLAMINO_SUGAR C3_AMINO_SUGAR = VariantType.C3_AMINO_SUGAR C3_BRANCH_POINT = VariantType.C3_BRANCH_POINT C3_DEOXY_SUGAR = VariantType.C3_DEOXY_SUGAR C3_KETOALDONIC_ACID = VariantType.C3_KETOALDONIC_ACID C3_METHYLATED_SUGAR = VariantType.C3_METHYLATED_SUGAR C3_PHOSPHATE = VariantType.C3_PHOSPHATE C3_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C3_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C3_SULFATED_SUGAR = VariantType.C3_SULFATED_SUGAR C3_SULFOAMINO_SUGAR = VariantType.C3_SULFOAMINO_SUGAR C4_ACETYLAMINO_SUGAR = VariantType.C4_ACETYLAMINO_SUGAR C4_AMINO_SUGAR = VariantType.C4_AMINO_SUGAR C4_BRANCH_POINT = VariantType.C4_BRANCH_POINT C4_DEOXY_SUGAR = VariantType.C4_DEOXY_SUGAR C4_KETOALDONIC_ACID = VariantType.C4_KETOALDONIC_ACID C4_METHYLATED_SUGAR = VariantType.C4_METHYLATED_SUGAR C4_PHOSPHATE = VariantType.C4_PHOSPHATE C4_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C4_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C4_SULFATED_SUGAR = VariantType.C4_SULFATED_SUGAR C4_SULFOAMINO_SUGAR = VariantType.C4_SULFOAMINO_SUGAR C5_ACETYLAMINO_SUGAR = VariantType.C5_ACETYLAMINO_SUGAR C5_AMINO_SUGAR = VariantType.C5_AMINO_SUGAR C5_BRANCH_POINT = VariantType.C5_BRANCH_POINT C5_DEOXY_SUGAR = VariantType.C5_DEOXY_SUGAR C5_KETOALDONIC_ACID = VariantType.C5_KETOALDONIC_ACID C5_METHYLATED_SUGAR = VariantType.C5_METHYLATED_SUGAR C5_PHOSPHATE = VariantType.C5_PHOSPHATE C5_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C5_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C5_SULFATED_SUGAR = VariantType.C5_SULFATED_SUGAR C5_SULFOAMINO_SUGAR = VariantType.C5_SULFOAMINO_SUGAR C6_ACETYLAMINO_SUGAR = VariantType.C6_ACETYLAMINO_SUGAR C6_AMINO_SUGAR = VariantType.C6_AMINO_SUGAR C6_BRANCH_POINT = VariantType.C6_BRANCH_POINT C6_DEOXY_SUGAR = VariantType.C6_DEOXY_SUGAR C6_KETOALDONIC_ACID = VariantType.C6_KETOALDONIC_ACID C6_METHYLATED_SUGAR = VariantType.C6_METHYLATED_SUGAR C6_PHOSPHATE = VariantType.C6_PHOSPHATE C6_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C6_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C6_SULFATED_SUGAR = VariantType.C6_SULFATED_SUGAR C6_SULFOAMINO_SUGAR = VariantType.C6_SULFOAMINO_SUGAR C7_ACETYLAMINO_SUGAR = VariantType.C7_ACETYLAMINO_SUGAR C7_AMINO_SUGAR = VariantType.C7_AMINO_SUGAR C7_BRANCH_POINT = VariantType.C7_BRANCH_POINT C7_DEOXY_SUGAR = VariantType.C7_DEOXY_SUGAR C7_KETOALDONIC_ACID = VariantType.C7_KETOALDONIC_ACID C7_METHYLATED_SUGAR = VariantType.C7_METHYLATED_SUGAR C7_PHOSPHATE = VariantType.C7_PHOSPHATE C7_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C7_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C7_SULFATED_SUGAR = VariantType.C7_SULFATED_SUGAR C7_SULFOAMINO_SUGAR = VariantType.C7_SULFOAMINO_SUGAR C8_ACETYLAMINO_SUGAR = VariantType.C8_ACETYLAMINO_SUGAR C8_AMINO_SUGAR = VariantType.C8_AMINO_SUGAR C8_BRANCH_POINT = VariantType.C8_BRANCH_POINT C8_DEOXY_SUGAR = VariantType.C8_DEOXY_SUGAR C8_KETOALDONIC_ACID = VariantType.C8_KETOALDONIC_ACID C8_METHYLATED_SUGAR = VariantType.C8_METHYLATED_SUGAR C8_PHOSPHATE = VariantType.C8_PHOSPHATE C8_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C8_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C8_SULFATED_SUGAR = VariantType.C8_SULFATED_SUGAR C8_SULFOAMINO_SUGAR = VariantType.C8_SULFOAMINO_SUGAR C9_ACETYLAMINO_SUGAR = VariantType.C9_ACETYLAMINO_SUGAR C9_AMINO_SUGAR = VariantType.C9_AMINO_SUGAR C9_BRANCH_POINT = VariantType.C9_BRANCH_POINT C9_DEOXY_SUGAR = VariantType.C9_DEOXY_SUGAR C9_METHYLATED_SUGAR = VariantType.C9_METHYLATED_SUGAR C9_PHOSPHATE = VariantType.C9_PHOSPHATE C9_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR = VariantType.C9_R3PRIMEHYDROXYBUTYRYLAMINO_SUGAR C9_SULFATED_SUGAR = VariantType.C9_SULFATED_SUGAR C9_SULFOAMINO_SUGAR = VariantType.C9_SULFOAMINO_SUGAR CARBOXYLATION = VariantType.CARBOXYLATION CENTROID_WITH_HA = VariantType.CENTROID_WITH_HA CTERM_CONNECT = VariantType.CTERM_CONNECT CUTPOINT_LOWER = VariantType.CUTPOINT_LOWER CUTPOINT_UPPER = VariantType.CUTPOINT_UPPER C_METHYLAMIDATION = VariantType.C_METHYLAMIDATION DEPROTONATED = VariantType.DEPROTONATED DIIODINATION = VariantType.DIIODINATION DIMETHYLATION = VariantType.DIMETHYLATION DISULFIDE = VariantType.DISULFIDE FIRST_VARIANT = VariantType.UPPER_TERMINUS_VARIANT FIVE_PRIME_END_OH = VariantType.FIVE_PRIME_END_OH FIVE_PRIME_END_PHOSPHATE = VariantType.FIVE_PRIME_END_PHOSPHATE FIVE_PRIME_PACKABLE_PHOSPHATE = VariantType.FIVE_PRIME_PACKABLE_PHOSPHATE FIVE_PRIME_PHOSPHATE = VariantType.FIVE_PRIME_PHOSPHATE HBS_POST = VariantType.HBS_POST HBS_PRE = VariantType.HBS_PRE HYDROXYLATION = VariantType.HYDROXYLATION HYDROXYLATION1 = VariantType.HYDROXYLATION1 HYDROXYLATION2 = VariantType.HYDROXYLATION2 LOWERTERM_TRUNC_VARIANT = VariantType.LOWERTERM_TRUNC_VARIANT LOWER_TERMINUS_VARIANT = VariantType.LOWER_TERMINUS_VARIANT METHYLATED_CTERMINUS_VARIANT = VariantType.METHYLATED_CTERMINUS_VARIANT METHYLATED_NTERM_VARIANT = VariantType.METHYLATED_NTERM_VARIANT METHYLATION = VariantType.METHYLATION METHYL_GLYCOSIDE = VariantType.METHYL_GLYCOSIDE NE2_CONNECT = VariantType.NE2_CONNECT NO_VARIANT = VariantType.NO_VARIANT NTERM_CONNECT = VariantType.NTERM_CONNECT N_ACETYLATION = VariantType.N_ACETYLATION N_VARIANTS = VariantType.N_VARIANTS OOP_POST = VariantType.OOP_POST OOP_PRE = VariantType.OOP_PRE PHOSPHONATE_UPPER_VARIANT = VariantType.PHOSPHONATE_UPPER_VARIANT PHOSPHORYLATION = VariantType.PHOSPHORYLATION PROTONATED = VariantType.PROTONATED PROTONATED_N1_ADENOSINE = VariantType.PROTONATED_N1_ADENOSINE PROTONATED_N3_ADENOSINE = VariantType.PROTONATED_N3_ADENOSINE REPLONLY = VariantType.REPLONLY REPLS_BB = VariantType.REPLS_BB SC_BRANCH_POINT = VariantType.SC_BRANCH_POINT SC_FRAGMENT = VariantType.SC_FRAGMENT SG_CONNECT = VariantType.SG_CONNECT SHOVE_BB = VariantType.SHOVE_BB SIDECHAIN_CONJUGATION = VariantType.SIDECHAIN_CONJUGATION SPECIAL_ROT = VariantType.SPECIAL_ROT SULFATION = VariantType.SULFATION THREE_PRIME_END_OH = VariantType.THREE_PRIME_END_OH THREE_PRIME_FIVE_PRIME_METHYL_PHOSPHATE = VariantType.THREE_PRIME_FIVE_PRIME_METHYL_PHOSPHATE THREE_PRIME_PACKABLE_PHOSPHATE = VariantType.THREE_PRIME_PACKABLE_PHOSPHATE THREE_PRIME_PHOSPHATE = VariantType.THREE_PRIME_PHOSPHATE TRIAZOLAMERC = VariantType.TRIAZOLAMERC TRIAZOLAMERN = VariantType.TRIAZOLAMERN TRIMETHYLATION = VariantType.TRIMETHYLATION UPPERTERM_TRUNC_VARIANT = VariantType.UPPERTERM_TRUNC_VARIANT UPPER_TERMINUS_VARIANT = VariantType.UPPER_TERMINUS_VARIANT URONIC_ACID_VARIANT = VariantType.URONIC_ACID_VARIANT VIRTUAL_BACKBONE_EXCEPT_C1PRIME = VariantType.VIRTUAL_BACKBONE_EXCEPT_C1PRIME VIRTUAL_BASE = VariantType.VIRTUAL_BASE VIRTUAL_BASE_HEAVY_ATOM = VariantType.VIRTUAL_BASE_HEAVY_ATOM VIRTUAL_BB = VariantType.VIRTUAL_BB VIRTUAL_DNA_PHOSPHATE = VariantType.VIRTUAL_DNA_PHOSPHATE VIRTUAL_NTERM = VariantType.N_VARIANTS VIRTUAL_O2PRIME_HYDROGEN = VariantType.VIRTUAL_O2PRIME_HYDROGEN VIRTUAL_PHOSPHATE = VariantType.VIRTUAL_PHOSPHATE VIRTUAL_RESIDUE_VARIANT = VariantType.VIRTUAL_RESIDUE_VARIANT VIRTUAL_RIBOSE = VariantType.VIRTUAL_RIBOSE VIRTUAL_RNA_RESIDUE = VariantType.VIRTUAL_RNA_RESIDUE VIRTUAL_RNA_RESIDUE_EXCLUDE_PHOSPHATE = VariantType.VIRTUAL_RNA_RESIDUE_EXCLUDE_PHOSPHATE VIRTUAL_SIDE_CHAIN = VariantType.VIRTUAL_SIDE_CHAIN ZN_CONNECT = VariantType.ZN_CONNECT   class merge_residue_behavior(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(rosetta.core.chemical.merge_residue_behavior, rosetta.core.chemical.merge_residue_behavior) -> bool __hash__(...) from builtins.PyCapsule __hash__(rosetta.core.chemical.merge_residue_behavior) -> int __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.merge_residue_behavior, int) -> NoneType   2. __init__(rosetta.core.chemical.merge_residue_behavior, int) -> NoneType __int__(...) from builtins.PyCapsule __int__(rosetta.core.chemical.merge_residue_behavior) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.core.chemical.merge_residue_behavior, rosetta.core.chemical.merge_residue_behavior) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __repr__(...) from builtins.PyCapsule __repr__(rosetta.core.chemical.merge_residue_behavior) -> str Data and other attributes defined here: mrb_do_not_merge = merge_residue_behavior.mrb_do_not_merge mrb_merge_w_next = merge_residue_behavior.mrb_merge_w_next mrb_merge_w_prev = merge_residue_behavior.mrb_merge_w_prev