Bindings for core::chemical::gasteiger namespace

Classes
		builtins.object GasteigerAtomTypeData GasteigerAtomTypeSet PossibleAtomTypesForAtom   class GasteigerAtomTypeData(builtins.object)     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////         contains hybridization and bond geometry data, which is used in Atom     Methods defined here: AtomicOrbitalTypes_strings(...) from builtins.PyCapsule AtomicOrbitalTypes_strings() -> rosetta.std.vector_std_string Clone(...) from builtins.PyCapsule Clone(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> rosetta.core.chemical.gasteiger.GasteigerAtomTypeData   Clone function      pointer to new AtomTypeData GetPropertyName(...) from builtins.PyCapsule GetPropertyName(PROPERTY : rosetta.core.chemical.gasteiger.Properties) -> str   element type property as string      the property desired      the property as string __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> NoneType   2. __init__(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, NAME : str, ELEMENT_TYPE : rosetta.core.chemical.Element, HYBRIDIZATION : core::chemical::gasteiger::GasteigerAtomTypeData::HybridOrbitalType, HYBRID_ORBITALS_IN_SIGMA_BONDS : int, HYBRID_ORBITALS_NONBINDING : int, PI_ORBITALS_IN_BONDS : rosetta.std.set_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_std_less_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_std_allocator_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_t, ATOMIC_ORBITALS_NONBINDING : rosetta.std.set_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_std_less_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_std_allocator_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_t, SIGMA_VALENCE_STATE_IONIZATION_POTENTIAL : float, SIGMA_VALENCE_STATE_ELECTRON_AFFINITY : float, PI_VALENCE_STATE_IONIZATION_POTENTIAL : float, PI_VALENCE_STATE_ELECTRON_AFFINITY : float, LONE_PAIR_IONIZATION_POTENTIAL : float, LONE_PAIR_ELECTRON_AFFINITY : float, ATOMIC_POLARIZABILITY : float) -> NoneType   3. __init__(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, NAME : str, ELEMENT : str, HYBRIDIZATION : core::chemical::gasteiger::GasteigerAtomTypeData::HybridOrbitalType, HYBRID_ORBITALS_IN_SIGMA_BONDS : int, HYBRID_ORBITALS_NONBINDING : int, PI_ORBITALS_IN_BONDS : rosetta.std.set_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_std_less_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_std_allocator_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_t, ATOMIC_ORBITALS_NONBINDING : rosetta.std.set_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_std_less_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_std_allocator_core_chemical_gasteiger_GasteigerAtomTypeData_AtomicOrbitalTypes_t, SIGMA_VALENCE_STATE_IONIZATION_POTENTIAL : float, SIGMA_VALENCE_STATE_ELECTRON_AFFINITY : float, PI_VALENCE_STATE_IONIZATION_POTENTIAL : float, PI_VALENCE_STATE_ELECTRON_AFFINITY : float, LONE_PAIR_IONIZATION_POTENTIAL : float, LONE_PAIR_ELECTRON_AFFINITY : float, ATOMIC_POLARIZABILITY : float, ele_set : rosetta.core.chemical.ElementSet) -> NoneType   4. __init__(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, NAME : str, ELEMENT_TYPE : rosetta.core.chemical.Element, CHARGE : int) -> NoneType   5. __init__(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData,  : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> 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.gasteiger.GasteigerAtomTypeData) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData,  : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> rosetta.core.chemical.gasteiger.GasteigerAtomTypeData calculate_stability_metric(...) from builtins.PyCapsule calculate_stability_metric(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> float   calculate the stability metric.  Electronic stability is indicated by a larger number  This is used to decide between atom types when no other means are possible difference_from(...) from builtins.PyCapsule difference_from(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, OTHER : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> rosetta.core.chemical.gasteiger.TypeDifference   determine the difference betweent his atom type data and another      the atom type data to compare this atom type data to      the corresponding TypeDifference get_atom_type_property(...) from builtins.PyCapsule get_atom_type_property(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, PROPERTY : rosetta.core.chemical.gasteiger.Properties) -> float   atom type property as core::Real      the property desired      the property as core::Real get_average_cation_pi_ip_to_neutral_ip_ratio(...) from builtins.PyCapsule get_average_cation_pi_ip_to_neutral_ip_ratio() -> float   get_average_cation_pi_ip_to_neutral_ip_ratio helper function for AtomTypes::CalculateElectronegativityValues      reference to a core::Real, which returns the ratio of Average(PiValenceStateIonizationPotential) for cations vs. neutral atoms get_average_cation_sigma_ip_to_neutral_ip_ratio(...) from builtins.PyCapsule get_average_cation_sigma_ip_to_neutral_ip_ratio() -> float   get_average_cation_sigma_ip_to_neutral_ip_ratio helper function for AtomTypes::CalculateElectronegativityValues      reference to a core::Real, which returns the ratio of Average(SigmaValenceStateIonizationPotential) for cations vs. neutral atoms get_average_ip_change_cation_to_neutral(...) from builtins.PyCapsule get_average_ip_change_cation_to_neutral(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, TYPE_DIFFERENCE : rosetta.core.chemical.gasteiger.TypeDifference) -> float   get the average ionization potential ratio between cation and neutral atom type that differ by TYPE_DIFFERENCE      the type difference to get the corresponding ratio for      the ratio get_average_ip_change_neutral_to_anion(...) from builtins.PyCapsule get_average_ip_change_neutral_to_anion(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, TYPE_DIFFERENCE : rosetta.core.chemical.gasteiger.TypeDifference) -> float   get the average ionization potential ratio between neutral and cation atom type that differ by TYPE_DIFFERENCE      the type difference to get the corresponding ratio for      the ratio get_average_neutral_pi_ip_to_anion_ip_ratio(...) from builtins.PyCapsule get_average_neutral_pi_ip_to_anion_ip_ratio() -> float   get_average_neutral_pi_ip_to_anion_ip_ratio helper function for AtomTypes::CalculateElectronegativityValues      reference to a core::Real, which returns the ratio of Average(PiValenceStateIonizationPotential) for neutral atoms vs. anions get_average_neutral_sigma_ip_to_anion_ip_ratio(...) from builtins.PyCapsule get_average_neutral_sigma_ip_to_anion_ip_ratio() -> float   GetAverageNeutralSigmaIVToEARatio helper function for AtomTypes::CalculateElectronegativityValues      reference to a core::Real, which returns the ratio of Average(SigmaValenceStateIonizationPotential) for neutral atoms vs. anions get_electron_affinity(...) from builtins.PyCapsule get_electron_affinity(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, TYPE_DIFFERENCE : rosetta.core.chemical.gasteiger.TypeDifference) -> float   get the electron affinity type corresponding to a TypeDifference      the type difference to get the corresponding electron affinity for      the electron affinity type corresponding to TypeDifference get_electronegativity(...) from builtins.PyCapsule get_electronegativity(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, TYPE_DIFFERENCE : rosetta.core.chemical.gasteiger.TypeDifference) -> float   get the electronegativity type corresponding to a TypeDifference      the type difference to get the corresponding electronegativity for      the electronegativity type corresponding to TypeDifference get_element_type(...) from builtins.PyCapsule get_element_type(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> rosetta.core.chemical.Element   return ElementType get_formal_charge(...) from builtins.PyCapsule get_formal_charge(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   Charge get_hybrid_orbital_type(...) from builtins.PyCapsule get_hybrid_orbital_type(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> rosetta.core.chemical.gasteiger.HybridOrbitalType   returns the hybridization of the atom type      the type of hybrid orbital get_ionization_potential(...) from builtins.PyCapsule get_ionization_potential(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, TYPE_DIFFERENCE : rosetta.core.chemical.gasteiger.TypeDifference) -> float   get the ionization potential type corresponding to a TypeDifference      the type difference to get the corresponding ionization potential for      the ionization potential type corresponding to TypeDifference get_maxE_contribution_to_pi_system(...) from builtins.PyCapsule get_maxE_contribution_to_pi_system(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   Get the max number of electrons available for contribution to an aromatic ring      the max electrons contributed by this atom type to a pi system get_nNumber_hybrid_lone_pairs(...) from builtins.PyCapsule get_nNumber_hybrid_lone_pairs(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   returns the number of lone pairs in hybrid orbitals      the number of lone pairs in hybrid orbitals get_name(...) from builtins.PyCapsule get_name(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> str   return Name get_number_bonds(...) from builtins.PyCapsule get_number_bonds(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   Number of bonds get_number_electrons_in_bonds(...) from builtins.PyCapsule get_number_electrons_in_bonds(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   get_number_electrons_in_bonds calculates the total number of electrons in pi-orbital and sigma bonds get_number_electrons_in_p_orbitals(...) from builtins.PyCapsule get_number_electrons_in_p_orbitals(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   Number of electrons in p orbitals (whether hybridized or not) get_number_hybrid_bonds(...) from builtins.PyCapsule get_number_hybrid_bonds(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   Number of hybridized bonds get_number_hybrid_orbitals(...) from builtins.PyCapsule get_number_hybrid_orbitals(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   returns the number of hybridized orbitals      the number of hybridized orbitals get_number_pi_orbitals(...) from builtins.PyCapsule get_number_pi_orbitals(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   Number of pi-orbitals get_number_sigma_orbitals(...) from builtins.PyCapsule get_number_sigma_orbitals(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   Number of Sigma orbitals get_number_unhybridized_lone_pairs(...) from builtins.PyCapsule get_number_unhybridized_lone_pairs(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   return Number of unhybridized lone pairs get_number_unhybridized_sigma_orbitals(...) from builtins.PyCapsule get_number_unhybridized_sigma_orbitals(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   Number of Sigma orbitals that are not hybridized get_orbital_E_neg_pos(...) from builtins.PyCapsule get_orbital_E_neg_pos(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> float   the orbital electronegativity associated with the charged state get_pi_electron_contribution_type(...) from builtins.PyCapsule get_pi_electron_contribution_type(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> rosetta.core.chemical.gasteiger.PiContributionType   Get the type of contribution this atom type can make to a pi system      the type of contribution this atom type can make to a pi system get_stability_metric(...) from builtins.PyCapsule get_stability_metric(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> float   Get the stability metric.  Electronic stability is indicated by a larger number  This is used to decide between atom types when no other means are possible get_type_difference_name(...) from builtins.PyCapsule get_type_difference_name(TYPE_DIFFERENCE : rosetta.core.chemical.gasteiger.TypeDifference) -> str   type difference as string      the type difference for which a string is desired      the type difference as a string get_valence_electrons_sp(...) from builtins.PyCapsule get_valence_electrons_sp(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> int   valence electrons in sp orbitals is_conjugated(...) from builtins.PyCapsule is_conjugated(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> bool   determine if this atom type can participate in pi-bond conjugation      true iff this atom type has any non-single bonds or lone pairs is_gasteiger_atom_type(...) from builtins.PyCapsule is_gasteiger_atom_type(rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> bool   is this a well characterized gasteiger atom type      true iff this atom type is this a well characterized gasteiger atom type set_property(...) from builtins.PyCapsule set_property(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, DATA : rosetta.core.chemical.gasteiger.Properties, VALUE : float) -> NoneType   set a particular data      the property to set      the value to set the property to Data and other attributes defined here: AdditiveAtomicPolarizability = Properties.AdditiveAtomicPolarizability AtomicOrbitalTypes = <class 'rosetta.core.chemical.gasteiger.GasteigerAtomTypeData.AtomicOrbitalTypes'> CovalentRadiusAromaticBond = Properties.CovalentRadiusAromaticBond CovalentRadiusDoubleBond = Properties.CovalentRadiusDoubleBond CovalentRadiusSingleBond = Properties.CovalentRadiusSingleBond CovalentRadiusTripleBond = Properties.CovalentRadiusTripleBond Dx2y2 = AtomicOrbitalTypes.Dx2y2 Dxy = AtomicOrbitalTypes.Dxy Dxz = AtomicOrbitalTypes.Dxz Dyz = AtomicOrbitalTypes.Dyz Dz2 = AtomicOrbitalTypes.Dz2 HybridOrbitalType = <class 'rosetta.core.chemical.gasteiger.GasteigerAtomTypeData.HybridOrbitalType'> LonePairElectronAffinity = Properties.LonePairElectronAffinity LonePairElectronegativityMulliken = Properties.LonePairElectronegativityMulliken LonePairIonizationPotential = Properties.LonePairIonizationPotential None = TypeDifference.None NumberBondingPOrbitals = TypeDifference.NumberBondingPOrbitals NumberBondingSOrbitals = TypeDifference.NumberBondingSOrbitals NumberHybridOrbitalType = HybridOrbitalType.NumberHybridOrbitalType NumberLonePairOrbitals = TypeDifference.NumberLonePairOrbitals NumberOfAtomicOrbitalTypes = AtomicOrbitalTypes.NumberOfAtomicOrbitalTypes NumberOfProperties = Properties.NumberOfProperties NumberTypeDifferences = TypeDifference.NumberTypeDifferences One = PiContributionType.One Other = TypeDifference.Other PiContributionType = <class 'rosetta.core.chemical.gasteiger.GasteigerAtomTypeData.PiContributionType'> how the atom type can contribute to a pi system PiOrbitalElectronegativityMulliken = Properties.PiOrbitalElectronegativityMulliken PiOrbitalElectronegativityPauling = Properties.PiOrbitalElectronegativityPauling PiValenceStateElectronAffinity = Properties.PiValenceStateElectronAffinity PiValenceStateIonizationPotential = Properties.PiValenceStateIonizationPotential Properties = <class 'rosetta.core.chemical.gasteiger.GasteigerAtomTypeData.Properties'> enum properties for atom types Px = AtomicOrbitalTypes.Px Py = AtomicOrbitalTypes.Py Pz = AtomicOrbitalTypes.Pz S = AtomicOrbitalTypes.S SP = HybridOrbitalType.SP SP2 = HybridOrbitalType.SP2 SP3 = HybridOrbitalType.SP3 SigmaOrbitalElectronegativityMulliken = Properties.SigmaOrbitalElectronegativityMulliken SigmaOrbitalElectronegativityPauling = Properties.SigmaOrbitalElectronegativityPauling SigmaValenceStateElectronAffinity = Properties.SigmaValenceStateElectronAffinity SigmaValenceStateIonizationPotential = Properties.SigmaValenceStateIonizationPotential Two = PiContributionType.Two TypeDifference = <class 'rosetta.core.chemical.gasteiger.GasteigerAtomTypeData.TypeDifference'> Type difference specifies the difference between two atom types Unhybridized = HybridOrbitalType.Unhybridized VdWaalsRadiusCSD = Properties.VdWaalsRadiusCSD Zero = PiContributionType.Zero ZeroOrTwo = PiContributionType.ZeroOrTwo   class GasteigerAtomTypeSet(builtins.object)     A set of Bcl Atom types     This class contains a vector of pointers each of which points to an Atom 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.gasteiger.GasteigerAtomTypeSet, index : int) -> rosetta.core.chemical.gasteiger.GasteigerAtomTypeData   Lookup an Atom by 1-based indexing __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, element_set : rosetta.std.weak_ptr_const_core_chemical_ElementSet_t) -> NoneType   2. __init__(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, other : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet) -> 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.gasteiger.GasteigerAtomTypeSet,  : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet) -> rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet atom_type(...) from builtins.PyCapsule atom_type(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, atom_type_name : str) -> rosetta.core.chemical.gasteiger.GasteigerAtomTypeData   Lookup the element index by the element_symbol string atom_type_index(...) from builtins.PyCapsule atom_type_index(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, atom_type_name : str) -> int   Lookup the element index by the element_symbol string contains_atom_type(...) from builtins.PyCapsule contains_atom_type(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, atom_type_name : str) -> bool   Check if there is an element_type associated with an element_symbol string element_set(...) from builtins.PyCapsule element_set(rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet) -> rosetta.std.weak_ptr_const_core_chemical_ElementSet_t   Return the associated element type set. n_types(...) from builtins.PyCapsule n_types(rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet) -> int   Number of atom types in the set read_bond_file(...) from builtins.PyCapsule read_bond_file(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, filename : str) -> NoneType read_file(...) from builtins.PyCapsule read_file(self : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, filename : str) -> NoneType   Load the AtomSet from a file type_for_fake_atoms(...) from builtins.PyCapsule type_for_fake_atoms(rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet) -> rosetta.core.chemical.gasteiger.GasteigerAtomTypeData   Return the type that's assigned for fake atoms. (Virtual atoms and the like.)   class PossibleAtomTypesForAtom(builtins.object)     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////         A helper class by which AtomTypes can return all possible atom types for a given atom in a structure        that is easily accessed by orbital type     Methods defined here: AddAromaticAtomType(...) from builtins.PyCapsule AddAromaticAtomType(self : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom, ATOM_TYPE : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData, DESIRED_CHARGE : int) -> NoneType   add an atom type to the search using a set of rules for atom types in aromatic rings      the type of atom to consider      the charge desired  The atom type will be ordered using the distance from the desired charge as the first sort key, second by  the stability.  Unlike AddAtomType, AddAromaticAtomType always adds the type to the considered list AddAtomType(...) from builtins.PyCapsule AddAtomType(self : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom, ATOM_TYPE : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> NoneType   add an atom type to be considered      the type of atom to consider CouldHaveHybridization(...) from builtins.PyCapsule CouldHaveHybridization(self : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom, HYBRID : rosetta.core.chemical.gasteiger.HybridOrbitalType) -> bool   tell whether a particular hybrid orbital type is possible given what we know about this atom      the type of hybrid orbital      true iff there is a possible atom type for that hybrid orbital Finalize(...) from builtins.PyCapsule Finalize(rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom) -> NoneType   Select the best choice for the atom type wherever possible FinalizeAromatic(...) from builtins.PyCapsule FinalizeAromatic(self : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom, DESIRED_CHARGE : int) -> NoneType   only keep the most stable types for the atom that span the set of desired pi orbital electrons (0-2)      the preferred charge  used during construction of the maps when there is no part of standardization that  should edit this class FinalizeUnhybridized(...) from builtins.PyCapsule FinalizeUnhybridized(rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom) -> NoneType   choose the preferred atom type (using VSEPR theory) assuming that the orbitals do not hybridize      This is used for elements in group 1, 2, & 7, which do hybridize in the gasteiger scheme FindPossibleAtomTypesForAtom(...) from builtins.PyCapsule FindPossibleAtomTypesForAtom(GASTEIGER_ATOM_TYPE_SET : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, ELEMENT : rosetta.core.chemical.Element, NUMBER_ELECTRONS_IN_BONDS : int, NUMBER_BONDS : int, SUSPECTED_CHARGE : int, IN_AROMATIC_RING : bool) -> rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom   constructor from the known information about the atom      element type,      number of electrons in bonds for the atom type      number of bonds for the atom      expected charge, ignored if no atom type matching the other criteria if found      true iff the atom has bonds of the aromatic unspecified type GetMostStableType(...) from builtins.PyCapsule GetMostStableType(rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom) -> rosetta.core.chemical.gasteiger.GasteigerAtomTypeData   return the most stable type      the most stable type - NULL if no such type exists GetNumberPossibleTypes(...) from builtins.PyCapsule GetNumberPossibleTypes(rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom) -> int   return the number of types that the atom has the potential to become      the number of types that the atom has the potential to become RemoveHybridization(...) from builtins.PyCapsule RemoveHybridization(self : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom, HYBRID : rosetta.core.chemical.gasteiger.HybridOrbitalType) -> NoneType   remove a particular hybrid orbital type from the possible types, unless that would remove all possibilities      the type of hybrid orbital to remove SetToType(...) from builtins.PyCapsule SetToType(self : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom, ATOM_TYPE : rosetta.core.chemical.gasteiger.GasteigerAtomTypeData) -> NoneType   set this object to only consider the given atom type      the atom type desired __init__(...) from builtins.PyCapsule __init__(rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom) -> 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.gasteiger.PossibleAtomTypesForAtom,  : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom) -> rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom gasteiger_atom_type_set(...) from builtins.PyCapsule gasteiger_atom_type_set(self : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom, GASTEIGER_ATOM_TYPE_SET : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet) -> NoneType hybridization_rank(...) from builtins.PyCapsule hybridization_rank(self : rosetta.core.chemical.gasteiger.PossibleAtomTypesForAtom, hybrid : rosetta.core.chemical.gasteiger.HybridOrbitalType) -> int   ///////////////////// / helper functions // /////////////////////

Functions
		assign_gasteiger_atom_types(...) method of builtins.PyCapsule instance assign_gasteiger_atom_types(*args, **kwargs) Overloaded function.   1. assign_gasteiger_atom_types(restype : rosetta.core.chemical.ResidueType, gasteiger_atom_type_set : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, keep_existing : bool) -> NoneType   2. assign_gasteiger_atom_types(restype : rosetta.core.chemical.ResidueType, gasteiger_atom_type_set : rosetta.core.chemical.gasteiger.GasteigerAtomTypeSet, keep_existing : bool, allow_unknown : bool) -> NoneType   3. assign_gasteiger_atom_types(restype : rosetta.core.chemical.ResidueType) -> NoneType   Version which gets typeset from ResidueType, or just uses default   4. assign_gasteiger_atom_types(restype : rosetta.core.chemical.ResidueType, keep_existing : bool) -> NoneType   Version which gets typeset from ResidueType, or just uses default   5. assign_gasteiger_atom_types(restype : rosetta.core.chemical.ResidueType, keep_existing : bool, allow_unknown : bool) -> NoneType   Version which gets typeset from ResidueType, or just uses default