ben-chem-tools 0.1.0__tar.gz

ben_chem_tools-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.3
+Name: ben-chem-tools
+Version: 0.1.0
+Summary: common useful tools for computational chemistry
+Author: Ben
+Author-email: Ben <bennyp2494@gmail.com>
+Requires-Dist: cclib>=1.8.1
+Requires-Dist: matplotlib>=3.9.4
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: periodictable>=2.0.2
+Requires-Dist: scipy>=1.13.1
+Requires-Dist: seaborn>=0.13.2
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+

ben_chem_tools-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "ben-chem-tools"
+version = "0.1.0"
+description = "common useful tools for computational chemistry"
+readme = "README.md"
+authors = [
+    { name = "Ben", email = "bennyp2494@gmail.com" }
+]
+requires-python = ">=3.9"
+dependencies = [
+    "cclib>=1.8.1",
+    "matplotlib>=3.9.4",
+    "numpy>=2.0.2",
+    "pandas>=2.3.3",
+    "periodictable>=2.0.2",
+    "scipy>=1.13.1",
+    "seaborn>=0.13.2",
+]
+
+[project.scripts]
+ben-chem-tools = "ben_chem_tools:main"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"

ben_chem_tools-0.1.0/src/ben_chem_tools/__init__.py

@@ -0,0 +1,8 @@
+from .geometries import xyz_atom
+from .geometries import xyz_molecule
+
+from .input_creation import g16_input
+from .input_creation import stationary_point_count
+from .input_creation import get_n_geometry
+from .input_creation import rerun_from_last_geom
+from .input_creation import quick_rerun_optimizations

ben_chem_tools-0.1.0/src/ben_chem_tools/geometries.py

