diff docs/modules/txt/Molecule.txt @ 0:4816e4a8ae95 draft default tip

Uploaded

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/docs/modules/txt/Molecule.txt	Wed Jan 20 09:23:18 2016 -0500
@@ -0,0 +1,988 @@
+NAME
+    Molecule - Molecule class
+
+SYNOPSIS
+    use Molecule;
+
+    use Molecule qw(:all);
+
+DESCRIPTION
+    Molecule class provides the following methods:
+
+    new, AddAtom, AddAtoms, AddBond, AddBonds, AddHydrogens,
+    AddPolarHydrogens, ClearRings, Copy, DeleteAromaticity, DeleteAtom,
+    DeleteAtoms, DeleteBond, DeleteBonds, DeleteHydrogens,
+    DeletePolarHydrogens, DetectAromaticity, DetectRings,
+    FormatElementalCompositionInformation, GetAllAtomPaths,
+    GetAllAtomPathsStartingAt, GetAllAtomPathsStartingAtWithLength,
+    GetAllAtomPathsStartingAtWithLengthUpto, GetAllAtomPathsWithLength,
+    GetAllAtomPathsWithLengthUpto, GetAromaticRings, GetAromaticityModel,
+    GetAtomNeighborhoods, GetAtomNeighborhoodsWithRadiusUpto,
+    GetAtomNeighborhoodsWithSuccessorAtoms,
+    GetAtomNeighborhoodsWithSuccessorAtomsAndRadiusUpto, GetAtomPathBonds,
+    GetAtomPaths, GetAtomPathsBetween, GetAtomPathsStartingAt,
+    GetAtomPathsStartingAtWithLength, GetAtomPathsStartingAtWithLengthUpto,
+    GetAtomPathsWithLength, GetAtomPathsWithLengthUpto, GetAtoms, GetBonds,
+    GetCharge, GetConnectedComponents, GetConnectedComponentsAtoms,
+    GetDimensionality, GetElementalComposition, GetElementsAndNonElements,
+    GetExactMass, GetFormalCharge, GetFreeRadicalElectrons,
+    GetFusedAndNonFusedRings, GetLargestConnectedComponent,
+    GetLargestConnectedComponentAtoms, GetLargestRing, GetMolecularFormula,
+    GetMolecularWeight, GetNumOfAromaticRings, GetNumOfAtoms, GetNumOfBonds,
+    GetNumOfConnectedComponents, GetNumOfElementsAndNonElements,
+    GetNumOfHeavyAtoms, GetNumOfHydrogenAtoms, GetNumOfMissingHydrogenAtoms,
+    GetNumOfNonHydrogenAtoms, GetNumOfRings, GetNumOfRingsWithEvenSize,
+    GetNumOfRingsWithOddSize, GetNumOfRingsWithSize,
+    GetNumOfRingsWithSizeGreaterThan, GetNumOfRingsWithSizeLessThan,
+    GetRingBonds, GetRingBondsFromRings, GetRings, GetRingsWithEvenSize,
+    GetRingsWithOddSize, GetRingsWithSize, GetRingsWithSizeGreaterThan,
+    GetRingsWithSizeLessThan, GetSizeOfLargestRing, GetSizeOfSmallestRing,
+    GetSmallestRing, GetSpinMultiplicity, GetSupportedAromaticityModels,
+    GetTopologicallySortedAtoms, GetValenceModel, HasAromaticAtomsInRings,
+    HasAromaticAtomsNotInRings, HasAromaticRings, HasAtom, HasBond,
+    HasFusedRings, HasNoRings, HasOnlyOneRing, HasRings, IsAromatic,
+    IsMolecule, IsRingAromatic, IsSupportedAromaticityModel,
+    IsThreeDimensional, IsTwoDimensional, KeepLargestComponent,
+    KekulizeAromaticAtoms, NewAtom, NewBond, SetActiveRings,
+    SetAromaticityModel, SetID, SetValenceModel, StringifyMolecule
+
+    The following methods can also be used as functions:
+
+    FormatElementalCompositionInformation, IsMolecule
+
+    Molecule class is derived from ObjectProperty base class which provides
+    methods not explicitly defined in Molecule 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
+            $NewMolecule = new Molecule([%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, the following properties are initialized:
+
+            ID = SequentialObjectID
+            Name = "Molecule <SequentialObjectID>"
+
+        Examples:
+
+            $Molecule = new Molecule();
+
+            $WaterMolecule = new Molecule('Name' => 'Water');
+
+            $Oxygen = new Atom('AtomSymbol' => 'O', 'XYZ' => [0, 0, 0]);
+            $Hydrogen1 = new Atom('AtomSymbol' => 'H',
+                                  'XYZ' => [0.7144, 0.4125, 0]);
+            $Hydrogen2 = new Atom('AtomSymbol' => 'H',
+                                  'XYZ' => [1.1208, -0.2959, 0]);
+            $WaterMolecule->AddAtoms($Oxygen, $Hydrogen1, $Hydrogen2);
+
+            $Bond1 = new Bond('Atoms' => [$Oxygen, $Hydrogen1],
+                              'BondOrder' => 1);
+            $Bond2 = new Bond('Atoms' => [$Oxygen, $Hydrogen2],
+                              'BondOrder' => 1);
+            $WaterMolecule->AddBonds($Bond1, $Bond2);
+
+    AddAtom
+            $Molecule->AddAtom($Atom);
+
+        Adds an *Atom* to a *Molecule* and returns *Molecule*.
+
+    AddAtoms
+            $Molecule->AddAtoms(@Atoms);
+
+        Adds *Atoms* to a *Molecule* and returns *Molecule*.
+
+    AddBond
+            $Molecule->AddBond($Bond);
+
+        Adds a *Bond* to a *Molecule* and returns *Molecule*.
+
+    AddBonds
+            $Molecule->AddBonds(@Bonds);
+
+        Adds *Bonds* to a *Molecule* and returns *Molecule*.
+
+    AddHydrogens
+            $NumOfHydrogensAdded = $Molecule->AddHydrogens();
+
+        Adds hydrogens to each atom in a *Molecule* and returns total number
+        of hydrogens added. The current release of MayaChemTools doesn't
+        assign hydrogen positions.
+
+    AddPolarHydrogens
+            $NumOfHydrogensAdded = $Molecule->AddPolarHydrogens();
+
+        Adds hydrogens to each polar atom - N, O, P or S - in a *Molecule*
+        and returns total number of polar hydrogens added. The current
+        release of MayaChemTools doesn't assign hydrogen positions.
+
+    ClearRings
+            $Molecule->ClearRings();
+
+        Deletes all rings associated with *Molecule* and returns *Molecule*.
+
+    Copy
+            $MoleculeCopy = $Molecule->Copy();
+
+        Copies *Molecule* and its associated data using Storable::dclone and
+        returns a new Molecule object.
+
+    DeleteAromaticity
+            $Molecule->DeleteAromaticity();
+
+        Deletes aromatic property associated with all atoms and bonds in a
+        *Molecule* and returns *Molecule*.
+
+    DeleteAtom
+            $Molecule->DeleteAtom($Atom);
+
+        Deletes *Atom* from a *Molecule* and returns *Molecule*.
+
+    DeleteAtoms
+            $Molecule->DeleteAtoms(@Atoms);
+
+        Deletes *Atoms* from a *Molecule* and returns *Molecule*.
+
+    DeleteBond
+            $Molecule->DeleteBond($Bond);
+
+        Deletes *Bond* from a *Molecule* and returns *Molecule*.
+
+    DeleteBonds
+            $Molecule->DeleteBonds(@Bonds);
+
+        Deletes *Bonds* from a *Molecule* and returns *Molecule*.
+
+    DeleteHydrogens
+            $NumOfHydrogensDeleted = $Molecule->DeleteHydrogens();
+
+        Removes hydrogens from each atom in a *Molecule* and returns total
+        number of hydrogens deleted.
+
+    DeletePolarHydrogens
+            $NumOfHydrogensDeleted = $Molecule->DeletePolarHydrogens();
+
+        Removes hydrogens to each polar atom - N, O, P or S - in a
+        *Molecule* and returns total number of polar hydrogens deleted.
+
+    DetectAromaticity
+            $Molecule->DetectAromaticity();
+
+        Associates *Aromatic* property to atoms and bonds involved in
+        aromatic rings or ring systems in a *Molecule* and returns
+        *Molecule*.
+
+        This method assumes the ring detection has already been perfomed
+        using DetectRings. And any existing *Aromatic* property associated
+        with atoms and bonds is deleted before performing aromaticity
+        detection.
+
+        What is aromaticity? [ Ref 124 ] It's in the code of the
+        implementer, did you say? Agree. The implementation of aromaticity
+        varies widely across different packages [ Ref 125 ]; additionally,
+        the implementation details are not always completely available, and
+        it's not possible to figure out the exact implementation of
+        aromaticity across various packages. Using the publicly available
+        information, however, one can try to reproduce the available results
+        to the extent possible, along with parameterizing all the control
+        parameters used to implement different aromaticity models, and
+        that's exactly what the current release of MayaChemTools does.
+
+        The implementation of aromaticity corresponding to various
+        aromaticity models in MayaChemTools package is driven by an external
+        CSV file AromaticityModelsData.csv, which is distributed with the
+        package and is available in lib/data directory. The CSV files
+        contains names of supported aromaticity models, along with various
+        control parameters and their values. This file is loaded and
+        processed during instantiation of Molecule class and data
+        corresponding to specific aromaticity model are used to detect
+        aromaticity for that model. Any new aromaticity model added to the
+        aromaticity data file, using different combinations of values for
+        existing control parameters, would work without any changes to the
+        code; the addition of any new control parameters, however, requires
+        its implementation in the code used to calculate number of pi
+        electrons available towards delocalization in a ring or ring
+        systems.
+
+        The current release of MayaChemTools package supports these
+        aromaticity models: MDLAromaticityModel, TriposAromaticityModel,
+        MMFFAromaticityModel, ChemAxonBasicAromaticityModel,
+        ChemAxonGeneralAromaticityModel, DaylightAromaticityModel,
+        MayaChemToolsAromaticityModel.
+
+        The current list of control parameters available to detect
+        aromaticity corresponding to different aromaticity models are:
+        AllowHeteroRingAtoms, HeteroRingAtomsList,
+        AllowExocyclicDoubleBonds, AllowHomoNuclearExocyclicDoubleBonds,
+        AllowElectronegativeRingAtomExocyclicDoubleBonds,
+        AllowRingAtomFormalCharge, AllowHeteroRingAtomFormalCharge,
+        MinimumRingSize. The values for these control parameters are
+        specified in AromaticityModelsData.csv file.
+
+        Although definition of aromaticity differs across various
+        aromaticity models, a ring or a ring system containing 4n + 2 pi
+        electrons (Huckel's rule) corresponding to alternate single and
+        double bonds, in general, is considered aromatic.
+
+        The available valence free electrons on heterocyclic ring atoms,
+        involved in two single ring bonds, are also allowed to participate
+        in pi electron delocalizaiton for most of the supported aromaticity
+        models.
+
+        The presence of exocyclic terminal double bond on ring atoms
+        involved in pi electron delocalization is only allowed for some of
+        the aromaticity models. Additionally, the type atoms involved in
+        exocyclic terminal double bonds may result in making a ring or ring
+        system non-aromatic.
+
+        For molecules containing fused rings, each fused ring set is
+        considered as one aromatic system for counting pi electrons to
+        satisfy Huckel's rule; In case of a failure, rings in fused set are
+        treated individually for aromaticity detection. Additionally,
+        non-fused rings are handled on their own during aromaticity
+        detection.
+
+    DetectRings
+            $Molecule->DetectRings();
+
+        Detects rings in a *Molecule* and returns *Molecule*. Ring detection
+        is performed using DetectCycles method avaible in Graph class which
+        in turn uses methods available Graph::CyclesDetection class.
+        Graph::CyclesDetection class implements collapsing path graph [Ref
+        31] methodology to detect all cycles in a graph.
+
+    FormatElementalCompositionInformation
+            $FormattedInfo = $Molecule->FormatElementalCompositionInformation(
+                             $ElementsRef, $ElementCompositionRef,
+                             [$Precision]);
+            $FormattedInfo = Molecule::FormatElementalCompositionInformation(
+                             $ElementsRef, $ElementCompositionRef,
+                             [$Precision]);
+
+        Using *ElementsRef* and *ElementCompositionRef* arrays referneces
+        containg informatio about elements and their composition, formats
+        elemental composition information and returns a *FormattedInfo*
+        string. Defaule *Precision* value: *2*.
+
+    GetAromaticityModel
+            $AromaticityModel = $Molecule->GetAromaticityModel();
+
+        Returns name of AromaticityModel set for *Molecule* corresponding to
+        AromaticityModel property or default model name of
+        MayaChemToolsAromaticityModel.
+
+    GetAllAtomPaths
+            $AtomPathsRef = $Molecule->GetAllAtomPaths([$AllowCycles]);
+
+        Returns all paths as a reference to an array containing reference to
+        arrays with path Atom objects.
+
+        Path atoms correspond to to all possible paths for each atom in
+        molecule with all possible lengths and sharing of bonds in paths
+        traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+        For molecule without any rings, this method returns the same set of
+        atom paths as GetAtomPaths method.
+
+    GetAllAtomPathsStartingAt
+            $AtomPathsRef = $Molecule->GetAllAtomPathsStartingAt($StartAtom,
+                            [$AllowCycles]);
+
+        Returns all atom paths starting from *StartAtom* as a reference to
+        an array containing reference to arrays with path Atom objects.
+
+        Path atoms atoms correspond to to all possible paths for specified
+        atom in molecule with all possible lengths and sharing of bonds in
+        paths traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+        For molecule without any rings, this method returns the same set of
+        atom paths as GetAtomPathsStartingAt method.
+
+    GetAllAtomPathsStartingAtWithLength
+            $AtomPathsRef = $Molecule->GetAllAtomPathsStartingAtWithLength(
+                            $StartAtom, $Length, [$AllowCycles]);
+
+        Returns all atom paths starting from *StartAtom* with specified
+        *Length*as a reference to an array containing reference to arrays
+        with path Atom objects.
+
+        Path atoms atoms correspond to to all possible paths for specified
+        atom in molecule with all possible lengths and sharing of bonds in
+        paths traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+        For molecule without any rings, this method returns the same set of
+        atom paths as GetAtomPathsStartingAtWithLength method.
+
+    GetAllAtomPathsStartingAtWithLengthUpto
+            $AtomPathsRef = $Molecule->GetAllAtomPathsStartingAtWithLengthUpto(
+                            $StartAtom, $Length, [$AllowCycles]);
+
+        Returns atom paths starting from *StartAtom* with length up to
+        *Length* as a reference to an array containing reference to arrays
+        with path Atom objects.
+
+        Path atoms atoms correspond to all possible paths for specified atom
+        in molecule with length up to a specified length and sharing of
+        bonds in paths traversed. By default, rings are included in paths. A
+        path containing a ring is terminated at an atom completing the ring.
+
+        For molecule without any rings, this method returns the same set of
+        atom paths as *GetAtomPathsStartingAtWithLengthUpto* method.
+
+    GetAllAtomPathsWithLength
+            $AtomPathsRef = $Molecule->GetAllAtomPathsWithLength($Length,
+                            [$AllowCycles]);
+
+        Returns all atom paths with specified *Length* as a reference to an
+        array containing reference to arrays with path Atom objects.
+
+        Path atoms correspond to to all possible paths for each atom in
+        molecule with length up to a specified length and sharing of bonds
+        in paths traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+        For molecule without any rings, this method returns the same set of
+        atom paths as as *GetAtomPathsWithLength* method.
+
+    GetAllAtomPathsWithLengthUpto
+            $AtomPathsRef = $Molecule->GetAllAtomPathsWithLengthUpto($Length,
+                            [$AllowCycles]);
+
+        Returns all atom paths with length up to *Length* as a reference to
+        an array containing reference to arrays with path Atom objects.
+
+        Path atoms correspond to to all possible paths for each atom in
+        molecule with length up to a specified length and sharing of bonds
+        in paths traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+        For molecule without any rings, this method returns the same set of
+        atom paths as as *GetAtomPathsWithLengthUpto* method.
+
+    GetAromaticRings
+            @AtomaticRings = $Molecule->GetAromaticRings();
+
+        Returns aromatic rings as an array containing references to arrays
+        of ring *Atom* objects in a *Molecule*.
+
+    GetAtomNeighborhoods
+            @Neighborhoods = $Molecule->GetAtomNeighborhoods($StartAtom);
+
+        Returns atom neighborhoods around a *StartAtom* as an array
+        containing references to arrays with neighborhood *Atom* objects at
+        possible radii.
+
+    GetAtomNeighborhoodsWithRadiusUpto
+            @Neighborhoods = $Molecule->GetAtomNeighborhoodsWithRadiusUpto($StartAtom,
+                             $Radius);
+
+        Returns atom neighborhoods around a *StartAtom* as an array
+        containing references to arrays with neighborhood *Atom* objects up
+        to *Radius*.
+
+    GetAtomNeighborhoodsWithSuccessorAtoms
+            @Neighborhoods = $Molecule->GetAtomNeighborhoodsWithSuccessorAtoms(
+                             $StartAtom);
+
+        Returns atom neighborhood around a specified *StartAtom*, along with
+        their successor connected atoms, collected at all radii as an array
+        containing references to arrays with first value corresponding to
+        neighborhood atom at a specific radius and second value as reference
+        to an array containing its successor connected atoms.
+
+        For a neighborhood atom at each radius level, the successor
+        connected atoms correspond to the neighborhood atoms at the next
+        radius level. Consequently, the neighborhood atoms at the last
+        radius level don't contain any successor atoms which fall outside
+        the range of specified radius.
+
+    GetAtomNeighborhoodsWithSuccessorAtomsAndRadiusUpto
+            @Neighborhoods = $Molecule->GetAtomNeighborhoodsWithSuccessorAtomsAndRadiusUpto(
+                             $StartAtom, $Radius);
+
+        Returns atom neighborhood around a specified *StartAtom*, along with
+        their successor connected atoms, collected upto specified *Radiud*
+        as an array containing references to arrays with first value
+        corresponding to neighborhood atom at a specific radius and second
+        value as reference to an array containing its successor connected
+        atoms.
+
+        For a neighborhood atom at each radius level, the successor
+        connected atoms correspond to the neighborhood atoms at the next
+        radius level. Consequently, the neighborhood atoms at the last
+        radius level don't contain any successor atoms which fall outside
+        the range of specified radius.
+
+    GetAtomPathBonds
+            $Return = $Molecule->GetAtomPathBonds(@PathAtoms);
+
+        Returns an array containing Bond objects corresponding to successive
+        pair of atoms in *PathAtoms*
+
+    GetAtomPaths
+            $AtomPathsRef = $Molecule->GetAtomPaths([$AllowCycles]);
+
+        Returns all paths as a reference to an array containing reference to
+        arrays with path Atom objects.
+
+        Path atoms correspond to to all possible paths for each atom in
+        molecule with all possible lengths and no sharing of bonds in paths
+        traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+    GetAtomPathsBetween
+            $AtomPathsRef = $Molecule->GetAtomPathsBetween($StartAtom, $EndAtom);
+
+        Returns all paths as between *StartAtom* and *EndAtom* as a
+        reference to an array containing reference to arrays with path Atom
+        objects.
+
+        For molecules with rings, atom paths array contains may contain two
+        paths.
+
+    GetAtomPathsStartingAt
+            $AtomPathsRef = $Molecule->GetAtomPathsStartingAt($StartAtom, [$AllowCycles]);
+
+        Returns paths starting at *StartAtom* as a reference to an array
+        containing reference to arrays with path Atom objects.
+
+        Path atoms correspond to all possible paths for specified atom in
+        molecule with all possible lengths and no sharing of bonds in paths
+        traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+    GetAtomPathsStartingAtWithLength
+            $AtomPathsRef = $Molecule->GetAtomPathsStartingAtWithLength($StartAtom,
+                            $Length, [$AllowCycles]);
+
+        Returns paths starting at *StartAtom* with length *Length* as a
+        reference to an array containing reference to arrays with path Atom
+        objects.
+
+        Path atoms correspond to all possible paths for specified atom in
+        molecule with length upto a specified length and no sharing of bonds
+        in paths traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+    GetAtomPathsStartingAtWithLengthUpto
+            $AtomPathsRef = $Molecule->GetAtomPathsStartingAtWithLengthUpto($StartAtom,
+                            $Length, [$AllowCycles]);
+
+        Returns paths starting at *StartAtom* with length up to *Length* as
+        a reference to an array containing reference to arrays with path
+        Atom objects.
+
+        Path atoms correspond to all possible paths for specified atom in
+        molecule with length upto a specified length and no sharing of bonds
+        in paths traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+    GetAtomPathsWithLength
+            $AtomPathsRef = $Molecule->GetAtomPathsWithLength($Length, [$AllowCycles]);
+
+        Returns all paths with specified *Length* as a reference to an array
+        containing reference to arrays with path Atom objects.
+
+        Path atoms correspond to all possible paths for each atom in
+        molecule with length upto a specified length and no sharing of bonds
+        in paths traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+    GetAtomPathsWithLengthUpto
+            $AtomPathsRef = $Molecule->GetAtomPathsWithLengthUpto($Length, [$AllowCycles]);
+
+        Returns all paths with length up to *Length* as a reference to an
+        array containing reference to arrays with path Atom objects.
+
+        Path atoms correspond to all possible paths for each atom in
+        molecule with length upto a specified length and no sharing of bonds
+        in paths traversed. By default, rings are included in paths. A path
+        containing a ring is terminated at an atom completing the ring.
+
+    GetAtoms
+            @AllAtoms = $Molecule->GetAtoms();
+            @PolarAtoms = $Molecule->GetAtoms('IsPolarAtom');
+
+            $NegateMethodResult = 1;
+            @NonHydrogenAtoms = $Molecule->GetAtoms('IsHydrogenAtom',
+                                $NegateMethodResult);
+
+            $AtomsCount = $Molecule->GetAtoms();
+
+        Returns an array of *Atoms* in a *Molecule*. In scalar context, it
+        returns number of atoms. Additionally, Atoms array can be filtered
+        by any user specifiable valid Atom class method and the result of
+        the Atom class method used to filter the atoms can also be negated
+        by an optional negate results flag as third parameter.
+
+    GetBonds
+            @Bonds = $Molecule->GetBonds();
+            $BondsCount = $Molecule->GetBonds();
+
+        Returns an array of *Bonds* in a *Molecule*. In scalar context, it
+        returns number of bonds.
+
+    GetCharge
+            $Charge = $Molecule->GetCharge();
+
+        Returns net charge on a *Molecule* using one of the following two
+        methods: explicitly set Charge property or sum of partial atomic
+        charges on each atom.
+
+    GetConnectedComponents
+            @ConnectedComponents = $Molecule->GetConnectedComponents();
+
+        Returns a reference to an array containing *Molecule* objects
+        corresponding to connected components sorted in decreasing order of
+        component size in a *Molecule*.
+
+    GetConnectedComponentsAtoms
+            @ConnectedComponentsAtoms =
+              $Molecule->GetConnectedComponentsAtoms();
+
+        Returns an array containing references to arrays with *Atom* objects
+        corresponding to atoms of connected components sorted in order of
+        component decreasing size in a *Molecule*.
+
+    GetDimensionality
+            $Dimensionality = $Molecule->GetDimensionality();
+
+        Returns *Dimensionality* of a *Molecule* corresponding to explicitly
+        set *Dimensionality* property value or by processing atomic.
+
+        The *Dimensionality* value from atomic coordinates is calculated as
+        follows:
+
+            3D - Three dimensional: One of X, Y or Z coordinate is non-zero
+            2D - Two dimensional: One of X or Y coordinate is non-zero; All Z
+                 coordinates are zero
+            0D - Zero dimensional: All atomic coordinates are zero
+
+    GetElementalComposition
+            ($ElementsRef, $CompositionRef) =
+              $Molecule->GetElementalComposition([$IncludeMissingHydrogens]);
+
+        Calculates elemental composition and returns references to arrays
+        containing elements and their percent composition in a *Molecule*.
+        By default, missing hydrogens are included during the calculation.
+
+    GetElementsAndNonElements
+            ($ElementsRef, $NonElementsRef) =
+             $Molecule->GetElementsAndNonElements([$IncludeMissingHydrogens]);
+
+        Counts elements and non-elements in a *Molecule* and returns
+        references to hashes containing element and non-element as hash keys
+        with values corresponding to their count. By default, missing
+        hydrogens are not added to the element hash.
+
+    GetExactMass
+            $ExactMass = $Molecule->GetExactMass();
+
+        Returns exact mass of a *Molecule* corresponding to sum of exact
+        masses of all the atoms.
+
+    GetFormalCharge
+            $FormalCharge = $Molecule->GetFormalCharge();
+
+        Returns net formal charge on a *Molecule* using one of the following
+        two methods: explicitly set FormalCharge property or sum of formal
+        charges on each atom.
+
+        FormalCharge is different from Charge property of the molecule which
+        corresponds to sum of partial atomic charges explicitly set for each
+        atom using a specific methodology.
+
+    GetFreeRadicalElectrons
+            $FreeRadicalElectrons = $Molecule->GetFreeRadicalElectrons();
+
+        Returns total number of free radical electrons available in a
+        *Molecule* using one of the following two methods: explicitly set
+        FreeRadicalElectrons property or sum of available free radical
+        electrons on each atom.
+
+    GetFusedAndNonFusedRings
+            ($FusedRingSetRef, $NonFusedRingsRef) =
+               $Molecule->GetFusedAndNonFusedRings();
+
+        Returns references to array of fused ring sets and non-fused rings
+        in a *Molecule*. Fused ring sets array reference contains refernces
+        to arrays of rings corresponding to ring *Atom* objects; Non-fused
+        rings array reference contains references to arrays of ring *Atom*
+        objects.
+
+    GetLargestConnectedComponent
+            $ComponentMolecule = $Molecule->GetLargestConnectedComponent();
+
+        Returns a reference to Molecule object corresponding to a largest
+        connected component in a *Molecule*.
+
+    GetLargestConnectedComponentAtoms
+            @ComponentAtoms = $Molecule->GetLargestConnectedComponentAtoms();
+
+        Returns a reference to an array of Atom objects corresponding to a
+        largest connected component in a *Molecule*.
+
+    GetLargestRing
+            @RingAtoms = $Molecule->GetLargestRing();
+
+        Returns an array of *Atoms* objects corresponding to a largest ring
+        in a *Molecule*.
+
+    GetMolecularFormula
+            $FormulaString = $Molecule->GetMolecularFormula(
+                             [$IncludeMissingHydrogens,
+                             $IncludeNonElements]);
+
+        Returns molecular formula of a *Molecule* by collecting information
+        about all atoms in the molecule and composing the formula using
+        Hills ordering system:
+
+            o C shows up first and H follows assuming C is present.
+            o All other standard elements are sorted alphanumerically.
+            o All other non-stanard atom symbols are also sorted
+              alphanumerically and follow standard elements.
+
+        Notes:
+
+            o By default, missing hydrogens and nonelements are also included.
+            o Elements for disconnected fragments are combined into the same
+              formula.
+            o Formal charge is also used during compoisiton of molecular formula.
+
+    GetMolecularWeight
+            $MolWeight = $Molecule->GetMolecularWeight();
+
+        Returns molecular weight of a *Molecule* corresponding to sum of
+        atomic weights of all the atoms.
+
+    GetNumOfAromaticRings
+            $NumOfAromaticRings = $Molecule->GetNumOfAromaticRings();
+
+        Returns number of aromatic rings in a *Molecule*.
+
+    GetNumOfAtoms
+            $NumOfAtoms = $Molecule->GetNumOfAtoms();
+
+        Returns number of atoms in a *Molecule*.
+
+    GetNumOfBonds
+            $NumOfBonds = $Molecule->GetNumOfBonds();
+
+        Returns number of bonds in a *Molecule*.
+
+    GetNumOfConnectedComponents
+            $NumOfComponents = $Molecule->GetNumOfConnectedComponents();
+
+        Returns number of connected components in a *Molecule*.
+
+    GetNumOfElementsAndNonElements
+            ($NumOfElements, $NumOfNonElements) = $Molecule->
+                                      GetNumOfElementsAndNonElements();
+            ($NumOfElements, $NumOfNonElements) = $Molecule->
+                           GetNumOfElementsAndNonElements($IncludeMissingHydrogens);
+
+        Returns number of elements and non-elements in a *Molecule*. By
+        default, missing hydrogens are not added to element count.
+
+    GetNumOfHeavyAtoms
+            $NumOfHeavyAtoms = $Molecule->GetNumOfHeavyAtoms();
+
+        Returns number of heavy atoms, non-hydrogen atoms, in a *Molecule*.
+
+    GetNumOfHydrogenAtoms
+            $NumOfHydrogenAtoms = $Molecule->GetNumOfHydrogenAtoms();
+
+        Returns number of hydrogen atoms in a *Molecule*.
+
+    GetNumOfMissingHydrogenAtoms
+            $NumOfMissingHydrogenAtoms = $Molecule->GetNumOfMissingHydrogenAtoms();
+
+        Returns number of hydrogen atoms in a *Molecule*.
+
+    GetNumOfNonHydrogenAtoms
+            $NumOfNonHydrogenAtoms = $Molecule->GetNumOfNonHydrogenAtoms();
+
+        Returns number of non-hydrogen atoms in a *Molecule*.
+
+    GetNumOfRings
+            $RingCount = $Molecule->GetNumOfRings();
+
+        Returns number of rings in a *Molecule*.
+
+    GetNumOfRingsWithEvenSize
+            $RingCount = $Molecule->GetNumOfRingsWithEvenSize();
+
+        Returns number of rings with even size in a *Molecule*.
+
+    GetNumOfRingsWithOddSize
+            $RingCount = $Molecule->GetNumOfRingsWithOddSize();
+
+        Returns number of rings with odd size in a *Molecule*.
+
+    GetNumOfRingsWithSize
+            $RingCount = $Molecule->GetNumOfRingsWithSize($Size);
+
+        Returns number of rings with *Size* in a *Molecule*.
+
+    GetNumOfRingsWithSizeGreaterThan
+            $RingCount = $Molecule->GetNumOfRingsWithSizeGreaterThan($Size);
+
+        Returns number of rings with size greater than *Size* in a
+        *Molecule*.
+
+    GetNumOfRingsWithSizeLessThan
+            $RingCount = $Molecule->GetNumOfRingsWithSizeLessThan($Size);
+
+        Returns number of rings with size less than *Size* in a *Molecule*.
+
+    GetRingBonds
+            @RingBonds = $Molecule->GetRingBonds(@RingAtoms);
+
+        Returns an array of ring Bond objects correponding to an array of
+        ring *Atoms* in a *Molecule*.
+
+    GetRingBondsFromRings
+            @RingBondsSets = $Molecule->GetRingBondsFromRings(@RingAtomsSets);
+
+        Returns an array containing references to arrays of ring Bond
+        objects for rings specified in an array of references to ring *Atom*
+        objects.
+
+    GetRings
+            @Rings = $Molecule->GetRings();
+
+        Returns rings as an array containing references to arrays of ring
+        *Atom* objects in a *Molecule*.
+
+    GetRingsWithEvenSize
+            @Rings = $Molecule->GetRingsWithEvenSize();
+
+        Returns even size rings as an array containing references to arrays
+        of ring *Atom* objects in a *Molecule*.
+
+    GetRingsWithOddSize
+            @Rings = $Molecule->GetRingsWithOddSize();
+
+        Returns odd size rings as an array containing references to arrays
+        of ring *Atom* objects in a *Molecule*.
+
+    GetRingsWithSize
+            @Rings = $Molecule->GetRingsWithSize($Size);
+
+        Returns rings with *Size* as an array containing references to
+        arrays of ring *Atom* objects in a *Molecule*.
+
+    GetRingsWithSizeGreaterThan
+            @Rings = $Molecule->GetRingsWithSizeGreaterThan($Size);
+
+        Returns rings with size greater than *Size* as an array containing
+        references to arrays of ring *Atom* objects in a *Molecule*.
+
+    GetRingsWithSizeLessThan
+            @Rings = $Molecule->GetRingsWithSizeLessThan($Size);
+
+        Returns rings with size less than *Size* as an array containing
+        references to arrays of ring *Atom* objects in a *Molecule*.
+
+    GetSizeOfLargestRing
+            $Size = $Molecule->GetSizeOfLargestRing();
+
+        Returns size of the largest ring in a *Molecule*.
+
+    GetSizeOfSmallestRing
+            $Size = $Molecule->GetSizeOfSmallestRing();
+
+        Returns size of the smalles ring in a *Molecule*.
+
+    GetSmallestRing
+            @RingAtoms = $Molecule->GetSmallestRing();
+
+        Returns an array containing *Atom* objects corresponding to the
+        smallest ring in a *Molecule*.
+
+    GetSpinMultiplicity
+            $SpinMultiplicity = $Molecule->GetSpinMultiplicity();
+
+        Returns net spin multiplicity of a *Molecule* using one of the
+        following two methods: explicitly set SpinMultiplicity property or
+        sum of spin multiplicity on each atom.
+
+    GetSupportedAromaticityModels
+            @SupportedModels = $Molecule->GetSupportedAromaticityModels();
+
+        Returns an array containing a list of supported aromaticity models.
+
+    GetValenceModel
+            $ValenceModel = $Molecule->GetValenceModel();
+
+        Returns valence model for *Molecule* using one of the following two
+        methods: explicitly set ValenceModel property or defaul value of
+        *InternalValenceModel*.
+
+    GetTopologicallySortedAtoms
+            @SortedAtoms = $Molecule->GetTopologicallySortedAtoms([$StartAtom]);
+
+        Returns an array of topologically sorted *Atom* objects starting
+        from *StartAtom* or an arbitrary atom in a *Molecule*.
+
+    HasAromaticRings
+            $Status = $Molecule->HasAromaticRings();
+
+        Returns 1 or 0 based on whether any aromatic ring is present in a
+        *Molecule*.
+
+    HasAromaticAtomsInRings
+            $Status = $Molecule->HasAromaticAtomsInRings();
+
+        Returns 1 or 0 based on whether any aromatic ring atom is present in
+        a *Molecule*.
+
+    HasAromaticAtomsNotInRings
+            $Status = $Molecule->HasAromaticAtomsNotInRings();
+
+        Returns 1 or 0 based on whether any non-ring atom is marked aromatic
+        in a *Molecule*.
+
+    HasAtom
+            $Status = $Molecule->HasAtom($Atom);
+
+        Returns 1 or 0 based on whether *Atom* is present in a *Molecule*.
+
+    HasBond
+            $Status = $Molecule->HasBond($Bond);
+
+        Returns 1 or 0 based on whether *Bond* is present in a *Molecule*.
+
+    HasFusedRings
+            $Status = $Molecule->HasFusedRings();
+
+        Returns 1 or 0 based on whether any fused rings set is present in a
+        *Molecule*.
+
+    HasNoRings
+            $Status = $Molecule->HasNoRings();
+
+        Returns 0 or 1 based on whether any ring is present in a *Molecule*.
+
+    HasOnlyOneRing
+            $Status = $Molecule->HasOnlyOneRing();
+
+        Returns 1 or 0 based on whether only one ring is present in a
+        *Molecule*.
+
+    HasRings
+            $Status = $Molecule->HasRings();
+
+        Returns 1 or 0 based on whether rings are present in a *Molecule*.
+
+    IsAromatic
+            $Status = $Molecule->IsAromatic();
+
+        Returns 1 or 0 based on whether *Molecule* is aromatic.
+
+    IsMolecule
+            $Status = Molecule::IsMolecule();
+
+        Returns 1 or 0 based on whether *Object* is a Molecule object.
+
+    IsRingAromatic
+            $Status = $Molecule->IsRingAromatic(@RingAtoms);
+
+        Returns 1 or 0 based on whether all *RingAtoms* are aromatic.
+
+    IsSupportedAromaticityModel
+            $Status = $Molecule->IsSupportedAromaticityModel($AromaticityModel);
+            $Status = Molecule::IsSupportedAromaticityModel($AromaticityModel);
+
+        Returns 1 or 0 based on whether specified *AromaticityModel* is
+        supported.
+
+    IsTwoDimensional
+            $Status = $Molecule->IsTwoDimensional();
+
+        Returns 1 or 0 based on whether any atom in *Molecule* has a
+        non-zero value for X or Y coordinate and all atoms have zero value
+        for Z coordinates.
+
+    IsThreeDimensional
+            $Status = $Molecule->IsThreeDimensional();
+
+        Returns 1 or 0 based on whether any atom in *Molecule* has a
+        non-zero value for Z coordinate.
+
+    KeepLargestComponent
+            $Molecule->KeepLargestComponent();
+
+        Deletes atoms corresponding to all other connected components Except
+        for the largest connected component in a *Molecule* and returns
+        *Molecule*.
+
+    KekulizeAromaticAtoms
+            $Status = $Molecule->KekulizeAromaticAtoms();
+
+        Kekulize marked ring and non-ring aromatic atoms in a molecule and
+        return 1 or 1 based on whether the kekulization succeeded.
+
+    NewAtom
+            $NewAtom = $Molecule->NewAtom(%AtomPropertyNamesAndValues);
+
+        Creates a new atom using *AtomPropertyNamesAndValues*, add its to
+        *Molecule*, and returns new Atom object.
+
+    NewBond
+            $NewBond = $Molecule->NewBond(%BondPropertyNamesAndValues);
+
+        Creates a new bond using *AtomPropertyNamesAndValues*, add its to
+        *Molecule*, and returns new Bond object.
+
+    SetActiveRings
+            $Molecule->SetActiveRings($RingsType);
+
+        Sets up type of detected ring sets to use during all ring related
+        methods and returns *Molecule*. Possible *RingType* values:
+        *Independent or All*. By default, *Independent* ring set is used
+        during all ring methods.
+
+    SetAromaticityModel
+            $Molecule = $Molecule->SetAromaticityModel($AromaticityModel);
+
+        Sets up *AromaticityModel* property value for *Molecule* and
+        retrurns *Molecule*.
+
+    SetValenceModel
+            $Molecule = $Molecule->SetValenceModel(ValenceModel);
+
+        Sets up *ValenceModel* property value for *Molecule* and retrurns
+        *Molecule*.
+
+    StringifyMolecule
+            $MoleculeString = $Molecule->StringifyMolecule();
+
+        Returns a string containing information about *Molecule* object
+
+AUTHOR
+    Manish Sud <[e-mail]>
+
+SEE ALSO
+    Atom.pm, Bond.pm, MoleculeFileIO.pm, MolecularFormula.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.
+