MolSym 0.2.1__tar.gz

molsym-0.2.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Stephen M. Goodlett, Nathaniel L. Kitzmiller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

molsym-0.2.1/MolSym.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: MolSym
+Version: 0.2.1
+Summary: A program for molecular symmetry detection and SALC construction
+Author-email: Stephen Goodlett <smg13363@uga.edu>, Nate Kitzmiller <nathaniel.kitzmiller@uga.edu>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NASymmetry/MolSym
+Project-URL: Documentation, https://molsym.readthedocs.io
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.23.4
+Provides-Extra: qcel
+Requires-Dist: qcelemental>=0.25.1; extra == "qcel"
+Dynamic: license-file
+
+<p align="center">
+  <img src="molsym_logo_v3.svg" width="400" alt=""/>
+</p>
+<table align="center">
+  <tr>
+    <th>Documentation</th>
+    <th>CI</th>
+    <th>Coverage</th>
+    <th>Citation</th>
+  </tr>
+  <tr>
+    <td align="center">
+      <a href='https://molsym.readthedocs.io/en/latest/?badge=latest'>
+      <img src='https://readthedocs.org/projects/molsym/badge/?version=latest' alt='Documentation Status' />
+      </a>
+    </td>
+    <td align="center">
+      <a href=https://github.com/NASymmetry/MolSym/actions/workflows/workflow.yml>
+      <img src=https://github.com/NASymmetry/MolSym/actions/workflows/workflow.yml/badge.svg>
+      </a>
+    </td>
+    <td align="center">
+      <a href=https://codecov.io/gh/NASymmetry/MolSym>
+      <img src=https://codecov.io/gh/NASymmetry/MolSym/branch/main/graph/badge.svg?token=NQDJ0QYLB0>
+      </a> 
+    </td>
+     <td align="center">
+      <a href=https://doi.org/10.1063/5.0216738>
+      <img src=https://img.shields.io/badge/JCP-10.1063/5.0216738-purple.svg>
+      </a>
+    </td>
+  </tr>
+</table>
+
+# MolSym
+A python package for handling molecular symmetry.
+
+
+## Capabilities
+- [Point group detection](https://github.com/NASymmetry/MolSym/wiki/Point-group-detection)
+- [Molecule symmetrization](https://github.com/NASymmetry/MolSym/wiki/Symmetrizing-a-molecule)
+- Symmetry element generation
+- Character table generation
+- SALC generation for [atomic basis functions](https://github.com/NASymmetry/MolSym/wiki/SALCs#spherical-harmonics), [internal coordinates](https://github.com/NASymmetry/MolSym/wiki/SALCs#internal-coordinates), and [cartesian coordinates](https://github.com/NASymmetry/MolSym/wiki/SALCs#cartesian-coordinates)
+
+## Installing
+As of now we do not have a better way to install the code other than cloning from GitHub.
+Create a new conda environment with:
+
+  `conda create -n "NameYourEnvironment" python=3.X`
+
+MolSym is tested with Python 3.9-3.13, but should work for more recent versions and some older versions as well.
+  
+  `git clone git@github.com:NASymmetry/MolSym.git`
+
+Install the necessary dependencies using `pip`.
+  
+  `pip install -r <Path to MolSym directory>/requirements.tx`
+
+Alternatively, most Python environments come equipped with all but one dependency, so if `pip` is not desired, installing `QCElemental` is all that should be required.
+
+  `conda install -c conda-forge qcelemental`
+
+Finally append the MolSym directory to your `PYTHONPATH`.
+  
+ `export PYTHONPATH=$PYTHONPATH:<Path to MolSym directory>`

molsym-0.2.1/MolSym.egg-info/SOURCES.txt

@@ -0,0 +1,45 @@
+LICENSE.txt
+README.md
+pyproject.toml
+MolSym.egg-info/PKG-INFO
+MolSym.egg-info/SOURCES.txt
+MolSym.egg-info/dependency_links.txt
+MolSym.egg-info/requires.txt
+MolSym.egg-info/top_level.txt
+molsym/__init__.py
+molsym/molecule.py
+molsym/symmetrize.py
+molsym/symtools.py
+molsym/pgdetect/__init__.py
+molsym/pgdetect/flowchart.py
+molsym/pgdetect/flowchart_helper.py
+molsym/salcs/__init__.py
+molsym/salcs/cartesian_coordinates.py
+molsym/salcs/function_set.py
+molsym/salcs/internal_coordinates.py
+molsym/salcs/linear_functions.py
+molsym/salcs/projection_op.py
+molsym/salcs/salc.py
+molsym/salcs/salc_tools.py
+molsym/salcs/spherical_harmonics.py
+molsym/symtext/Ih_irrep_mats.py
+molsym/symtext/__init__.py
+molsym/symtext/character_table.py
+molsym/symtext/general_irrep_mats.py
+molsym/symtext/goat.py
+molsym/symtext/irrep_mats.py
+molsym/symtext/linear_helper.py
+molsym/symtext/multiplication_table.py
+molsym/symtext/point_group.py
+molsym/symtext/symel.py
+molsym/symtext/symtext.py
+molsym/symtext/symtext_helper.py
+test/test_find_pg.py
+test/test_ics.py
+test/test_molecule.py
+test/test_new_generator.py
+test/test_old_bugs.py
+test/test_projection_op.py
+test/test_psi4_pgbits.py
+test/test_salc_tools.py
+test/test_symtext.py

molsym-0.2.1/MolSym.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

molsym-0.2.1/MolSym.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.23.4
+
+[qcel]
+qcelemental>=0.25.1

molsym-0.2.1/MolSym.egg-info/top_level.txt

@@ -0,0 +1 @@
+molsym

molsym-0.2.1/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: MolSym
+Version: 0.2.1
+Summary: A program for molecular symmetry detection and SALC construction
+Author-email: Stephen Goodlett <smg13363@uga.edu>, Nate Kitzmiller <nathaniel.kitzmiller@uga.edu>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NASymmetry/MolSym
+Project-URL: Documentation, https://molsym.readthedocs.io
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.23.4
+Provides-Extra: qcel
+Requires-Dist: qcelemental>=0.25.1; extra == "qcel"
+Dynamic: license-file
+
+<p align="center">
+  <img src="molsym_logo_v3.svg" width="400" alt=""/>
+</p>
+<table align="center">
+  <tr>
+    <th>Documentation</th>
+    <th>CI</th>
+    <th>Coverage</th>
+    <th>Citation</th>
+  </tr>
+  <tr>
+    <td align="center">
+      <a href='https://molsym.readthedocs.io/en/latest/?badge=latest'>
+      <img src='https://readthedocs.org/projects/molsym/badge/?version=latest' alt='Documentation Status' />
+      </a>
+    </td>
+    <td align="center">
+      <a href=https://github.com/NASymmetry/MolSym/actions/workflows/workflow.yml>
+      <img src=https://github.com/NASymmetry/MolSym/actions/workflows/workflow.yml/badge.svg>
+      </a>
+    </td>
+    <td align="center">
+      <a href=https://codecov.io/gh/NASymmetry/MolSym>
+      <img src=https://codecov.io/gh/NASymmetry/MolSym/branch/main/graph/badge.svg?token=NQDJ0QYLB0>
+      </a> 
+    </td>
+     <td align="center">
+      <a href=https://doi.org/10.1063/5.0216738>
+      <img src=https://img.shields.io/badge/JCP-10.1063/5.0216738-purple.svg>
+      </a>
+    </td>
+  </tr>
+</table>
+
+# MolSym
+A python package for handling molecular symmetry.
+
+
+## Capabilities
+- [Point group detection](https://github.com/NASymmetry/MolSym/wiki/Point-group-detection)
+- [Molecule symmetrization](https://github.com/NASymmetry/MolSym/wiki/Symmetrizing-a-molecule)
+- Symmetry element generation
+- Character table generation
+- SALC generation for [atomic basis functions](https://github.com/NASymmetry/MolSym/wiki/SALCs#spherical-harmonics), [internal coordinates](https://github.com/NASymmetry/MolSym/wiki/SALCs#internal-coordinates), and [cartesian coordinates](https://github.com/NASymmetry/MolSym/wiki/SALCs#cartesian-coordinates)
+
+## Installing
+As of now we do not have a better way to install the code other than cloning from GitHub.
+Create a new conda environment with:
+
+  `conda create -n "NameYourEnvironment" python=3.X`
+
+MolSym is tested with Python 3.9-3.13, but should work for more recent versions and some older versions as well.
+  
+  `git clone git@github.com:NASymmetry/MolSym.git`
+
+Install the necessary dependencies using `pip`.
+  
+  `pip install -r <Path to MolSym directory>/requirements.tx`
+
+Alternatively, most Python environments come equipped with all but one dependency, so if `pip` is not desired, installing `QCElemental` is all that should be required.
+
+  `conda install -c conda-forge qcelemental`
+
+Finally append the MolSym directory to your `PYTHONPATH`.
+  
+ `export PYTHONPATH=$PYTHONPATH:<Path to MolSym directory>`

molsym-0.2.1/README.md

@@ -0,0 +1,66 @@
+<p align="center">
+  <img src="molsym_logo_v3.svg" width="400" alt=""/>
+</p>
+<table align="center">
+  <tr>
+    <th>Documentation</th>
+    <th>CI</th>
+    <th>Coverage</th>
+    <th>Citation</th>
+  </tr>
+  <tr>
+    <td align="center">
+      <a href='https://molsym.readthedocs.io/en/latest/?badge=latest'>
+      <img src='https://readthedocs.org/projects/molsym/badge/?version=latest' alt='Documentation Status' />
+      </a>
+    </td>
+    <td align="center">
+      <a href=https://github.com/NASymmetry/MolSym/actions/workflows/workflow.yml>
+      <img src=https://github.com/NASymmetry/MolSym/actions/workflows/workflow.yml/badge.svg>
+      </a>
+    </td>
+    <td align="center">
+      <a href=https://codecov.io/gh/NASymmetry/MolSym>
+      <img src=https://codecov.io/gh/NASymmetry/MolSym/branch/main/graph/badge.svg?token=NQDJ0QYLB0>
+      </a> 
+    </td>
+     <td align="center">
+      <a href=https://doi.org/10.1063/5.0216738>
+      <img src=https://img.shields.io/badge/JCP-10.1063/5.0216738-purple.svg>
+      </a>
+    </td>
+  </tr>
+</table>
+
+# MolSym
+A python package for handling molecular symmetry.
+
+
+## Capabilities
+- [Point group detection](https://github.com/NASymmetry/MolSym/wiki/Point-group-detection)
+- [Molecule symmetrization](https://github.com/NASymmetry/MolSym/wiki/Symmetrizing-a-molecule)
+- Symmetry element generation
+- Character table generation
+- SALC generation for [atomic basis functions](https://github.com/NASymmetry/MolSym/wiki/SALCs#spherical-harmonics), [internal coordinates](https://github.com/NASymmetry/MolSym/wiki/SALCs#internal-coordinates), and [cartesian coordinates](https://github.com/NASymmetry/MolSym/wiki/SALCs#cartesian-coordinates)
+
+## Installing
+As of now we do not have a better way to install the code other than cloning from GitHub.
+Create a new conda environment with:
+
+  `conda create -n "NameYourEnvironment" python=3.X`
+
+MolSym is tested with Python 3.9-3.13, but should work for more recent versions and some older versions as well.
+  
+  `git clone git@github.com:NASymmetry/MolSym.git`
+
+Install the necessary dependencies using `pip`.
+  
+  `pip install -r <Path to MolSym directory>/requirements.tx`
+
+Alternatively, most Python environments come equipped with all but one dependency, so if `pip` is not desired, installing `QCElemental` is all that should be required.
+
+  `conda install -c conda-forge qcelemental`
+
+Finally append the MolSym directory to your `PYTHONPATH`.
+  
+ `export PYTHONPATH=$PYTHONPATH:<Path to MolSym directory>`

molsym-0.2.1/molsym/__init__.py

@@ -0,0 +1,5 @@
+from .molecule import Molecule
+from .pgdetect.flowchart import find_point_group
+from .symtext.symtext import Symtext
+from .symmetrize import symmetrize
+from .import salcs

molsym-0.2.1/molsym/molecule.py

@@ -0,0 +1,268 @@
+import numpy as np
+from dataclasses import dataclass
+from copy import deepcopy
+import sys
+global_tol = 1e-8 # TODO It would be nice to get rid of this...
+
+@dataclass
+class Atom():
+    """
+    Dataclass for storing atom information
+
+    :param Z: Atomic number of atom.
+    :param mass: Mass of atom in amu as defined by QCElemental.
+    :param xyz: Position vector of atom in Cartesian coordinates.
+    :type Z: int 
+    :type mass: float
+    :type xyz: NumPy array of shape (3,)
+    """
+    Z:int
+    mass:float
+    xyz:np.array
+
+@dataclass
+class SEA():
+    """
+    SEA: symmetry equivalent atoms.
+    SEAs are atoms that can be swapped with no distinguishable change in the molecule.
+
+    :param label: Optionally defines rotor type of SEA set (e.g. Single Atom, Linear, Spherical, Regular Polygon, Oblate Symmetric Top, etc.)
+    :param subset: Sublist of atom indices in molecule that constitute the SEA set
+    :param axis: Optionally defines possible rotational symmetry vector
+    :type label: str or None
+    :type subset: NumPy array of integers
+    :type axis: NumPy array of shape (3,) or None
+    """
+    label:str
+    subset:np.array
+    axis:np.array
+
+class Molecule():
+    """
+    Class dealing with molecule relevant information.
+    Typically initiated from a QCSchema object.
+    """
+    def __init__(self, atoms, coords, masses) -> None:
+        self.tol = 1e-5
+        self.atoms = np.asarray(atoms)
+        try:
+            self.natoms = len(self.atoms)
+        except TypeError:
+            self.natoms = 1
+        self.coords = np.asarray(coords)
+        self.masses = np.asarray(masses)
+
+    @classmethod
+    def from_schema(cls, schema):
+        """
+        Class method for constructing a Molecule from a QCSchema object
+
+        :param schema: Schema dictionary to be converted to Molecule
+        :type schema: dict
+        :rtype: molsym.Molecule
+        """
+        import qcelemental as qcel
+        atoms = schema["symbols"]
+        natoms = len(atoms)
+        coords = np.reshape(schema["geometry"], (natoms,3))
+        # As of now, QCElemental seems to have issues assigning masses, so I do it
+        masses = np.zeros(natoms)
+        for (idx, symb) in enumerate(atoms):
+            masses[idx] = qcel.periodictable.to_mass(symb)
+        return cls(atoms, coords, masses)
+    
+    @classmethod
+    def from_psi4_molecule(cls, mol):
+        """
+        Class method for constructing a Molecule from a QCSchema object
+
+        :param schema: Schema dictionary to be converted to Molecule
+        :type schema: dict
+        :rtype: molsym.Molecule
+        """
+        if "psi4" not in sys.modules:
+            raise ImportError("Psi4 is required to use this function")
+        atoms = [mol.symbol(i) for i in range(mol.natom())]
+        coords = mol.geometry().to_array()
+        masses = [mol.mass(i) for i in range(mol.natom())]
+        return cls(atoms, coords, masses)
+
+    @classmethod
+    def from_file(cls, fn, keep_angstrom=False):
+        """
+        Class method for constructing a Molecule from an *.xyz file
+
+        :param fn: Filename
+        :type fn: str
+        :rtype: molsym.Molecule
+        """
+        import qcelemental as qcel
+        with open(fn, "r") as lfn:
+            strang = lfn.read()
+
+        schema = qcel.models.Molecule.from_data(strang).dict()
+        if keep_angstrom:
+            schema["geometry"] *= qcel.constants.bohr2angstroms
+        return cls.from_schema(schema)
+
+    @classmethod
+    def from_psi4_schema(cls, schema):
+        """
+        Class method for constructing a Molecule from a QCSchema object generated in Psi4.
+        Schemas coming from Psi4 are different for some reason?
+
+        :param schema: Schema dictionary to be converted to Molecule
+        :type schema: dict
+        :rtype: molsym.Molecule
+        """
+        import qcelemental as qcel
+        atoms = schema["elem"] # was symbols
+        natoms = len(atoms)
+        coords = np.reshape(schema["geom"], (natoms,3)) # was geometry
+        # As of now, QCElemental seems to have issues assigning masses, so I do it
+        masses = np.zeros(natoms)
+        for (idx, symb) in enumerate(atoms):
+            masses[idx] = qcel.periodictable.to_mass(symb)
+        return cls(atoms, coords, masses)
+
+    def to_xyz_string(self, already_angstrom=False):
+        import qcelemental as qcel
+        # Will save xyz in Angstrom, undoing the previous
+        # Ang->Bohr from Molecule.from_schema
+        if already_angstrom:
+            self.coords /= qcel.constants.bohr2angstroms
+        qcmol = qcel.models.Molecule(
+            **{"symbols": self.atoms, 
+            "geometry": self.coords})
+        return qcmol.to_string("xyz")
+
+    def __repr__(self) -> str:
+        rstr = "MolSym Molecule:\n"
+        for i in range(self.natoms):
+            rstr += f"   {self.atoms[i]:3s}   {self.coords[i,0]:12.8f}"
+            rstr += f"   {self.coords[i,1]:12.8f}   {self.coords[i,2]:12.8f}\n"
+        return rstr
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __getitem__(self, i):
+        return Molecule(self.atoms[i], self.coords[i,:], self.masses[i])
+
+    def __len__(self):
+        return self.natoms
+
+    def __eq__(self, other):
+        # Select higher tolerance
+        if self.tol >= other.tol:
+            eq_tol = self.tol
+        else:
+            eq_tol = other.tol
+        if isinstance(other, Molecule):
+            c1 = (other.atoms == self.atoms).all()
+            c2 = (other.masses == self.masses).all()
+            c3 = np.allclose(other.coords, self.coords, atol=eq_tol)
+            return c1 and c2 and c3
+
+    def find_com(self):
+        """
+        Get center of mass of molecule.
+
+        :return: Center of mass
+        :rtype: NumPy array of shape (3,)
+        """
+        com = np.zeros(3)
+        for i in range(self.natoms):
+            com += self.masses[i]*self.coords[i,:]
+        return com / sum(self.masses)
+
+    def is_at_com(self):
+        """
+        Checks if molecule is at center of mass already.
+
+        :rtype: bool
+        """
+        if sum(abs(self.find_com())) < self.tol:
+            return True
+        else:
+            return False
+
+    def translate(self, r):
+        """
+        Translates Cartesian positions of all atoms in molecule in place by vector r.
+
+        :param r: Translation vector
+        :type r: NumPy array of shape (3,)
+        """
+        for i in range(self.natoms):
+            self.coords[i,:] -= r
+        
+    def transform(self, M):
+        """
+        Transform coordinates of molecule by matrix M and return new molecule.
+
+        :param M: Transformation matrix (e.g. rotation, reflection, etc.)
+        :type M: NumPy array (3,3)
+        :return: Molecule with transformed atom coordinates
+        :rtype: molsym.Molecule
+        """
+        new_mol = deepcopy(self)
+        new_mol.coords = np.dot(new_mol.coords,np.transpose(M))
+        return new_mol
+
+    def distance_matrix(self):
+        """
+        Calculates the interatomic distance matrix as all pairwise distances between atoms.
+
+        :return: Interatomic distance matrix
+        :rtype: NumPy array of shape (self.natoms,self.natoms)
+        """
+        dm = np.zeros((self.natoms,self.natoms))
+        for i in range(self.natoms):
+            for j in range(i,self.natoms):
+                dm[i,j] = np.sqrt(sum((self.coords[i,:]-self.coords[j,:])**2))
+                dm[j,i] = dm[i,j]
+        return dm
+
+    def find_SEAs(self):
+        """
+        Find sets of symmetry equivalent atoms.
+        Permutations of the distance matrix reveal which atoms form symmetry equivalent sets.
+
+        :return: List of symmetry equivalent atom sets
+        :rtype: List[molsym.SEA]
+        """
+        dm = self.distance_matrix()
+        out = []
+        for i in range(self.natoms):
+            for j in range(i+1,self.natoms):
+                a_idx = np.argsort(dm[i,:])
+                b_idx = np.argsort(dm[j,:])
+                z = dm[i,a_idx] - dm[j,b_idx]
+                chk = True
+                for k in z:
+                    if abs(k) < self.tol:
+                        continue
+                    else:
+                        chk = False
+                if chk:
+                    out.append((i,j))
+        skip = []
+        SEAs = []
+        for i in range(self.natoms):
+            if i in skip:
+                continue
+            else:
+                collect = [i]
+            
+            for k in out:
+                if i in k:
+                    if i == k[0]:
+                        collect.append(k[1])
+                        skip.append(k[1])
+                    else:
+                        collect.append(k[0])
+                        skip.append(k[0])
+            SEAs.append(SEA("", collect, np.zeros(3)))
+        return SEAs
+