@@ -0,0 +1,137 @@
+import numpy as np
+import periodictable as pt
+
+##################################################
+# This file holds objects for geometries like 
+# atoms and molecules.
+##################################################
+
+
+class xyz_atom:
+
+    def __init__(self,atom_label:str,x_coord:float,y_coord:float,z_coord:float):
+
+        self.atom_label = str(atom_label).split()[0]
+
+        try: 
+            self.x_coord = float(x_coord)
+        except ValueError:
+            raise ValueError("x_coord must be a numeric value.")
+        try: 
+            self.y_coord = float(x_coord)
+        except ValueError:
+            raise ValueError("y_coord must be a numeric value.")
+        try: 
+            self.z_coord = float(x_coord)
+        except ValueError:
+            raise ValueError("z_coord must be a numeric value.")
+        
+    @classmethod
+    def from_string(cls,atom_string:str):
+        atom_string = str(atom_string).strip().split()
+        if len(atom_string) !=4:
+            raise ValueError(f"Supplied string splits in to {len(atom_string)} items. Method requires 4.")
+        return cls(*atom_string)
+
+    @classmethod
+    def from_cclib_vals(cls,atom_num:int,coords:list[float]):
+        try: 
+            atom_label = pt.elements[int(atom_num)]
+        except ValueError:
+            atom_label = atom_num
+        except KeyError:
+            KeyError(f"atom number {atom_num} not found")
+        if len(coords) != 3:
+            raise ValueError(f"coords is {len(coords)} long. It must have a length of 3.")
+        return cls(atom_label,coords[0],coords[1],coords[2])
+    
+    def as_list(self):
+        return [self.atom_label,[self.x_coord,self.y_coord,self.z_coord]]
+    
+    def apply_transormation(self,transformation_matrix,inplace=False):
+
+        transformation_matrix = np.array(transformation_matrix)
+        transformation_matrix = transformation_matrix.reshape((3,3))
+        position_vector = np.array([self.x_coord,self.y_coord,self.z_coord])
+        position_vector = position_vector @ transformation_matrix
+
+        if inplace:
+            self.x_coord = float(position_vector[0])
+            self.y_coord = float(position_vector[1])
+            self.z_coord = float(position_vector[2])
+        return position_vector
+        
+    def __str__(self):
+        return f"{self.atom_label}    {self.x_coord:.6f}     {self.y_coord:.6f}     {self.z_coord:.6f}"
+    
+    def __repr__(self):
+        return f"{self.atom_label}    {self.x_coord:.6f}     {self.y_coord:.6f}     {self.z_coord:.6f}"
+
+
+
+
+class xyz_molecule:
+
+    def __init__(self,atom_list:list[xyz_atom]):
+        self.atom_list:list[xyz_atom] = atom_list
+
+    @classmethod
+    def from_cclib_vals(cls,atom_nums,atom_coords):
+        acc = []
+        for atom_num,atom_coord in zip(atom_nums,atom_coords):
+            acc.append(xyz_atom.from_cclib_vals(atom_num,atom_coords))
+        return cls(acc)
+    
+    @classmethod
+    def from_string(cls,molecule_string:str):
+        molecule_string = molecule_string.strip()
+        acc = []
+        for atom_string in molecule_string.split("\n"):
+            acc.append(xyz_atom.from_string(atom_string))
+        return cls(acc)
+    
+    @classmethod
+    def from_xyz_file(cls,file_path:str):
+        with open(file_path,"r") as file:
+            file_lines = file.readlines()
+            num_atoms = int(file_lines[0].strip())
+        acc = []
+        for line in file_lines[2:2+num_atoms]:
+            acc.append(xyz_atom.from_string(line))  
+        return cls(acc)  
+
+    def add_atom(self,new_atom):
+        self.atom_list.append(new_atom)
+
+
+
+    def as_list(self):
+        return [atom.as_list() for atom in self.atom_list]
+    
+    def write_xyz_file(self,file_name,comment_line=""):
+        with open(file_name,"w") as outfile:
+            outfile.write(f"{len(self.atom_list)}\n")
+            outfile.write(f"{comment_line}\n")
+            for atom in self.atom_list:
+                outfile.write(f"{str(atom)}\n")
+    
+    def apply_transformation(self,transformation_matrix,inplace=False):
+        transformed_coords = []
+        for atom in self.atom_list:
+            transformed_coords.append(atom.apply_transormation(transformation_matrix,inplace))
+        return transformed_coords
+    
+    def __str__(self):
+        acc = ""
+        for atom in self.atom_list:
+            acc += f"{str(atom)}\n"
+        acc = acc.strip()
+        return acc
+    
+    def __repr__(self):
+        acc = ""
+        for atom in self.atom_list:
+            acc += f"{str(atom)}\n"
+        acc = acc.strip()
+        return acc
+

ben_chem_tools-0.1.0/src/ben_chem_tools/input_creation.py

