Mercurial > repos > deepakjadmin > mayatool3_test2
diff docs/modules/txt/Atom.txt @ 0:4816e4a8ae95 draft default tip
Uploaded
| author | deepakjadmin |
|---|---|
| date | Wed, 20 Jan 2016 09:23:18 -0500 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/modules/txt/Atom.txt Wed Jan 20 09:23:18 2016 -0500 @@ -0,0 +1,1523 @@ +NAME + Atom + +SYNOPSIS + use Atom; + +DESCRIPTION + Atom class provides the following methods: + + new, AddHydrogens, Copy, DeleteAtom, DeleteHydrogens, + DoesAtomNeighborhoodMatch, GetAtomicInvariantValue, GetAtomicWeight, + GetBondToAtom, GetBonds, GetBondsToHeavyAtoms, GetBondsToHydrogenAtoms, + GetBondsToNonHydrogenAtoms, GetExactMass, GetExplicitHydrogens, + GetFormalCharge, GetFreeRadicalElectrons, GetGroupNumber, + GetHeavyAtomNeighbors, GetHeavyAtomNeighborsAtomInformation, + GetHeavyAtomNeighborsBondformation, GetHighestCommonValence, + GetHydrogenAtomNeighbors, GetHydrogens, GetImplicitHydrogens, + GetLargestBondOrder, GetLargestBondOrderToHeavyAtoms, + GetLargestBondOrderToNonHydrogenAtoms, GetLargestRing, + GetLowestCommonValence, GetMassNumber, GetMissingHydrogens, + GetNeighbors, GetNeighborsUsingAtomSpecification, + GetNonHydrogenAtomNeighbors, GetNonHydrogenAtomNeighborsAtomInformation, + GetNonHydrogenAtomNeighborsBondInformation, + GetNonHydrogenNeighborOfHydrogenAtom, GetNumOfAromaticBondsToHeavyAtoms, + GetNumOfAromaticBondsToNonHydrogenAtoms, GetNumOfBondTypesToHeavyAtoms, + GetNumOfBondTypesToNonHydrogenAtoms, GetNumOfBonds, + GetNumOfBondsToHeavyAtoms, GetNumOfBondsToHydrogenAtoms, + GetNumOfBondsToNonHydrogenAtoms, GetNumOfDoubleBondsToHeavyAtoms, + GetNumOfBondsAvailableForHeavyAtoms, + GetNumOfBondsAvailableForNonHydrogenAtoms, + GetNumOfDoubleBondsToNonHydrogenAtoms, GetNumOfExplicitHydrogens, + GetNumOfHeavyAtomNeighbors, GetNumOfHydrogenAtomNeighbors, + GetNumOfHydrogens, GetNumOfImplicitHydrogens, GetNumOfMissingHydrogens, + GetNumOfNeighbors, GetNumOfNonHydrogenAtomNeighbors, GetNumOfRings, + GetNumOfRingsWithEvenSize, GetNumOfRingsWithOddSize, + GetNumOfRingsWithSize, GetNumOfRingsWithSizeGreaterThan, + GetNumOfRingsWithSizeLessThan, GetNumOfSigmaAndPiBondsToHeavyAtoms, + GetNumOfSigmaAndPiBondsToNonHydrogenAtoms, + GetNumOfSingleBondsToHeavyAtoms, GetNumOfSingleBondsToNonHydrogenAtoms, + GetNumOfTripleBondsToHeavyAtoms, GetNumOfTripleBondsToNonHydrogenAtoms, + GetPeriodNumber, GetPotentialTotalCommonValence, GetRings, + GetRingsWithEvenSize, GetRingsWithOddSize, GetRingsWithSize, + GetRingsWithSizeGreaterThan, GetRingsWithSizeLessThan, + GetSizeOfLargestRing, GetSizeOfSmallestRing, GetSmallestRing, + GetSpinMultiplicity, GetSumOfBondOrders, GetSumOfBondOrdersToHeavyAtoms, + GetSumOfBondOrdersToHydrogenAtoms, GetSumOfBondOrdersToNonHydrogenAtoms, + GetValence, GetValenceElectrons, GetValenceFreeElectrons, GetX, GetXYZ, + GetXYZVector, GetY, GetZ, IsAmideCarbon, IsAmideNitrogen, IsAromatic, + IsArsenic, IsBondedToAtom, IsBromine, IsCarbon, IsCarboxylCarbon, + IsCarboxylOxygen, IsCarboxylateCarbon, IsCarboxylateOxygen, IsChlorine, + IsFluorine, IsFunctionalClassType, IsGuadiniumCarbon, + IsGuadiniumNitrogen, IsHBondAcceptor, IsHBondDonor, IsHalogen, + IsHeteroAtom, IsHydrogen, IsHydrogenBondAcceptor, IsHydrogenBondDonor, + IsHydrophobic, IsInRing, IsInRingOfSize, IsIodine, IsIsotope, + IsLipophilic, IsMetallic, IsNegativelyIonizable, IsNitrogen, + IsNonCarbonOrHydrogen, IsNotInRing, IsOnlyInOneRing, IsOxygen, + IsPhosphateOxygen, IsPhosphatePhosphorus, IsPhosphorus, IsPolarAtom, + IsPolarHydrogen, IsPositivelyIonizable, IsSaturated, IsSelenium, + IsSilicon, IsStereoCenter, IsSulfur, IsSulphur, IsTellurium, IsTerminal, + IsTopologicalPharmacophoreType, IsUnsaturated, SetAtomSymbol, + SetAtomicNumber, SetExplicitHydrogens, SetMassNumber, SetStereoCenter, + SetStereochemistry, SetX, SetXYZ, SetY, SetZ, StringifyAtom + + Atom class is derived from ObjectProperty base class which provides + methods not explicitly defined in Atom or ObjectProperty class using + Perl's AUTOLOAD functionality. These methods are generated on-the-fly + for a specified object property: + + Set<PropertyName>(<PropertyValue>); + $PropertyValue = Get<PropertyName>(); + Delete<PropertyName>(); + + METHODS + new + $NewAtom = new Atom([%PropertyNameAndValues]); + + Using specified *Atom* property names and values hash, new method + creates a new object and returns a reference to newly created Atom + object. By default, following properties are initialized: + + ID = SequentialObjectID + Name = "Atom <SequentialObjectID>" + AtomSymbol = "" + AtomicNumber = 0 + XYZ = ZeroVector + + Except for *ID* property, all other default properties and other + additional properties can be set during invocation of this method. + + Examples: + + $Atom = new Atom(); + $CarbonAtom = new Atom('AtomSymbol' => 'C', 'XYZ' => (0.0, 1.0, + 0.0)); + $OxygenAtom = new Atom('AtomName' => 'Oxygen', AtomSymbol' => 'O', + 'XYZ' => (1.0, 1.0, 1.0)); + + AddHydrogens + $NumOfHydrogensAdded = $Atom->AddHydrogens(); + + Adds hydrogens to an Atom present in a Molecule object and returns + the number of added hydrogens. The current release of MayaChemTools + doesn't assign hydrogen positions. + + Copy + $AtomCopy = $Atom->Copy(); + + Copy *Atom* and its associated data using Storable::dclone and + return a new Atom object. + + DeleteAtom + $Atom->DeleteAtom(); + + Delete *Atom* from a molecule. + + DoesAtomNeighborhoodMatch + $Status = $Atom->DoesAtomNeighborhoodMatch($CentralAtomSpec); + $Status = $Atom->DoesAtomNeighborhoodMatch($CentralAtomSpec, + $NbrAtomSpecsRef); + $Status = $Atom->DoesAtomNeighborhoodMatch($CentralAtomSpec, + $NbrAtomSpecsRef, $AllowedNbrBondSpecsRef); + $Status = $Atom->DoesAtomNeighborhoodMatch($CentralAtomSpec, + $NbrAtomSpecsRef, $NbrBondSpecsRef, + $AllowedNbrOfNbrAtomSpecsRef); + + Returns 1 or 0 based on whether atom matches central atom and its + neighborhood using specified atom and bonds specifications. + Neighborhood atom and bond specifications are specified as array + references containing neighbor atom and bond specifications. + + Let: + + AS = Atom symbol corresponding to element symbol, atomic number (#n) + or any atom (A) + + X<n> = Number of non-hydrogen atom neighbors or heavy atoms + attached to atom + T<n> = Total number of atom neighbors including implicit and explicit + hydrogens + BO<n> = Sum of bond orders to non-hydrogen atom neighbors or heavy + atoms attached to atom + LBO<n> = Largest bond order of non-hydrogen atom neighbors or heavy + atoms attached to atom + SB<n> = Number of single bonds to non-hydrogen atom neighbors or + heavy atoms attached to atom + TSB<n> = Total number of single bonds to atom neighbors including implicit + and explicit hydrogens + DB<n> = Number of double bonds to non-hydrogen atom neighbors or + heavy atoms attached to atom + TB<n> = Number of triple bonds to non-hydrogen atom neighbors or + heavy atoms attached to atom + AB<n> = Number of aromatic bonds to non-hydrogen atom neighbors or + heavy atoms attached to atom + H<n> = Number of implicit and explicit hydrogens for atom + Ar = Aromatic annotation indicating whether atom is aromatic + RA or RA<n> = Ring atom annotation indicating whether atom + is a ring + TR<n> = Total number of rings containing atom + FC<+n/-n> = Formal charge assigned to atom + MN<n> = Mass number indicating isotope other than most abundant isotope + SM<n> = Spin multiplicity of atom. Possible values: 1 (singlet), + 2 (doublet) or 3 (triplet) + + Then, atom specification corresponds to: + + AS.X<n>.T<n>.BO<n>.LBO<n>.<SB><n>.TSB<n>.<DB><n>.<TB><n>.AB<n>.H<n>.Ar. + RA<n>.TR<n>FC<+n/-n>.MN<n>.SM<n> + + Except for AS which is a required atomic invariant in atom + specification, all other atomic invariants are optional. For an atom + specification to match an atom, the values of all specified atomic + invariants must match. Exclamation in from of atomic invariant can + be used to negate its effect during the match. + + For *FC* value matching, the following value operators are also + supported: + + o +* : Any positive value + o -* : Any negative value + o > ValidNumber or >= ValidNumber + o < ValidNumber or <= ValidNumber + + A comma delimited atom specification string is used to match any one + of the specified atom specification. + + Notes: + + o During atom specification match to an atom, the first atomic invariant is always assumed to + atom symbol. + + Examples: + + o ('N', 'N', 'N') + o ('N.FC0', 'N.FC0', 'N,N.FC+1.H1') + o ('N.H2', 'N.H2', 'N.H1') + o ('C,N', '!N', '!H') + o ('C,N', 'N.Ar', 'N.R5') + + Let: + + -|1|s|Single = Single bond + =|2|d|Double = Double bond + #|3|t|Triple = Triple bond + :|1.5|a|Ar|Aromatic = Aromatic bond + + @|RB|Ring = Ring bond + ~|*|Any = Any bond + + Then, bond specification corresponds to: + + -.: + =.@ + Double.Aromatic + + For a bond specification to match bond between two atoms, the values + of all specified bond symbols must match. Exclamation in from of + bond symbol can be used to negate its effect during the match. + + A comma delimited bond specification string is used to match any one + of the specified atom specification. + + Notes: + + o During atom neighborhood match for central atom neighborhood atom and bond specifications, + implicit or missing hydrogens are automatically checked for any matches to unmatched + specifications. + + Examples: + + Aromatic carbon in a 5 membered ring: + $Atom->DoesAtomNeighborhoodMatch('C.Ar.RA5'); + + AcetylenicCarbon: $Atom->DoesAtomNeighborhoodMatch('C.T2.TB1'); or + $Atom->DoesAtomNeighborhoodMatch('C.T2.TB1', + ['*', '*'], ['#', '-']); + + GuadiniumCarbon: $Atom->DoesAtomNeighborhoodMatch('C.X3.BO4', + ['N.FC0', 'N.FC0', 'N.FC0,N.FC+1'], + ['-', '-', '='], + ['C,H', 'C,H', 'C,H']); + + AmideCarbon: $Atom->DoesAtomNeighborhoodMatch('C.X3.BO4,C.X2.BO3', + ['C,H', 'O', 'N'], + ['-', '=', '-'], + ['C,H', 'C', 'C,H,N,O,S,P,F,Cl,Br,I']); + + CarboxylCarbon: $Atom->DoesAtomNeighborhoodMatch('C.X3.BO4,C.X2.BO3', + ['C,H', 'O', 'O.X1.FC0'], + ['-', '=', '-'], + ['C,H', 'C', 'C']); + + CarboxylateCarbon: $Atom->DoesAtomNeighborhoodMatch('C.X3.BO4,C.X2.BO3', + ['C,H', 'O', 'O.X1.FC-1'], + ['-', '=', '-'], + ['C,H', 'C', 'C']); + + DeleteHydrogens + $NumOfHydrogensDeleted = $Atom->AddHydrogens(); + + Delete hydrogens from an Atom present in a Molecule object and + returns the number of deleted hydrogens. + + GetAtomicInvariantValue + $Value = $Atom->GetAtomicInvariantValue($AtomicInvariant); + + Returns atomic invariant value for a specified *AtomicInvariant*. + The current release of MayaChemTools supports following + abbreviations and descriptive names for *AtomicInvarints*: + + AS : Atom or element symbol + X : NumOfNonHydrogenAtomNeighbors or NumOfHeavyAtomNeighbors + T : TotalNumOfAtomNeighbors + BO : SumOfBondOrdersToNonHydrogenAtoms or SumOfBondOrdersToHeavyAtoms + LBO : LargestBondOrderToNonHydrogenAtoms or LargestBondOrderToHeavyAtoms + SB : NumOfSingleBondsToNonHydrogenAtoms or NumOfSingleBondsToHeavyAtoms + TSB : TotalNumOfSingleBonds + DB : NumOfDoubleBondsToNonHydrogenAtoms or NumOfDoubleBondsToHeavyAtoms + TB : NumOfTripleBondsToNonHydrogenAtoms or NumOfTripleBondsToHeavyAtoms + AB : NumOfAromaticBondsToNonHydrogenAtoms or NumOfAromaticBondsToHeavyAtoms + H : NumOfImplicitAndExplicitHydrogens + Ar : Aromatic + Str : Stereochemistry + RA : RingAtom + FC : FormalCharge + AN : AtomicNumber + AM : AtomicMass + MN : MassNumber + SM : SpinMultiplicity + + GetAtomicWeight + $Value = $Aom->GetAtomicWeight(); + + Returns atomic weight of an Atom which corresponds to either + explicity set *AtomicWeight* atom property or atomic weight of the + corresponding element in the periodic table available by + PeriodicTable module. + + GetBondToAtom + $Bond = $Atom->GetBondToAtom($OtherAtom); + + Returns a Bond object corresponding to bond between *Atom* and + *OtherAtom* in a molecule. + + GetBonds + @Bonds = $Aoto->GetBonds(); + + Returns an array of Bond objects corresponding to all bonds from + *Atom* to other bonded atoms in a molecule. + + GetBondsToHeavyAtoms + @Bonds = $Atom->GetBondsToHeavyAtoms(); + + Returns an array of Bond objects corresponding to bonds from *Atom* + to other bonded non-hydrogen atoms in a molecule. + + GetBondsToHydrogenAtoms + @Bonds = $Atom->GetBondsToHydrogenAtoms(); + + Returns an array of Bond objects corresponding to bonds from *Atom* + to any other hydrogen atom in a molecule. + + GetBondsToNonHydrogenAtoms + @Bonds = $Atom->GetBondsToNonHydrogenAtoms(); + + Returns an array of Bond objects corresponding to bonds from *Atom* + to other bonded non-hydrogen atoms in a molecule. + + GetExactMass + $ExactMass = $Atom->GetExactMass(); + + Returns exact mass of an *Atom* which correspond to one of these + three values: explicity set *ExactMass* property; mass of natural + isotope for an explicty set value of *MassNumber*; most abundant + natural isotope mass for *Atom* with valid atomic number value + available by PerodicTable module. + + GetExplicitHydrogens + $NumOfExplicitHydrogens = $Atom->GetExplicitHydrogens(); + + Returns number of hydrogens explicity bonded to an *Atom* in a + molecule. + + GetFormalCharge + $FormalCharge = $Atom->GetFormalCharge(); + + Returns formal charge of an *Atom* in a molecule. + + GetFreeRadicalElectrons + $FreeRadicalElectrons = $Atom->GetFreeRadicalElectrons(); + + Returns number of free radical electrons corresponding to to one of + these three values: *FreeRadicalElectrons* property; + *SpinMultiplicity* property; value of 0. + + For atoms with explicit assignment of *SpinMultiplicity* atom + property values, + + Singlet - two unparied electrons corresponding to one spin state + Doublet - free radical; an unpaired electron corresponding to two + spin states + Triplet - two unparied electrons corresponding to three spin states + (divalent carbon atoms: carbenes) + + FreeRadicalElectrons are calculated as follows: + + Doublet: 1 (one valence electron not available for bonding) + Singlet: 2 (two valence electrons not available for bonding) + Triplet: 2 (two valence electrons not available for bonding) + + GetGroupNumber + $GroupNumber = $Atom->GetGroupNumber(); + + Returns group number of an *Atom* in a molecule with a valid atomic + number. + + GetHeavyAtomNeighbors + $NumOfHeavyAtoms = $Atom->GetHeavyAtomNeighbors(); + @HeavyAtoms = $Atom->GetHeavyAtomNeighbors(); + + Return number of heavy atoms or an array of Atom objects + corresponding to heavy atoms bonded to an *Atom* in a molecule. + + GetHeavyAtomNeighborsAtomInformation + ($NumOfAtomNeighbors, $AtomNeighborsRef, + $NumOfAtomNeighborsType, $AtomNeighborsTypeMapRef) = $Atom-> + GetHeavyAtomNeighborsAtomInformation(); + + Returns atoms information for all non-hydrogen atoms attached to an + *Atom* in a molecule. + + The following values are returned: + + o Number of non-hydrogen atom neighbors + o A reference to an array containing atom objects corresponding to + non-hydrogen atom neighbors + o Number of different types of non-hydrogen atom neighbors + o A reference to a hash containing atom symbol as key with value + corresponding to its count for non-hydrogen atom neighbors + + GetHeavyAtomNeighborsBondformation + ($NumOfBonds, $BondTypeCountMapRef, + $AtomsBondTypesCountMapRef, + $AtomsBondTypeAtomsMap) = $Atom-> + GetHeavyAtomNeighborsBondformation(); + + Returns bonds information for all non-hydrogen atoms attached to an + *Atom* in a molecule. + + The following values are returned: + + o Number of bonds to non-hydrogen atom neighbors + o A reference to an array containing bond objects corresponding to + non-hydrogen atom neighbors + o A reference to a hash containing bond type as key with value + corresponding to its count for non-hydrogen atom neighbors. Bond + types are: Single, Double or Triple + o A reference to a hash containing atom symbol as key pointing to bond + type as second key with values corresponding to count of bond types for atom + symbol for non-hydrogen atom neighbors + o A reference to a hash containing atom symbol as key pointing to bond + type as second key with values corresponding to atom objects array involved + in corresponding bond type for atom symbol for non-hydrogen atom neighbors + + GetHighestCommonValence + $HighestCommonValence = $Atom->GetHighestCommonValence(); + + Returns highest common valence of an *Atom* which corresponds to + either explicity set *HighestCommonValence* atom property or highest + common valence of the corresponding element in the periodic table + available by PerodicTable module. + + GetHydrogens + $NumOfHydrogens = $Atom->GetHydrogens(); + + Returns total number of hydrogens for an *Atom* in a molecule + including both hydrogen atom neighbors and implicit hydrogens. + + GetHydrogenAtomNeighbors + $NumOfHydrogenAtomNeighbors = $Atom->GetHydrogenAtomNeighbors(); + @HydrogenAtomNeighbors = $Atom->GetHydrogenAtomNeighbors(); + + Return number of hydrogen atoms or an array of *Atom* objects + corresponding to hydrogen atoms bonded to an *Atom* in a molecule. + + GetImplicitHydrogens + $NumOfImplicitHydrogens = $Atom->GetImplicitHydrogens(); + + Returns number of implicit hydrogens for an *Atom* in a molecule. + This value either corresponds to explicitly set *ImplicitHydrogens* + atom property or calculated as the difference between the value of + potential total valence and sum of bond orders to both hydrogen and + non-hydrogen atom neighbors. + + GetPotentialTotalCommonValence + $PotentialTotalValence = $Atom->GetPotentialTotalCommonValence(); + + Returns potential total common valence of an *Atom* in a molecule + corresponding to a specific valence model set for the molecule using + its SetValenceModel method or default internal valence model. It is + used during the calculation of missing or implicit hydrogens. + + The current release of MayaChemTools supports three valence models: + *MDLValenceModel, DaylightValenceModel, InternalValenceModel or + MayaChemToolsValenceModel*. + + For *MDLValenceModel* and *DaylightValenceModel*, the following data + files, distributed with the package, are used to calculate potential + total valence: + + lib/data/MDLValenceModelData.csv + lib/data/DaylightValenceModelData.csv + + The calculation of potential total common valence for these two + models is performed as follows: Calculate current effective total + valence of the *Atom* by adding up the bond order of its neighbors + and number of free radical electrons; Find available common valence + for the *Atom*, corresponding to any specified formal charge, higher + than the effective total valence, and return it as + *PotentialTotalValence*. + + The calculation of potential total common valence For + *InternalValenceModel* or *MayaChenToolsValenceModel* doesn't uses + PeriodicTable module to retrieve values for common valence, which in + turn reads in PeriodicTableElements.csv file distributed with the + package. + + For elements with one one common valence, potential total common + valence corresponds to: + + CommonValence + FormalCharge - FreeRadicalElectrons + + For elements with multiple common valences, each common valence is + used to calculate total potential common valence as shown above, and + the first total potential common valence greater than the sum of + bond orders to all neighbors is selected as the final total common + valence. + + FormalCharge sign is reversed for electropositive elements with + positive formal charge during common valence calculations. + Electropositive elements, metals and transition elements, have + usually plus formal charge and it leads to decrease in common + valence; the negative formal charge should result in the decrease of + common valence. + + The sign of formal charge is adjusted as follows. + + Group numbers > 14 - Group numbers 15 (N), 16 (O), 17 (F), 18 (He): + + Formal charge sign is not adjusted. Positive and negative values + result in the increase and decrease of valence. + + Group 14 containing C, Si, Ge, Sn, Pb...: + + Formal charge sign is reversed for positive values. Both positive + and negative values result in the decrease of valence. + + Group 13 containing B, Al, Ga, In, Tl...: + + Formal charge sign is always reversed. Positive and negative values + result in the decrease and increase of valence. + + Groups 1 (H) through 12 (Zn)...: + + Formal charge sign is reversed for positive values. Both positive + and negative values result in the decrease of valence. + + Lanthanides and actinides: + + Formal charge sign is reversed for positive values. Both positive + and negative values result in the decrease of valence. + + GetLargestBondOrder + $LargestBO =$Atom->GetLargestBondOrder(); + + Returns largest bond order for an *Atom* among the bonds to other + atoms in a molecule. + + GetLargestBondOrderToHeavyAtoms + $LargestBO =$Atom->GetLargestBondOrderToHeavyAtoms(); + + Returns largest bond order for an *Atom* among the bonds to other + heavy atoms in a molecule. + + GetLargestBondOrderToNonHydrogenAtoms + $LargestBO =$Atom->GetLargestBondOrderToNonHydrogenAtoms(); + + Returns largest bond order for an *Atom* among the bonds to other + non-hydrogen atoms in a molecule. + + GetLargestRing + @RingAtoms = $Atom->GetLargestRing(); + + Returns an array of ring *Atom* objects corresponding to the largest + ring containing *Atom* in a molecule. + + GetLowestCommonValence + $LowestCommonValence = $Atom->GetLowestCommonValence(); + + Returns lowest common valence of an *Atom* which corresponds to + either explicity set *LowestCommonValence* atom property or highest + common valence of the corresponding element in the periodic table + available by PerodicTable module. + + GetMassNumber + $MassNumber = $Aom->GetMassNumber(); + + Returns atomic weight of an Atom which corresponds to either + explicity set *MassNumber* atom property or mass number of the most + abundant natural isotope of the corresponding element in the + periodic table available by PeriodicTable module. + + GetMissingHydrogens + $NumOfMissingHydrogens = $Atom->GetMissingHydrogens(); + + Returns number of missing hydrogens for an *Atom* in a molecule. + This value either corresponds to explicitly set *ImplicitHydrogens* + atom property or calculated as the difference between the value of + potential total valence and sum of bond orders to both hydrogen and + non-hydrogen atom neighbors. + + GetNeighbors + $NumOfNeighbors = $Atom->GetNeighbors(); + @Neighbors = $Atom->GetNeighbors(); + + Returns number of neighbor atoms or an array of *Atom* objects + corresponding to all atoms bonded to an *Atom* in a molecule. + + GetNeighborsUsingAtomSpecification + @AtomNeighbors = $Atom->GetNeighborsUsingAtomSpecification($AtomSpec); + $NumOfNeighbors = $Atom->GetNeighborsUsingAtomSpecification($AtomSpec); + + @AtomNeighbors = $Atom->GetNeighborsUsingAtomSpecification($AtomSpec, + @ExcludeNeighbors); + + Returns number of neighbor atoms or an array of *Atom* objects + matching atom specification corresponding to atom neighbors of an + *Atom* in a molecule. Optionally, *Atom* neighbors can be excluded + from the neighbors list using *ExcludeNeighbors*. + + Notes: + + o AtomSpecification correspond to any valid AtomicInvariant based atomic specifications + as supported by DoesAtomNeighborhoodMatch method + o Multiple atom specifications can be used in a string delimited by comma + + GetNonHydrogenAtomNeighbors + $NumOfNeighbors = $Atom->GetNonHydrogenAtomNeighbors(); + @Neighbors = $Atom->GetNonHydrogenAtomNeighbors(); + + Returns number of non-hydrogen atoms or an array of Atom objects + corresponding to non-hydrogen atoms bonded to an *Atom* in a + molecule. + + GetNonHydrogenAtomNeighborsAtomInformation + ($NumOfAtomNeighbors, $AtomNeighborsRef, + $NumOfAtomNeighborsType, $AtomNeighborsTypeMapRef) = $Atom-> + GetNonHydrogenAtomNeighborsAtomInformation(); + + Returns atoms information for all non-hydrogen atoms attached to an + *Atom* in a molecule. + + The following values are returned: + + o Number of non-hydrogen atom neighbors + o A reference to an array containing atom objects corresponding to + non-hydrogen atom neighbors + o Number of different types of non-hydrogen atom neighbors + o A reference to a hash containing atom symbol as key with value + corresponding to its count for non-hydrogen atom neighbors + + GetNonHydrogenAtomNeighborsBondInformation + ($NumOfBonds, $BondTypeCountMapRef, + $AtomsBondTypesCountMapRef, + $AtomsBondTypeAtomsMap) = $Atom-> + GetNonHydrogenAtomNeighborsBondInformation(); + + Returns bonds information for all non-hydrogen atoms attached to an + *Atom* in a molecule. + + The following values are returned: + + o Number of bonds to non-hydrogen atom neighbors + o A reference to an array containing bond objects corresponding to + non-hydrogen atom neighbors + o A reference to a hash containing bond type as key with value + corresponding to its count for non-hydrogen atom neighbors. Bond + types are: Single, Double or Triple + o A reference to a hash containing atom symbol as key pointing to bond + type as second key with values corresponding to count of bond types for atom + symbol for non-hydrogen atom neighbors + o A reference to a hash containing atom symbol as key pointing to bond + type as second key with values corresponding to atom objects array involved + in corresponding bond type for atom symbol for non-hydrogen atom neighbors + + GetNonHydrogenNeighborOfHydrogenAtom + $Atom = $Atom->GetNonHydrogenNeighborOfHydrogenAtom(); + + Returns non-hydrogen or heavy atom neighbor of a hydrogen atom in a + molecule.. + + GetNumOfAromaticBondsToHeavyAtoms + $NumOfBonds = $Atom->GetNumOfAromaticBondsToHeavyAtoms(); + + Returns number of aromatic bonds from an *Atom* to other + non-hydrogen or heavy atoms in a molecule. + + GetNumOfAromaticBondsToNonHydrogenAtoms + $NumOfBonds = $Atom->GetNumOfAromaticBondsToNonHydrogenAtoms(); + + Returns number of aromatic bonds from an *Atom* to other + non-hydrogen or heavy atoms in a molecule. + + GetNumOfBonds + $NumOfBonds = $Atom->GetNumOfBonds(); + + Returns number of bonds from an *Atom* to other atoms in a molecule. + + GetNumOfBondsAvailableForHeavyAtoms + $NumOfBonds = $Atom->GetNumOfBondsAvailableForHeavyAtoms(); + + Get number of bonds available to form additional bonds with heavy + atoms, excluding any implicit bonds to hydrogens set using + *ImplicitHydrogens* property. + + It's different from number of implicit or missing hydrogens, both of + which are equivalent. + + For example, in a SMILES string, [nH] ring atom corresponds to an + aromatic nitrogen. Although the hydrogen specified for n is treated + internally as implicit hydrogen and shows up in missing hydrogen + count, it's not available to participate in double bonds to + additional heavy atoms. + + GetNumOfBondsAvailableForNonHydrogenAtoms + $NumOfBonds = $Atom->GetNumOfBondsAvailableForNonHydrogenAtoms(); + + Get number of bonds available to form additional bonds with heavy + atoms, excluding any implicit bonds to hydrogens set using + ImplicitHydrogens property. + + GetNumOfBondsToHeavyAtoms + $NumOfBondsToHeavyAtoms = $Atom->GetNumOfBondsToHeavyAtoms(); + + Returns number of bonds from an *Atom* to other heavy atoms in a + molecule. + + GetNumOfBondsToHydrogenAtoms + $NumOfBonds = $Atom->GetNumOfBondsToHydrogenAtoms(); + + Returns number of bonds from an *Atom* to other hydrogen atoms in a + molecule. + + GetNumOfBondsToNonHydrogenAtoms + $NumOfBonds = $Atom->GetNumOfBondsToNonHydrogenAtoms(); + + Returns number of bonds from an *Atom* to other non-hydrogen atoms + in a molecule. + + GetNumOfBondTypesToHeavyAtoms + ($NumOfSingleBonds, $NumOfDoubleBonds, + $NumOfTripleBonds, $NumOfAromaticBonds) = $Atom-> + GetNumOfBondTypesToHeavyAtoms($CountAromaticBonds); + + Get number of single, double, triple, and aromatic bonds from an + *Atom* to all other non-hydrogen atoms in a molecule. + + Value of *CountAtomaticBonds* parameter controls whether number of + aromatic bonds is returned; default is not to count aromatic bonds. + During counting of aromatic bonds, the bond marked aromatic is not + included in the count of other bond types. + + GetNumOfBondTypesToNonHydrogenAtoms + ($NumOfSingleBonds, $NumOfDoubleBonds, + $NumOfTripleBonds, $NumOfAromaticBonds) = $Atom-> + GetNumOfBondTypesToNonHydrogenAtoms($CountAromaticBonds); + + Get number of single, double, triple, and aromatic bonds from an + *Atom* to all other non-hydrogen atoms in a molecule. + + Value of *CountAtomaticBonds* parameter controls whether number of + aromatic bonds is returned; default is not to count aromatic bonds. + During counting of aromatic bonds, the bond marked aromatic is not + included in the count of other bond types. + + GetNumOfDoubleBondsToHeavyAtoms + $NumOfDoubleBonds = $Atom->GetNumOfDoubleBondsToHeavyAtoms(); + + Returns number of double bonds from an *Atom* to other heavy atoms + or non-hydrogen atoms in a molecule. + + GetNumOfDoubleBondsToNonHydrogenAtoms + $NumOfDoubleBonds =$Atom->GetNumOfDoubleBondsToNonHydrogenAtoms(); + + Returns number of double bonds from an *Atom* to other heavy atoms + or non-hydrogen atoms in a molecule. + + GetNumOfHeavyAtomNeighbors + $NumOfNeighbors = $Atom->GetNumOfHeavyAtomNeighbors(); + + Returns number heavy atom neighbors for an *Atom* in a molecule. + + GetNumOfHydrogenAtomNeighbors + $NumOfNeighbors = $Atom->GetNumOfHydrogenAtomNeighbors(); + + Returns number hydrogens atom neighbors for an *Atom* in a molecule. + + GetNumOfMissingHydrogens + $NumOfMissingHydrogens = $Atom->GetNumOfMissingHydrogens(); + + Returns number of implicit hydrogens for an *Atom* in a molecule. + This value either corresponds to explicitly set *ImplicitHydrogens* + atom property or calculated as the difference between the value of + potential total valence and sum of bond orders to both hydrogen and + non-hydrogen atom neighbors. + + GetNumOfExplicitHydrogens + $NumOfExplicitHydrogens = $Atom->GetNumOfExplicitHydrogens(); + + Returns number hydrogens atom neighbors for an *Atom* in a molecule. + + GetNumOfHydrogens + $NumOfHydrogens = $Atom->GetNumOfHydrogens(); + + Returns total number of hydrogens for an *Atom* in a molecule + including both hydrogen atom neighbors and implicit hydrogens. + + GetNumOfImplicitHydrogens + $NumOfImplicitHydrogens = $Atom->GetNumOfImplicitHydrogens(); + + Returns number of implicit hydrogens for an *Atom* in a molecule. + This value either corresponds to explicitly set *ImplicitHydrogens* + atom property or calculated as the difference between the value of + potential total valence and sum of bond orders to both hydrogen and + non-hydrogen atom neighbors. + + GetNumOfNeighbors + $NumOfNeighbors = $Atom->GetNumOfNeighbors(); + + Returns number atom neighbors for an *Atom* in a molecule. + + GetNumOfNonHydrogenAtomNeighbors + $NumNeighbors = $This->GetNumOfNonHydrogenAtomNeighbors(); + + Returns number non-hydrogens atom neighbors for an *Atom* in a + molecule. + + GetNumOfRings + $NumOfRings = $Atom->GetNumOfRings(); + + Returns number of rings containing *Atom* in a molecule. + + GetNumOfRingsWithEvenSize + $NumOfRings = $Atom->GetNumOfRingsWithEvenSize(); + + Returns number of rings with even size containing *Atom* in a + molecule. + + GetNumOfRingsWithOddSize + $NumOfRings = $Atom->GetNumOfRingsWithOddSize(); + + Returns number of rings with odd size containing *Atom* in a + molecule. + + GetNumOfRingsWithSize + $NumOfRings = $Atom->GetNumOfRingsWithSize($RingSize); + + Returns number of rings with specific *RingSize* containing *Atom* + in a molecule. + + GetNumOfRingsWithSizeGreaterThan + $NumOfRings = $Atom->GetNumOfRingsWithSizeGreaterThan($RingSize); + + Returns number of rings with size greater than specific *RingSize* + containing *Atom* in a molecule. + + GetNumOfRingsWithSizeLessThan + $NumOfRings = $Atom->GetNumOfRingsWithSizeLessThan($RingSize); + + Returns number of rings with size less than specific *RingSize* + containing *Atom* in a molecule. + + GetNumOfSigmaAndPiBondsToHeavyAtoms + ($NumOfSigmaBonds, $NumOfPiBonds) = $Atom-> + GetNumOfSigmaAndPiBondsToHeavyAtoms(); + + Get number of sigma and pi bonds from an *Atom* to all other + non-hydrogen atoms in a molecule. + + Sigma and pi bonds are counted using the following methodology: a + single bond correspond to one sigma bond; a double bond contributes + one to sigma bond count and one to pi bond count; a triple bond + contributes one to sigma bond count and two to pi bond count. + + GetNumOfSigmaAndPiBondsToNonHydrogenAtoms + ($NumOfSigmaBonds, $NumOfPiBonds) = $Atom-> + GetNumOfSigmaAndPiBondsToNonHydrogenAtoms(); + + Get number of sigma and pi bonds from an *Atom* to all other + non-hydrogen atoms in a molecule. + + Sigma and pi bonds are counted using the following methodology: a + single bond correspond to one sigma bond; a double bond contributes + one to sigma bond count and one to pi bond count; a triple bond + contributes one to sigma bond count and two to pi bond count. + + GetNumOfSingleBondsToNonHydrogenAtoms + $NumOfSingleBonds =$Atom->GetNumOfSingleBondsToNonHydrogenAtoms(); + + Returns number of single bonds from an *Atom* to other heavy atoms + or non-hydrogen atoms in a molecule. + + GetNumOfSingleBondsToHeavyAtoms + $NumOfSingleBonds = $Atom->GetNumOfSingleBondsToHeavyAtoms(); + + Returns number of single bonds from an *Atom* to other heavy atoms + or non-hydrogen atoms in a molecule. + + GetNumOfTripleBondsToNonHydrogenAtoms + $NumOfTripleBonds =$Atom->GetNumOfTripleBondsToNonHydrogenAtoms(); + + Returns number of triple bonds from an *Atom* to other heavy atoms + or non-hydrogen atoms in a molecule. + + GetNumOfTripleBondsToHeavyAtoms + $NumOfTripleBonds = $Atom->GetNumOfTripleBondsToHeavyAtoms(); + + Returns number of triple bonds from an *Atom* to other heavy atoms + or non-hydrogen atoms in a molecule. + + GetPeriodNumber + $PeriodNumber = $Atom->GetPeriodNumber(); + + Returns periodic table period number for an *Atom* in a molecule + with a valid atomic number . + + GetRings + @Rings = $Aotm->GetRings(); + + Returns an array of references to arrays containing ring atoms + corressponding to all rings containing *Atom* in a molecule. + + GetRingsWithEvenSize + @Rings = $Aotm->GetRingsWithEvenSize(); + + Returns an array of references to arrays containing ring atoms + corressponding to all rings with even size containing *Atom* in a + molecule. + + GetRingsWithOddSize + @Rings = $Aotm->GetRingsWithOddSize(); + + Returns an array of references to arrays containing ring atoms + corressponding to all rings with odd size containing *Atom* in a + molecule. + + GetRingsWithSize + @Rings = $Aotm->GetRingsWithSize($RingSize); + + Returns an array of references to arrays containing ring atoms + corressponding to all rings with specific *RingSize *containing + *Atom* in a molecule. + + GetRingsWithSizeGreaterThan + @Rings = $Aotm->GetRingsWithSizeGreaterThan($RingSize); + + Returns an array of references to arrays containing ring atoms + corressponding to all rings with size greater than specific + *RingSize *containing *Atom* in a molecule. + + GetRingsWithSizeLessThan + @Rings = $Aotm->GetRingsWithSizeLessThan($RingSize); + + Returns an array of references to arrays containing ring atoms + corressponding to all rings with size less than specific *RingSize + *containing *Atom* in a molecule. + + GetSizeOfLargestRing + $Size = $Atom->GetSizeOfLargestRing(); + + Returns size of the largest ring containing *Atom* in a molecule. + + GetSizeOfSmallestRing + $Size = $Atom->GetSizeOfSmallestRing(); + + Returns size of the smallest ring containing *Atom* in a molecule. + + GetSmallestRing + @RingAtoms = $Atom->GetSmallestRing(); + + Returns an array of ring *Atom* objects corresponding to the largest + ring containing *Atom* in a molecule. + + GetSpinMultiplicity + $SpinMultiplicity = $Atom->GetSpinMultiplicity(); + + Returns spin multiplicity of an *Atom* corresponding to one of these + three values: explicitly set SpinMultiplicity property value; + calculated from FreeRadicalElectrons property; value of 0. + + The SpinMultiplicity is calculate from *FreeRadicalElectrons* + property as follows: + + FreeRadicalElectrons: 1; SpinMultiplicity: 2 + FreeRadicalElectrons: 2; SpinMultiplicity: 1 + FreeRadicalElectrons: other; SpinMultiplicity: 0 + + GetSumOfBondOrders + $SumBondOrders = $Atom->GetSumOfBondOrders(); + + Returns sum of bond orders corresponding to all atoms bonded to an + *Atom* in a molecule. + + GetSumOfBondOrdersToHeavyAtoms + $SumBondOrders = $Atom->GetSumOfBondOrdersToHeavyAtoms(); + + Returns sum of bond orders corresponding to all heavy atoms bonded + to an *Atom* in a molecule. + + GetSumOfBondOrdersToHydrogenAtoms + $SumBondOrders = $Atom->GetSumOfBondOrdersToHydrogenAtoms(); + + Returns sum of bond orders corresponding to all hydrogen atoms + bonded to an *Atom* in a molecule. + + GetSumOfBondOrdersToNonHydrogenAtoms + $SumBondOrders = $Atom->GetSumOfBondOrdersToNonHydrogenAtoms(); + + Returns sum of bond orders corresponding to all non-hydrogen atoms + bonded to an *Atom* in a molecule. + + GetValence + $Valence = $Atom->GetValence(); + + Returns valence of an *Atom* in a molecule. Valence corresponds to + number of electrons used by an atom in bonding: + + Valence = ValenceElectrons - ValenceFreeElectrons = BondingElectrons + + Single, double and triple bonds with bond orders of 1, 2, and 3 + correspond to contribution of 1, 2, and 3 bonding electrons. So: + + Valence = SumOfBondOrders + NumOfMissingHydrogens + FormalCharge + + where positive and negative values of FormalCharge increase and + decrease the number of bonding electrons, respectively. + + The current release of MayaChemTools supports the following three + valence models, which are used during calculation of implicit + hydrogens: MDLValenceModel, DaylightValenceModel, + InternalValenceModel or MayaChemToolsValenceModel. + + Notes: + + . Missing hydrogens are included in the valence. + . For neutral molecules, valence and sum of bond orders are equal. + . For molecules containing only single bonds, SumOfBondOrders and + NumOfBonds are equal. + . Free radical electrons lead to the decrease in valence. For atoms with + explicit assignment of SpinMultiplicity property values corresponding to + Singlet (two unparied electrons corresponding to one spin state), Doublet + (free radical; an unpaired electron corresponding to two spin states), + and Triplet (two unparied electrons corresponding to three spin states; + divalent carbon atoms (carbenes)), FreeRadicalElectrons are calculated as follows: + + SpinMultiplicity: Doublet(2); FreeRadicalElectrons: 1 (one valence + electron not available for bonding) + SpinMultiplicity: Singlet(1)/Triplet(3); FreeRadicalElectrons: 2 (two + valence electrons not available for bonding) + + GetValenceElectrons + $ValenceElectrons = $Atom->GetValenceElectrons(); + + Returns valence electrons for an Atom which corresponds to either + explicity set *ValenceElectrons* atom property or valence electrons + for the corresponding element in the periodic table available by + PeriodicTable module. + + GetValenceFreeElectrons + $ValenceFreeElectrons = $Atom->GetValenceFreeElectrons(); + $ValenceFreeElectrons = $Atom->GetValenceFreeElectrons( + $ExcludeFreeRadicalElectrons); + + Returns valence frees electrons for an Atom in a molecule. It + corresponds to: + + ValenceElectrons - Valence + or + ValenceElectrons - NumOfMissingHydrogens - SumOfBondOrders - FormalCharge + + Free radical electrons are included in the valence free electrons + count by default. + + Examples: + + NH3: ValenceFreeElectrons = 5 - 3 = 5 - 3 - 0 - 0 = 2 + NH2: ValenceFreeElectrons = 5 - 3 = 5 - 2 - 1 - 0 = 2 + NH4+; ValenceFreeElectrons = 5 - 5 = 5 - 4 - 0 - 1 = 0 + NH3+; ValenceFreeElectrons = 5 - 5 = 5 - 3 - 1 - 1 = 0 + C(=O)O- : ValenceFreeElectrons on O- = 6 - 0 = 6 - 1 - 0 - (-1) = 6 + C(=O)O- : ValenceFreeElectrons on =O = 6 - 2 = 6 - 2 - 0 - 0 = 4 + + GetX + $X = $Atom->GetX(); + + Returns value of X-coordinate for an *Atom*. + + GetXYZ + @XYZ = $Atom->GetXYZ(); + $XYZRef = $Atom->GetXYZ(); + + Returns an array or a reference to an array containing values for + *Atom* coordinates. + + GetXYZVector + $XYZVector = $Atom->GetXYZVector(); + + Returns a *Vector* object containing values for *Atom* coordinates + + GetY + $Y = $Atom->GetY(); + + Returns value of Y-coordinate for an *Atom*. + + GetZ + $Z = $Atom->GetZ(); + + Returns value of Z-coordinate for an *Atom*. + + IsAmideCarbon + $Status = $Atom->IsAmideCarbon(); + + Returns 1 or 0 based on whether it's amide carbon *Atom*. + + An amide group is defineds as: + + R-C(=O)-N(-R')-R'' + + where: + + o R = Hydrogen or groups of atoms attached through carbon + o R' = Hydrogens or groups of atoms attached through carbon or + hetro atoms + o R'' = Hydrogens or groups of atoms attached through carbon or + hetro atoms + + IsAmideNitrogen + $Status = $Atom->IsAmideNitrogen(); + + Returns 1 or 0 based on whether it's amide nitrogen *Atom*. + + IsAromatic + $Status = $Atom->IsAromatic(); + + Returns 1 or 0 based on whether it's an aromatic *Atom*. + + IsArsenic + $Status = $Atom->IsArsenic(); + + Returns 1 or 0 based on whether it's an arsenic *Atom*. + + IsBondedToAtom + $Status = $Atom->IsBondedToAtom($OtherAtom); + + Returns 1 or 0 based on whether *Atom* is bonded to *OtherAtom*. + + IsBromine + $Status = $Atom->IsBromine(); + + Returns 1 or 0 based on whether it's a bromine *Atom*. + + IsCarbon + $Status = $Atom->IsCarbon(); + + Returns 1 or 0 based on whether it's a carbon *Atom*. + + IsCarboxylCarbon + $Status = $Atom->IsCarboxylCarbon(); + + Returns 1 or 0 based on whether it's a carboxyl carbon atom in + carboxyl group: R-C(=O)-OH. + + IsCarboxylOxygen + $Status = $Atom->IsCarboxylOxygen(); + + Returns 1 or 0 based on whether it's a carboxyl oxygen atom in + carboxyl group: R-C(=O)-OH. + + IsCarboxylateCarbon + $Status = $Atom->IsCarboxylateCarbon(); + + Returns 1 or 0 based on whether it's a carboxylate carbon atom in + carboxyl group: R-C(=O)-O-. + + IsCarboxylateOxygen + $Status = $Atom->IsCarboxylateOxygen(); + + Returns 1 or 0 based on whether it's a carboxylate oxygen atom in + carboxyl group: R-C(=O)-O-. + + IsChlorine + $Status = $Atom->IsChlorine(); + + Returns 1 or 0 based on whether it's a chlorine *Atom*. + + IsFluorine + $Status = $Atom->IsFluorine(); + + Returns 1 or 0 based on whether it's a fluorine *Atom*. + + IsFunctionalClassType + $Status =$Atom->IsFunctionalClassType($Type); + + Returns 1 or 0 based on whether it's a specified functional class + *Type*. + + The current release of MayaChemTools supports following + abbreviations and descriptive names for *FunctionalClassType*: + + HBD: HydrogenBondDonor + HBA: HydrogenBondAcceptor + PI : PositivelyIonizable + NI : NegativelyIonizable + Ar : Aromatic + Hal : Halogen + H : Hydrophobic + RA : RingAtom + CA : ChainAtom + + The following definitions are used to determine functional class + types: [ Ref 60-61, Ref 65-66 ]: + + HydrogenBondDonor: NH, NH2, OH + HydrogenBondAcceptor: N[!H], O + PositivelyIonizable: +, NH2 + NegativelyIonizable: -, C(=O)OH, S(=O)OH, P(=O)OH + + IsGuadiniumCarbon + $Status = $Atom->IsGuadiniumCarbon(); + + Returns 1 or 0 based on whether it's a guadinium carbon in guadinium + group by checking its neighbors for a nitrogen in guadinium group. + + IsGuadiniumNitrogen + $Status = $Atom->IsGuadiniumNitrogen(); + + Returns 1 or 0 based on whether it's a guadinium nitrogen in + guadinium group. + + A guadinium group is defined as: + + R2N-C(=NR)-(NR2) or R2N-C(=NR2+)-(NR2) + + where: + + o R = Hydrogens or group of atoms attached through carbon + o Only one of the three nitrogens has a double bond to carbon + and has optional formal charge allowing it to be neutral or charged state + + IsHBondAcceptor + $Status =$Atom->IsHBondAcceptor(); + $Status =$Atom->IsHBondAcceptor($HydrogenBondsType); + + Returns 1 or 0 based on whether it's a hydrogen bond acceptor + *Atom*. + + IsHBondDonor + $Status =$Atom->IsHBondDonor(); + $Status =$Atom->IsHBondDonor($HydrogenBondsType); + + Returns 1 or 0 based on whether it's a hydrogen bond donor *Atom*. + + IsHydrogenBondAcceptor + $Status =$Atom->IsHydrogenBondAcceptor(); + $Status =$Atom->IsHydrogenBondAcceptor($HydrogenBondsType); + + Returns 1 or 0 based on whether it's a hydrogen bond acceptor + *Atom*. + + IsHydrogenBondDonor + $Status =$Atom->IsHydrogenBondDonor(); + $Status =$Atom->IsHydrogenBondDonor($HydrogenBondsType); + + Returns 1 or 0 based on whether it's a hydrogen bond donor *Atom*. + + The current release of MayaChemTools supports identification of two + types of hydrogen bond donor and acceptor atoms with these names: + + HBondsType1 or HydrogenBondsType1 + HBondsType2 or HydrogenBondsType2 + + The names of these hydrogen bond types are rather arbitrary. + However, their definitions have specific meaning and are as follows: + + HydrogenBondsType1 [ Ref 60-61, Ref 65-66 ]: + + Donor: NH, NH2, OH - Any N and O with available H + Acceptor: N[!H], O - Any N without available H and any O + + HydrogenBondsType2 [ Ref 91 ]: + + Donor: NH, NH2, OH - N and O with available H + Acceptor: N, O - And N and O + + By default, *HydrogenBondsType1* is used to calculate number + hydrogen bond donor and acceptor atoms. *HydrogenBondsType2* + corresponds to RuleOf5 definition of hydrogen bond donors and + acceptors. + + IsHalogen + $Status =$Atom->IsHalogen(); + + Returns 1 or 0 based on whether it's a halogen *Atom*. + + IsHeteroAtom + $Status = $Atom->IsHeteroAtom(); + + Returns 0 or 1 based on whether it's a hetro *Atom*. Following atoms + are considered hetro atoms: N, O, F, P, S, Cl, Br, I. + + IsHydrogen + $Status = $Atom->IsHydrogen(); + + Returns 1 or 0 based on whether it's a hydrogen *Atom*. + + IsHydrophobic + $Status =$Atom->IsHydrophobic(); + + Returns 1 or 0 based on whether it's a hydrophobic *Atom*. + + IsInRing + $Status = $Atom->IsInRing(); + + Returns 1 or 0 based on whether *Atom* is present in a ring. + + IsInRingOfSize + $Status = $Atom->IsInRingOfSize($Size); + + Returns 1 or 0 based on whether *Atom* is present in a ring of + specific *Size*. + + IsIodine + $Status = $Atom->IsIodine(); + + Returns 1 or 0 based on whether it's an iodine *Atom*. + + IsIsotope + $Status =$Atom->IsIsotope(); + + Returns 1 or 0 based on whether it's an isotope *Atom*. + + IsLipophilic + $Status =$Atom->IsLipophilic(); + + Returns 1 or 0 based on whether it's a lipophilic *Atom*. + + IsMetallic + $Status = $Atom->IsMetallic(); + + Returns 1 or 0 based on whether it's a metallic *Atom*. + + IsNegativelyIonizable + $Status =$Atom->IsNegativelyIonizable(); + + Returns 1 or 0 based on whether it's a negatively ionizable atom + *Atom*. + + IsNitrogen + $Status = $Atom->IsNitrogen(); + + Returns 1 or 0 based on whether it's a nitrogen *Atom*. + + IsNonCarbonOrHydrogen + $Status =$Atom->IsNonCarbonOrHydrogen(); + + Returns 1 or 0 based on whether it's not a carbon or hydrogen + *Atom*. + + IsNotInRing + $Status = $Atom->IsNotInRing(); + + Returns 1 or 0 based on whether *Atom* is not present in a ring. + + IsOnlyInOneRing + $Status = $Atom->IsOnlyInOneRing(); + + Returns 1 or 0 based on whether *Atom* is only present in one ring. + + IsOxygen + $Status = $Atom->IsOxygen(); + + Returns 0 or 1 based on whether it's an oxygen *Atom*. + + IsPhosphorus + $Status = $Atom->IsPhosphorus(); + + Returns 0 or 1 based on whether it's a phosphorus *Atom*. + + IsPhosphateOxygen + $Status = $Atom->IsPhosphateOxygen(); + + Returns 1 or 0 based on whether it's a phosphate oxygen in phosphate + group. + + A phosphate group is defined as: + + AO-(O=)P(-OA)-OA + + Where: + + A - Any group of atoms including hydrogens + + IsPhosphatePhosphorus + $Status = $Atom->IsPhosphatePhosphorus(); + + Returns 1 or 0 based on whether it's a phosphate phosphorus in + phosphate group. + + IsPolarAtom + $Status = $Atom->IsPolarAtom(); + + Returns 0 or 1 based on whether it's a polar *Atom*. Following atoms + are considered polar atoms: N, O, P, S. + + IsPolarHydrogen + $Status = $Atom->IsPolarHydrogen(); + + Returns 0 or 1 based on whether it's a hydrogen *Atom* bonded to a + polar atom. + + IsPositivelyIonizable + $Status =$Atom->IsPositivelyIonizable(); + + Returns 1 or 0 based on whether it's a positively ionizable *Atom*. + + IsSaturated + $Status = $Atom->IsSaturated(); + + Returns 1 or 0 based on whether it's a saturated *Atom*. An atom + attached to other atoms with only single bonds is considered a + saturated atom. + + IsSelenium + $Status = $Atom->IsSelenium(); + + Returns 0 or 1 based on whether it's a selenium *Atom*. + + IsStereoCenter + $Status = $Atom->IsStereoCenter(); + + Returns 0 or 1 based on whether it's marked as a stero center *Atom* + by explicit setting of *StereoCenter* atom propert to value of *1*. + + IsSilicon + $Status = $Atom->IsSilicon(); + + Returns 0 or 1 based on whether it's a silicon *Atom*. + + IsSulfur + $Status = $Atom->IsSulfur(); + + Returns 0 or 1 based on whether it's a sulfur *Atom*. + + IsSulphur + $Status = $Atom->IsSulphur(); + + Returns 0 or 1 based on whether it's a sulfur *Atom*. + + IsTellurium + $Status = $Atom->IsTellurium(); + + Returns 0 or 1 based on whether it's a tellurium *Atom*. + + IsTerminal + $Status = $Atom->IsTerminal(); + + Returns 0 or 1 based on whether it's a terminal *Atom* attached to + no more than one non-hydrogen atom. + + IsUnsaturated + $Status = $Atom->IsUnsaturated(); + + Returns 1 or 0 based on whether it's as unsaturated *Atom*. An atom + attached to other atoms with at least one non-single bond is + considered an unsaturated atom. + + IsTopologicalPharmacophoreType + $Status =$Atom->IsTopologicalPharmacophoreType(); + + Returns 1 or 0 based on whether it's any of the supportyed + topological pharmacophore *Atom* type. See *IsFunctionalClassType* + for a list of supported types. + + SetAtomSymbol + $Atom->SetAtomSymbol($AtomicSymbol); + + Sets atom symbol for *Atom* and returns *Atom* object. The + appropriate atomic number is also set automatically. + + SetAtomicNumber + $Atom->SetAtomicNumber($AtomicNumber); + + Sets atomic number for *Atom* and returns *Atom* object. The + appropriate atom symbol is also set automatically. + + SetMassNumber + $Atom->SetMassNumber($MassNumber); + + Sets mass number for *Atom* and returns *Atom* object. + + SetStereoCenter + $Atom->SetStereoCenter($StereoCenter); + + Sets stereo center for *Atom* and returns *Atom* object. + + SetStereochemistry + $Atom->SetStereochemistry($Stereochemistry); + + Sets stereo chemistry for *Atom* and returns *Atom* object. + + SetX + $Atom->SetX($Value); + + Sets X-coordinate value for *Atom* and returns *Atom* object. + + SetXYZ + $Atom->SetXYZ(@XYZValues); + $Atom->SetXYZ($XYZValuesRef); + $Atom->SetXYZ($XYZVector); + + Sets *Atom* coordinates using an array, reference to an array or a + *Vector* object and returns *Atom* object. + + SetY + $Atom->SetY($Value); + + Sets Y-coordinate value for *Atom* and returns *Atom* object. + + SetZ + $Atom->SetZ($Value); + + Sets Z-coordinate value for *Atom* and returns *Atom* object. + + StringifyAtom + $AtomString = $Atom->StringifyAtom(); + + Returns a string containing information about *Atom* object. + +AUTHOR + Manish Sud <msud@san.rr.com> + +SEE ALSO + Bond.pm, Molecule.pm, MoleculeFileIO.pm + +COPYRIGHT + Copyright (C) 2015 Manish Sud. All rights reserved. + + This file is part of MayaChemTools. + + MayaChemTools is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 3 of the License, or (at + your option) any later version. +