updated readme

Author: akaszynski

doc/examples.rst

@@ -129,49 +129,6 @@ Here's the same result as viewed from ANSYS.
 .. image:: ansys_stress.png
 
 
-Reading a Full File
--------------------
-This example reads in the mass and stiffness matrices associated with the above
-example.
-
-.. code:: python
-
-    # Load the reader from pyansys
-    import pyansys
-    
-    # Create result reader object and read in full file
-    fobj = pyansys.FullReader('file.full')
-    fobj.LoadFullKM()
-    
-
-Data from the full file can now be accessed from the object.  If you have 
-``scipy`` installed, you can construct a sparse matrix and solve it.
-
-.. code:: python
-
-    import numpy as np
-    from scipy.sparse import csc_matrix, linalg
-    ndim = fobj.nref.size
-    k = csc_matrix((fobj.kdata, (fobj.krows, fobj.kcols)), shape=(ndim, ndim))
-    m = csc_matrix((fobj.mdata, (fobj.mrows, fobj.mcols)), shape=(ndim, ndim))
-    
-    # Solve
-    w, v = linalg.eigsh(k, k=20, M=m, sigma=10000)
-    # System natural frequencies
-    f = (np.real(w))**0.5/(2*np.pi)
-    
-    print('First four natural frequencies')
-    for i in range(4):
-        print '{:.3f} Hz'.format(f[i])
-    
-.. code:: 
-
-    First four natural frequencies
-    1283.200 Hz
-    1283.200 Hz
-    5781.975 Hz
-    6919.399 Hz
-
 
 Built-In Examples
 -----------------

doc/index.rst

@@ -16,6 +16,7 @@ Contents
 
    examples
    loading_results
+   loading_km
 
 Installation
 ------------

doc/loading_km.rst

@@ -0,0 +1,61 @@
+Working with a ANSYS Full File (full)
+======================================
+
+The ANSYS full file is a fortran formatted binary file containing the mass and
+stiffness from an ANSYS analysis.  Using pyansys it can be loaded into memory
+as either a sparse or full matrix.
+
+
+Reading a Full File
+-------------------
+This example reads in the mass and stiffness matrices associated with the above
+example.  By default, ``LoadKM`` sorts degrees of freedom such that the nodes are
+ordered from minimum to maximum, and each degree of freedom (i.e. X, Y, Z), are
+sorted within each node.  This increases the bandwidth of mass and stiffness
+matrices and can be disabled by setting ``sort=False``.  The matrices ``k`` and
+``m`` are sparse by default, but if ``scipy`` is not installed, or if the
+optional parameter ``as_sparse=False`` then they will be full numpy arrays.
+
+.. code:: python
+
+    # Load pyansys
+    import pyansys
+    
+    # Create result reader object and read in full file
+    fobj = pyansys.FullReader('file.full')
+    dof_ref, k, m = fobj.LoadKM()
+    
+
+If you have ``scipy`` installed, you can solve solve for the natural 
+frequencies of a system.
+
+.. code:: python
+
+    from scipy.sparse import linalg
+    #numpy.linalg.eig
+
+    # Solve
+    w, v = linalg.eigsh(k, k=20, M=m, sigma=10000)
+
+    # System natural frequencies
+    f = (np.real(w))**0.5/(2*np.pi)
+    
+    print('First four natural frequencies')
+    for i in range(4):
+        print '{:.3f} Hz'.format(f[i])
+    
+.. code:: 
+
+    First four natural frequencies
+    1283.200 Hz
+    1283.200 Hz
+    5781.975 Hz
+    6919.399 Hz
+    
+This exact example can be run from pyansys's examples::
+
+    from pyansys import examples
+    examples.LoadKM()
+    
+    
+    

pyansys/binary_reader.py

@@ -1,3 +1,4 @@
+import os
 import numpy as np
 import warnings
 import logging
@@ -79,6 +80,10 @@ def __init__(self, filename):
         
         """
 
+        # check if file exists
+        if not os.path.isfile(filename):
+            raise Exception('{:s} not found'.format(filename))
+        
         self.filename = filename
         self.header = _parsefull.ReturnHeader(filename)
 
@@ -91,39 +96,44 @@ def __init__(self, filename):
             raise Exception ("Unable to read an unsymmetric mass/stiffness matrix.")
 
 
-    def LoadFullKM(self):
+    def LoadKM(self, as_sparse=True, sort=True):
         """
-        Load indices for constructing symmetric mass and stiffness
-        matricies
+        Load and construct mass and stiffness matrices from an ANSYS full file.
 
-        STORES TO SELF:
-        
-        nref (np.int32 array)
-            Ordered reference to original ANSYS node numbers
+        Parameters
+        ----------
+        as_sparse : bool, optional
+            Outputs the mass and stiffness matrices as scipy csc sparse arrays
+            when True by default.
+            
+        sort : bool, optional
+            By default, this setting sorts the rows and columns such that the 
+            nodes are in order.  ANSYS stores the mass and stiffness matrices 
+            such that the bandwidth of the arrays is minimized.  Therefore, to
+            minimize the bandwidth of the arrays, make this setting False.
+            
         
-        dref (np.int32 array)
-            DOF reference where
+        Returns
+        -------
+        dof_ref : (n x 2) np.int32 array
+            This array contains the node and degree corresponding to each row 
+            and column in the mass and stiffness matrices.  When the sort 
+            parameter is set to True this array will be sorted by node number
+            first and then by the degree of freedom.  In a 3 DOF analysis the 
+            intergers will correspond to:
             0 - x
             1 - y
             2 - z