@@ -0,0 +1,173 @@
+from glob import glob
+import cclib
+import periodictable as pt
+from geometries import xyz_molecule, xyz_atom
+import os
+
+
+class g16_input:
+    """ a base level g16 input file
+    """
+
+    def __init__(self, input_line:str, geometry:xyz_molecule, file_name:str,charge:int,spin_mult:int, nproc = 36,mem = 5):
+        self.checkpoint = file_name[:-3] + "chk"
+        self.file_name = file_name
+        self.geometry = geometry
+        self.mem = mem
+        self.nproc = nproc
+        self.input_line = input_line.lower()
+        self.extra = ""
+        self.title_card = "Title Card"
+        self.charge = charge
+        self.spin_mult = spin_mult
+
+
+    def write_file(self):
+        """writes a file associated with the g16 input instance
+        """
+        out_string = f"""%chk={self.checkpoint}
+%nproc={self.nproc}
+%mem={self.mem}GB
+#p {self.input_line}
+
+{self.title_card}
+
+{self.charge} {self.spin_mult}
+{str(self.geometry)}
+
+{self.extra}
+
+
+"""
+        with open(self.file_name,"w") as file:
+            file.write(out_string)
+
+    @classmethod
+    def from_file(cls,file_name):
+        collect_input = False
+        input_line = ""
+        nproc = 36
+        mem = 5
+        charge_collected = False
+        charge = 0
+        spin_mult = 1
+        Title_Card = False
+        blank_counter = 0 
+        geometry = xyz_molecule([])
+
+        with open(file_name,"r") as file:
+            for line in file:
+                true_line = line.strip(" \n")
+
+                if "%mem" in true_line:
+                    mem = int(true_line.split("=")[1][:-2])
+
+                if "%nproc" in true_line:
+                    nproc = int(true_line.split("=")[1])
+
+                if collect_input == True and blank_counter == 0:
+                    input_line = input_line + " " + line.strip(" \n")
+
+                if "#p" in true_line:
+                    collect_input = True
+                    input_line = input_line + line.strip("\n")
+
+                if blank_counter == 2 and charge_collected and true_line != "":
+                    geometry.add_atom(xyz_atom.from_string(true_line))
+
+                if blank_counter == 2 and charge_collected == False:
+                    true_line = line.strip(" \n\t")
+                    charge_mult = true_line.split()
+                    charge = charge_mult[0]
+                    spin_mult = charge_mult[1]
+                    charge_collected = True
+                
+                if true_line.strip("\t") == "":
+                    blank_counter = blank_counter + 1
+
+                                 
+
+        return cls(input_line,geometry,file_name,charge,spin_mult,nproc = nproc,mem = mem)
+
+
+def stationary_point_count(output_file_pattern:str="*.log"):
+    """Evaluates files for number of stationary points
+Parameters
+----------
+output_file_pattern (str): a file pattern to match and evaluate stationary points.
+
+Returns
+-------
+list[tuple[str,int]]: a list of tuples containing the names of the log files and the number of stationary points"""
+
+    results ={}
+
+    for output_file in glob(output_file_pattern):
+        results[output_file] = 0
+        with open(output_file) as current_file:
+            for line in current_file:
+                results[output_file] += "Stationary point" in line
+
+    results = [(key,results[key]) for key in results.keys()]
+    if len(results.keys()) == 0:
+        raise FileExistsError(f"No files found to match pattern '{output_file_pattern}'.")
+    results = sorted(results,key = lambda x: x[1])
+    return results
+
+
+def get_n_geometry(log_file_name:str,n_geometry:int = -1):
+    """Grabs the nth geometry (zero indexed) from a log file. Defaults to the last geometry
+Parameters
+----------
+log_file_name (str): the path to a log file
+
+n_geometry (int): the index of the desired geometry
+
+Returns
+-------
+xyz_molecule"""
+
+    outfile = cclib.io.ccread(log_file_name)
+    atom_nums = outfile.atomnos
+    correct_geom = outfile.geometries[n_geometry]
+    return xyz_molecule.from_cclib_vals(atom_nums,correct_geom)
+
+def rerun_from_last_geom(file_to_rerun):
+    """reruns a job from the last geometry found in the log file.
+Parameters
+----------
+file_to_rerun (str): the path to a log file
+
+Returns
+-------
+None: reformats and resubmits g16 input"""
+    new_geometry = get_n_geometry(file_to_rerun)
+    old_input = g16_input.from_file(file_to_rerun[:-3]+"gjf")
+    old_input.geometry = new_geometry
+    old_input.write_file()
+    print(f"Rerunning {file_to_rerun[:-4]}")
+    os.system(f"sbatch {file_to_rerun[:-3]+"s"}")
+
+def quick_rerun_optimizations(log_file_pattern:str="*.log"):
+    """Reruns any files with only one stationary point, and notifies about files with 0 stationary points
+Parameters
+----------
+
+log_file_pattern (str): a pattern for the path of files to rerun.
+
+Returns
+-------
+None: reruns files with only 1 stationary point and prints advice for files with 0."""
+    statp_eval = stationary_point_count(log_file_pattern)
+
+    for file,statp_count in statp_eval:
+        if statp_count == 1:
+            rerun_from_last_geom(file)
+        elif statp_count == 0:
+            print(f"{file} requires manual check, not Stationary point found")
+
+
+
+
+
+