webmo 1.3.3__tar.gz → 1.4.2__tar.gz

{webmo-1.3.3/webmo.egg-info → webmo-1.4.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: webmo
-Version: 1.3.3
+Version: 1.4.2
 Summary: A Python-based interface to WebMO
 Home-page: https://github.com/jrschmidt2/webmo-python
-Download-URL: https://github.com/jrschmidt2/webmo-python/archive/refs/tags/1.3.3.tar.gz
+Download-URL: https://github.com/jrschmidt2/webmo-python/archive/refs/tags/1.4.2.tar.gz
 Author: J.R. Schmidt
 Author-email: schmidt@webmo.net
 License: MIT

{webmo-1.3.3 → webmo-1.4.2}/webmo/__init__.py

@@ -1,2 +1,2 @@
 from .webmo_rest import WebMOREST
-__version__ = "1.3.3"
+__version__ = "1.4.2"

{webmo-1.3.3 → webmo-1.4.2}/webmo/gui.py

@@ -50,6 +50,8 @@ class JupyterGUI(_WebMOGUIBase):
         #fail silently, since this should never happen in Jupyter
         pass #print('ipywidgets not found; disabling support for JupyterGUI')
 
+    import time
+
     def __init__(self, template, query_vars, additional_vars=None):
         """Constructor for JupyterGUI
 
@@ -66,6 +68,7 @@ class JupyterGUI(_WebMOGUIBase):
 
         _WebMOGUIBase.__init__(self, template, query_vars, additional_vars)
         self._widgets = []
+        self._display_time = -1
 
         for var in query_vars:
             if template['variables'][var]['type'] == 'checkbox':
@@ -93,11 +96,20 @@ class JupyterGUI(_WebMOGUIBase):
 
     def display(self):
 
+        self._display_time = self.time.time()
+
         for widget in self._widgets:
             display(widget)
 
     def get_variables(self):
 
+        MIN_INPUT_TIME = 1.0
+        # sanity check to make sure user has had time to input something
+        # fail this call during re-execution of entire notebook at once
+        elapsed_time = self.time.time() - self._display_time
+        if self._display_time == -1 or elapsed_time < MIN_INPUT_TIME:
+            raise RuntimeError('Must provide JupyterGUI input before calling get_variables')
+
         # add in additional user-specified variables
         if (self._additional_vars != None):
             variables = {**self._additional_vars}

{webmo-1.3.3 → webmo-1.4.2}/webmo/spectrum.py

@@ -330,8 +330,10 @@ def voigt_line(center, intensity, width=10, q=0.5, start=0, stop=4000, step=1):
     Returns:
     	(x,y): a tuple of the x and y numpy arrays of the specified line
     """
-    if (not 0 < q < 1):
-        q = 0.5
+    if (q <= 0):
+        return(gauss_line(center, intensity, width, start, stop, step))
+    elif (q >= 1):
+        return(lorentz_line(center,intensity,width,start,stop,step))
 
     x = np.arange(start=start, stop=stop, step=step)
     vfunc = np.vectorize(_arb_voigt(center, intensity, q, width))
@@ -345,7 +347,7 @@ def _arb_gaussian(center, intensity, width=10):
     from math import sqrt, pi, exp, log
 
     sigma = (width / (2 * sqrt(2 * log(2))))
-    l = lambda x: intensity * (1/sigma*sqrt(2*pi)) * exp(-((x-center)**2/(2*sigma**2)))
+    l = lambda x: intensity * (1/(sigma*sqrt(2*pi))) * exp(-((x-center)**2/(2*sigma**2)))
 
     return l
 
@@ -403,7 +405,7 @@ def lorentz_line(center, intensity, width=10, start=0, stop=4000, step=1):
     vfunc = np.vectorize(_arb_lorentz(center, intensity, width))
     return((x,vfunc(x)))
 
-def construct_spectrum(points, intensities, lineshape="gauss", width=10, start=0, stop=4000, step=1):
+def construct_spectrum(points, intensities, lineshape="gauss", frac_loren=0.5, width=10, start=0, stop=4000, step=1):
     """Construct an entire spectrum plot of data
 
     This function returns a pair of numpy arrays that make a spectrum; an x axis
@@ -415,6 +417,7 @@ def construct_spectrum(points, intensities, lineshape="gauss", width=10, start=0
     	intensities([float]): a list of corresponding peak intensities - the order must
     			      match `points`
     	lineshape(string,optional): the desired lineshape. The options are "gauss", "lorentz", and "voigt"
+        frac_loren(float,optional): the fraction lorentzian of the voigt lineshape, if specified
     	width(float,optional): the full width half max of each peak
     	start(float,optional): the starting point of the returned array
     	stop(float,optional): the ending point of the returned array
@@ -428,10 +431,10 @@ def construct_spectrum(points, intensities, lineshape="gauss", width=10, start=0
     linefuncs = {
         "gauss": gauss_line,
         "lorentz": lorentz_line,
-        "voigt": voigt_line
+        "voigt": lambda x, y, **kwargs: voigt_line(x,y,q=frac_loren, **kwargs)
     }
     if (lineshape not in linefuncs.keys()):
-        linefunc = gauss_line
+        raise AssertionError("invalid lineshape specified")
     else:
         linefunc = linefuncs[lineshape]
 

webmo-1.4.2/webmo/util.py

@@ -0,0 +1,287 @@
+import numpy as np
+
+def xyz_from_name(name):
+    """Obtains an XYZ-formatted geometry for the molecule name via PubChem lookup.
+
+    Arguments:
+        name(str): The name of the molecule.
+
+    Returns:
+        A string containing the molecule's XYZ-formatted geometry.
+    """
+    import pubchempy as pcp
+
+    results = pcp.get_compounds(name, 'name', record_type='3d')
+    if (len(results) == 0):
+        raise ValueError("Specified molecule could not be found in PubChem")
+
+    record = results[0]
+    geom = ""
+    for atom in record.atoms:
+        element = atom.element
+        x = float(atom.x)
+        y = float(atom.y)
+        z = float(atom.z)
+        geom += f"{element}\t{x:f}\t{y:f}\t{z:f}\n"
+        
+    return geom
+
+def get_energy(results, include_units=False):
+    """Returns the molecular energy from the job results. This should correspond to the ground state energy
+    at molecule at the requested level of theory.
+
+    Requires WebMO 25 or higher.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+        bool(include_units): Whether to include the units with the returned energy (e.g. 1.5 vs. "1.5 Hartree")
+
+    Returns:
+        The molecular energy.
+    """
+    properties = results['properties']
+
+    if not 'method_energy_name' in properties.keys():
+        raise RuntimeError('Cannot locate "method_energy_name" in results')
+    method_energy_name = properties['method_energy_name'].lower().replace(' ', '_') + '_energy'
+
+    found = False
+    #also check related key names, since Gaussian prepends some things occasionally
+    for key in [method_energy_name, 'r' + method_energy_name, 'u' + method_energy_name, 'ro' + method_energy_name]:
+        if key in properties:
+            energy = properties[key]['value']
+            units = properties[key]['units']
+            found = True
+
+    if not found:
+        raise RuntimeError('Could not locate "' + method_energy_name + '" in results')
+
+    if include_units:
+        energy = f"{energy} {units}"
+
+    return energy
+
+def get_energies(results, include_units=False):
+    """Returns a dictionary of available energies from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+        bool(include_units): Whether to include the units with the returned energy (e.g. 1.5 vs. "1.5 Hartree")
+
+    Returns:
+        A dictionary of available energies.
+    """
+    properties = results['properties']
+    energies = {}
+
+    for key in properties.keys():
+        index = key.find('_energy')
+
+        if key.endswith('_energy'):
+            index = key.find('_energy')
+            energy_type = key[:index]
+
+            if include_units:
+                energies[energy_type] = f"{properties[key]['value']} {properties[key]['units']}"
+            else:
+                energies[energy_type] = properties[key]['value']
+
+    return energies
+
+def get_geometry(results):
+    """Returns the XYZ-formatted final geometry from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+
+    Returns:
+        The XYZ-formatted final geometry as a string.
+    """
+
+
+    geom = ""
+    index = 0
+    for element in results['symbols']:
+
+        x = results['geometry'][index]
+        y = results['geometry'][index + 1]
+        z = results['geometry'][index + 2]
+
+        geom += f"{element}\t{x:f}\t{y:f}\t{z:f}\n"
+        index += 3
+
+    return geom
+
+def get_stoichiometry(results):
+    """Returns the stoichiometry from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+
+    Returns:
+        The stoichiometry as a string.
+    """
+
+    properties = results['properties']
+    return properties['stoichiometry']
+
+def get_dipole_moment(results):
+    """Returns the dipole moment from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+
+    Returns:
+        The magnitude of the dipole moment.
+    """
+
+    from math import sqrt
+
+    properties = results['properties']
+    dipole = properties['dipole_moment']
+    mag = sqrt(dipole[0]**2 + dipole[1]**2 + dipole[2]**2)
+
+    return mag
+
+def get_property(results, property_name):
+    """Returns an arbitrary calculated property from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+        str(property_name): The name of the desired property
+
+    Returns:
+        The value of the calculated property (scalar or dictionary).
+    """
+
+    properties = results['properties']
+    return properties[property_name]
+
+
+def get_bond_length(results, index1, index2):
+    """Returns the specified bond length between two atoms from the job results OR an xyz-formatted string.
+
+    Arguments:
+        dict(results): A dictionary of job results obtained from get_job_results OR an xyz-formatted string.
+        index1(int): The one-based index of the first atom of the bonded pair
+        index2(int): The one-based index of the second atom of the bonded pair
+
+    Returns:
+        The calculated bond length.
+    """
+
+    if not isinstance(results, dict):
+        geom = _xyz_to_array(results)
+    else:
+        geom = results['geometry']
+
+    #convert to 0 index
+    index1 -= 1
+    index2 -= 1
+
+    atom1 = np.array(geom[index1*3:index1*3 + 3])
+    atom2 = np.array(geom[index2*3:index2*3 + 3])
+
+    return np.linalg.norm(atom1 - atom2)
+
+def get_bond_angle(results, index1, index2, index3):
+    """Returns the specified bond angle between three atoms from the job results OR an xyz-formatted string.
+
+    Arguments:
+        dict(results): A dictionary of job results obtained from get_job_results OR an xyz-formatted string.
+        index1(int): The one-based index of the first atom
+        index2(int): The one-based index of the second atom
+        index3(int): The one-based index of the third atom
+
+    Returns:
+        The calculated bond angle.
+    """
+
+    if not isinstance(results, dict):
+        geom = _xyz_to_array(results)
+    else:
+        geom = results['geometry']
+
+    #convert to 0 index
+    index1 -= 1
+    index2 -= 1
+    index3 -= 1
+
+    atom1 = np.array(geom[index1*3:index1*3 + 3])
+    atom2 = np.array(geom[index2*3:index2*3 + 3])
+    atom3 = np.array(geom[index3*3:index3*3 + 3])
+
+    vec1 = atom1 - atom2
+    vec2 = atom3 - atom2
+
+    vec1 /= np.linalg.norm(vec1)
+    vec2 /= np.linalg.norm(vec2)
+
+    return np.arccos(np.dot(vec1,vec2))*180./np.pi
+
+def get_dihedral_angle(results, index1, index2, index3, index4):
+    """Returns the specified dihedral angle between four atoms from the job results OR an xyz-formatted string.
+
+    Arguments:
+        dict(results): A dictionary of job results obtained from get_job_results OR an xyz-formatted string.
+        index1(int): The one-based index of the first atom
+        index2(int): The one-based index of the second atom
+        index3(int): The one-based index of the third atom
+        index4(int): The one-based index of the fourth atom
+
+    Returns:
+        The calculated dihedral angle.
+    """
+
+    if not isinstance(results, dict):
+        geom = _xyz_to_array(results)
+    else:
+        geom = results['geometry']
+
+    #convert to 0 index
+    index1 -= 1
+    index2 -= 1
+    index3 -= 1
+    index4 -= 1
+
+    atom1 = np.array(geom[index1*3:index1*3 + 3])
+    atom2 = np.array(geom[index2*3:index2*3 + 3])
+    atom3 = np.array(geom[index3*3:index3*3 + 3])
+    atom4 = np.array(geom[index4*3:index4*3 + 3])
+
+    b1 = atom1 - atom2
+    b2 = atom2 - atom3
+    b3 = atom3 - atom4
+
+    b1 /= np.linalg.norm(b1)
+    b2 /= np.linalg.norm(b2)
+    b3 /= np.linalg.norm(b3)
+
+    n1 = np.cross(b1, b2)
+    n2 = np.cross(b2, b3)
+    m = np.cross(n1, b2)
+
+    x = np.dot(n1, n2)
+    y = np.dot(m, n2)
+
+    return np.arctan2(y, x)*180./np.pi
+
+def _xyz_to_array(xyz):
+    xyz = xyz.strip()
+
+    try:
+        #throw exception if NOT a number, indicating that our XYZ file has no header
+        tokens = xyz.split()
+        int(tokens[0])
+        #this XYZ formatted string is proper, containing a header that must be removed
+        xyz = xyz.split("\n",2)[2]
+    except ValueError:
+        pass
+
+    #process the actual geometry of the XYZ file, converting into an array
+    geom = xyz.split()
+    #remove the element names, leaving only an array of positions
+    del geom[0::4]
+
+    #convert to an array of floats and return
+    return np.array(geom,dtype=float)

{webmo-1.3.3 → webmo-1.4.2}/webmo/webmo_rest.py

@@ -621,22 +621,10 @@ class WebMOREST:
     #
     # Helper functions
     #
-    def wait_for_job(self, job_number, poll_frequency=5):
-        """Waits for completion of the specified WebMO job
+    def wait_for_job(self, *job_numbers, poll_frequency=5):
+        """Waits for completion of the specified WebMO jobs(s)
         
-        This call blocks until the specified WebMO job has finished executing (successfully or not)
-        
-        Arguments:
-            job_number(int): The job number to wait for
-            poll_frequency(int, optional): The frequency at which to check the job status (default is 5s)
-        """
-        
-        self.wait_for_jobs([job_number], poll_frequency)
-    
-    def wait_for_jobs(self, job_numbers, poll_frequency=5):
-        """Waits for completion of the specified list of WebMO jobs
-        
-        This call blocks until the specified WebMO jobs have all finished executing (successfully or not)
+        This call blocks until the specified WebMO job(s) have all finished executing (successfully or not)
         
         Arguments:
             job_numbers(list): A list of job numbers which will be waited upon

{webmo-1.3.3 → webmo-1.4.2/webmo.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: webmo
-Version: 1.3.3
+Version: 1.4.2
 Summary: A Python-based interface to WebMO
 Home-page: https://github.com/jrschmidt2/webmo-python
-Download-URL: https://github.com/jrschmidt2/webmo-python/archive/refs/tags/1.3.3.tar.gz
+Download-URL: https://github.com/jrschmidt2/webmo-python/archive/refs/tags/1.4.2.tar.gz
 Author: J.R. Schmidt
 Author-email: schmidt@webmo.net
 License: MIT

webmo-1.3.3/webmo/util.py

@@ -1,25 +0,0 @@
-def xyz_from_name(name):
-    """Obtains an XYZ-formatted geometry for the molecule name via PubChem lookup.
-
-    Arguments:
-        name(str): The name of the molecule.
-
-    Returns:
-        A string containing the molecule's XYZ-formatted geometry.
-    """
-    import pubchempy as pcp
-
-    results = pcp.get_compounds(name, 'name', record_type='3d')
-    if (len(results) == 0):
-        raise ValueError("Specified molecule could not be found in PubChem")
-
-    record = results[0]
-    geom = ""
-    for atom in record.atoms:
-        element = atom.element
-        x = float(atom.x)
-        y = float(atom.y)
-        z = float(atom.z)
-        geom += f"{element}\t{x:f}\t{y:f}\t{z:f}\n"
-        
-    return geom