-
-        krows (np.int32 array)
-            Rows to construct the sparse stiffness matrix
-
-        kcols (np.int32 array)
-            Columns to construct the sparse stiffness matrix
+            
+        k : (n x n) np.float or scipy.csc array
+            Stiffness array
+            
+        m : (n x n) np.float or scipy.csc array
+            Mass array
+        
+        Notes
+        -----
         
-        kdata (np.int32 array)
-            Data for each entry in thesparse stiffness matrix
-
-        mrows (np.int32 array)
-            Rows to construct the mass stiffness matrix
-
-        mcols (np.int32 array)
-            Columns to construct the mass stiffness matrix
-
-        mdata (np.int32 array)
-            Data to construct the mass stiffness matrix
         
         """
         data = _parsefull.ReturnFull_KM(self.filename)
@@ -144,7 +154,54 @@ def LoadFullKM(self):
         self.mcols = data[6]
         self.mdata = data[7]
 
-    
+        # see if 
+        if as_sparse:
+            try:
+                from scipy.sparse import csc_matrix
+            except:
+                raise Exception('Unable to load scipy, matricies will be full')
+                as_sparse = False
+        
+        # number of dimentions and degree of freedom reference
+        ndim = self.nref.size
+        dof_ref = np.vstack((self.nref, self.dref)).T
+        idx, ridx = Unique_Rows(dof_ref)
+
+        # resort K and M matries to ordered sorted node order
+        if sort:
+            # determine unique nodes and sorted indices
+            krow = ridx[self.krows]
+            kcol = ridx[self.kcols]
+            
+            # get number of degrees of freedom
+            krow = ridx[self.krows]
+            kcol = ridx[self.kcols]
+            mrow = ridx[self.mrows]         
+            mcol = ridx[self.mcols]         
+            
+            # sorted references
+            dof_ref = dof_ref[idx]
+            
+        else:
+            krow = self.krows
+            kcol = self.kcols
+            mrow = self.mrows
+            mcol = self.mcols
+            
+        # output as a sparse matrix
+        if as_sparse:
+            k = csc_matrix((self.kdata, (krow, kcol)), shape=(ndim,)*2)
+            m = csc_matrix((self.mdata, (mrow, mcol)), shape=(ndim,)*2)
+            
+        else:
+            k = np.zeros((ndim,)*2)
+            k[krow, kcol] = self.kdata
+
+            m = np.zeros((ndim,)*2)
+            m[mrow, mcol] = self.mdata
+
+        return dof_ref, k, m
+        
 
 class ResultReader(object):
     """
@@ -153,19 +210,22 @@ class ResultReader(object):
 
     def __init__(self, filename, logger=False):
         """
-        SUMMARY
-        Loads basic result information from result file.
-
+        Loads basic result information from result file and initializes result
+        object.
     
-        INPUTS
-        filename (str)
+        Parameters
+        ----------
+        filename : string
             Filename of the ANSYS binary result file.
+            
+        logger : bool
+            Enables logging if True.  Debug feature.
         
         
-        OUTPUTS
+        Returns
+        -------
         None
         
-        
         """
 
         # set logging level depending on settings
@@ -826,3 +886,12 @@ def GetResultInfo(filename):
     return resultheader
 
 
+
+def Unique_Rows(a):
+    """ Returns unique rows of a and indices of those rows """
+    b = np.ascontiguousarray(a).view(np.dtype((np.void, a.dtype.itemsize * a.shape[1])))
+    _, idx, ridx = np.unique(b, return_index=True, return_inverse=True)
+    
+    return idx, ridx
+
+

pyansys/examples/examples.py

@@ -4,7 +4,7 @@
 """
 
 from __future__ import print_function
-import os
+import os, inspect, sys
 
 import pyansys
 
@@ -17,6 +17,17 @@
 hexbeamfile = os.path.join(dir_path, 'hexbeam.vtk')
 fullfile = os.path.join(dir_path, 'file.full')
 
+    
+def RunAll():
+    """ Runs all the functions within this module """
+    testfunctions = []
+    for name, obj in inspect.getmembers(sys.modules[__name__]):
+        if inspect.isfunction(obj) and name != 'RunAll':
+              testfunctions.append(obj)      
+
+    # run all the functions
+    any(f() for f in testfunctions)
+
 
 def DisplayHexBeam():
     """ Displays a hex beam mesh """
@@ -76,7 +87,7 @@ def LoadKM():
 
     # Create file reader object
     fobj = pyansys.FullReader(fullfile)
-    fobj.LoadFullKM()
+    dof_ref, k, m = fobj.LoadKM()
 
     ndim = fobj.nref.size
 
@@ -85,6 +96,23 @@ def LoadKM():
     print('\t k has {:d} entries'.format(fobj.krows.size))
     print('\t m has {:d} entries'.format(fobj.mrows.size))
 
+    # compute natural frequencies if installed
+    try:
+        from scipy.sparse import linalg
+    except:
+        return
+    
+    import numpy as np
+    # Solve
+    w, v = linalg.eigsh(k, k=20, M=m, sigma=10000)
+
+    # System natural frequencies
+    f = np.real(w)**0.5/(2*np.pi)
+    
+    print('First four natural frequencies:')
+    for i in range(4):
+        print('{:.3f} Hz'.format(f[i]))
+        
 
 def DisplayCellQual(meshtype='tet'):
     """ 
@@ -120,15 +148,3 @@ def DisplayCellQual(meshtype='tet'):
     archive.uGrid.Plot(scalars=qual, stitle='Cell Minimum Scaled\nJacobian',
                        rng=[0, 1])
 
-    
-    
-def RunAll():
-    """ Runs all examples in this file """
-    DisplayCellQual()
-    DisplayCellQual('hex')
-    LoadKM()
-    DisplayHexBeam()
-    LoadResult()
-    DisplayDisplacement()
-    
-