Added full file reader

Author: akaszynski

LICENSE

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 Copyright (c) 2016 Alex Kaszynski
 
-"Software" refers to python module ANSYScdb and all python and cython source code within.
+"Software" refers to python module pyansys and all python and cython source code within.
 
 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:
 

MANIFEST.in

@@ -0,0 +1,2 @@
+include pyansys/cython/*.h
+

README.rst

@@ -2,14 +2,14 @@ pyansys
 ========
 
 Python module to extract data from ANSYS binary files and to display
-them if vtk is installed.  Currently only supports (*.rst) files.
+them if vtk is installed.  Currently supports (*.rst) and (*.full) files.
 
 Installation
 ------------
 
-From source directory
+From PyPi directory
 
-``pip install .``
+``pip install pyansys``
 
 or
 
@@ -24,7 +24,7 @@ provided in the file named ``LICENSE``.
 Dependencies
 ------------
 
-Required: ``numpy``, ``ANSYScdb``. Optional: ``vtk``
+Required: ``numpy``, ``cython``, ``ANSYScdb``. Optional: ``vtk``
 
 Minimum requirements are numpy to extract results from a results file. To
 convert the raw data to a VTK unstructured grid, vtk 5.0 or greater must
@@ -33,7 +33,7 @@ be installed with Python bindings.
 Tests
 -----
 
-Test installation with the following from Python
+Test installation with the following
 
 .. code:: python
 
@@ -45,12 +45,15 @@ Test installation with the following from Python
     # Display first bending mode of that beam
     Tests.Reader.Display()
 
+    # Load mass and stiffness matrices from the beam
+    Tests.Reader.LoadKM()
 
-Example Code
-------------
 
-Assumes you have the example files . Otherwise, replace
-‘Beam.cdb’ with your own blocked \*.cdb file.
+Example: Reading a Result File
+------------------------------
+This example reads in binary results from a modal analysis from ANSYS.
+
+Example files can be found within the Tests folder in installation folder.
 
 .. code:: python
 
@@ -75,3 +78,35 @@ Assumes you have the example files . Otherwise, replace
     # Plot the displacement of Mode 41 in the x direction
     fobj.PlotDisplacement(40, 'x')
 
+
+Example: Reading a full file
+----------------------------
+This example reads in mass and stiffness matrices associated with `Beam.cdb`
+
+Example files can be found within the Tests folder in installation folder.
+
+.. code:: python
+
+    # Load the reader from pyansys
+    from pyansys import Reader
+    
+    # Create result reader object
+    fobj = Reader.FullReader('file.full')
+    
+    # Read in full file
+    fobj.LoadFullKM()
+
+    # Data from the full file can now be accessed from the object
+    # Can be used construct a sparse matrix and solve it
+
+    # 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.kdata, (fobj.krows, fobj.kcols), shape=(ndim, ndim))
+    # Solve
+    #w, v = linalg.eigsh(k, k=20, M=m, sigma=10000)
+    # System natural frequencies
+    #f = np.sqrt(real(w))/(2*np.pi)
+
+    
+

pyansys/Reader.py

@@ -1,7 +1,14 @@
 import numpy as np
-from ANSYScdb import CDB_Reader
 import warnings
 
+from pyansys import _parsefull
+
+# Try to load optional items
+try:
+    from ANSYScdb import CDB_Reader
+except:
+    warnings.warn('CDB_Reader uninstalled')
+
 try:
     import vtk
     from vtk.util import numpy_support as VN
@@ -10,6 +17,92 @@
 except:
     warnings.warn('Cannot load vtk\nWill be unable to display results or load CDB.')
     vtkloaded = False
+
+
+class FullReader(object):
+    """
+    Object to store the results of an ANSYS full file
+
+    NOTES:
+    Currently only supports symmetric and real stiffness matrices as well as
+    non-lumped mass matrices.
+    
+    """
+    
+    def __init__(self, filename):
+        """
+        Loads full header on initialization
+        
+        See ANSYS programmer's reference manual full header section for
+        definitions of each header.
+        
+        """
+        
+        self.filename = filename
+        self.header = _parsefull.ReturnHeader(filename)
+        
+        #// Check if lumped (item 11)
+        if self.header[11]:
+            raise Exception("Unable to read a lumped mass matrix.  Terminating.")
+    
+        # Check if arrays are unsymmetric (item 14)
+        if self.header[14]:
+            raise Exception ("Unable to read an unsymmetric mass/stiffness matrix.")
+
+
+    def LoadFullKM(self):
+        """
+        Load indices for constructing symmetric mass and stiffness
+        matricies
+
+        STORES TO SELF:
+        
+        nref (np.int32 array)
+            Ordered reference to original ANSYS node numbers
+        
+        dref (np.int32 array)
+            DOF reference where
+            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
+        
+        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)
+        
+        # nodal reference
+        self.nref = data[0]
+        
+        # DOF reference
+        self.dref = data[1]
+
+        # stiffness rows, columns, and data
+        self.krows = data[2]
+        self.kcols = data[3]
+        self.kdata = data[4]
+        
+        # stiffness rows, columns, and data
+        self.mrows = data[5]
+        self.mcols = data[6]
+        self.mdata = data[7]
+        
 
 
 class ResultReader(object):

pyansys/Tests/Reader.py

@@ -7,11 +7,12 @@
 
 from pyansys import Reader
 
-def Load():
+pth = dirname(realpath(__file__))
+
+def LoadResult():
     """ Load and plot hexahedral beam """
 
     # get location of this file
-    pth = dirname(realpath(__file__))
     filename = join(pth, 'file.rst')
 
     fobj = Reader.ResultReader(filename)
@@ -31,16 +32,30 @@ def Load():
         z = disp[i, 2]
         print('{:2d}  {:10.6f}   {:10.6f}   {:10.6f}'.format(node, x, y, z))
 
-#    return disp
 
-def Display():
+def DisplayResult():
     """ Load and plot hexahedral beam """
 
     # get location of this file
-    pth = dirname(realpath(__file__))
-    
     fobj = Reader.ResultReader(join(pth, 'file.rst'))
     fobj.LoadCDB(join(pth, 'HexBeam.cdb'))
 
     print('Displaying ANSYS Mode 1')
     fobj.PlotDisplacement(0)
+
+
+def LoadKM():
+    """ Loads m and k matrices from a full file """
+    
+    # Create file reader object
+    fobj = Reader.FullReader(join(pth, 'file.full'))
+    fobj.LoadFullKM()
+
+    ndim = fobj.nref.size
+
+    # print results
+    print('Loaded {:d} x {:d} mass and stiffness matrices'.format(ndim, ndim))
+    print('\t k has {:d} entries'.format(fobj.krows.size))
+    print('\t m has {:d} entries'.format(fobj.mrows.size))
+
+

pyansys/Tests/file.full

@@ -0,0 +1,98 @@
+import numpy as np
+cimport numpy as np
+
+# Definitions from c header
+cdef extern from "parsefull.h":
+    int return_fheader(char*, int*)
+    
+    void read_full(int*, int*, int*, int*, int*, double*, int*, int*, double*,
+                   int*, char*);
+
+
+def ReturnHeader(filename):
+    """ Just reads in the header """
+    # Convert python string to char array
+    cdef bytes py_bytes = filename.encode()
+    cdef char* c_filename = py_bytes
+    
+    # Read header
+    cdef int [::1] fheader = np.empty(101, np.int32)
+    return_fheader(c_filename, &fheader[0])
+    
+    return np.asarray(fheader)
+    
+    
+def ReturnFull_KM(filename):
+    """
+    Reads an ANSYS full file and returns indices to construct symmetric, real, 
+    and sparse mass and stiffness matrices
+    """
+    
+    # Convert python string to char array
+    cdef bytes py_bytes = filename.encode()
+    cdef char* c_filename = py_bytes
+    
+    # Read header
+    cdef int [::1] fheader = np.empty(101, np.int32)
+    cdef int rst = return_fheader(c_filename, &fheader[0])
+
+    cdef int neqn = fheader[2];    #  Number of equations
+    cdef int ntermK = fheader[9];  # number of terms in stiffness matrix
+    cdef int nNodes = fheader[33]; # Number of nodes considered by assembly
+    cdef int ntermM = fheader[34]; # number of terms in mass matrix
+
+    #### Sanity check ####
+    #// Check if lumped (item 11)
+    if fheader[11]:
+        raise Exception("Unable to read a lumped mass matrix.  Terminating.")
+
+    # Check if arrays are unsymmetric (item 14)
+    if fheader[14]:
+        raise Exception ("Unable to read an unsymmetric mass/stiffness matrix.")
+
+    # Create numpy memory views so they can be garbage collected later
+    cdef int[::1] numdat = np.empty(3, np.int32)
+    # tracks array sizes (nfree, kentry, mentry)
+
+    # node and dof reference arrays
+    cdef int[::1] nref = np.empty(nNodes*3, np.int32)
+    cdef int[::1] dref = np.empty(nNodes*3, np.int32)
+
+    # size mass and stiffness arrays
+    cdef int karrsz = 2*ntermK - neqn
+    cdef int [::1] krows = np.empty(karrsz, np.int32)
+    cdef int [::1] kcols = np.empty(karrsz, np.int32)
+    cdef double [::1] kdata = np.empty(karrsz, np.double)
+
+    cdef int marrsz = 2*ntermM - neqn
+    cdef int [::1] mrows = np.empty(marrsz, np.int32)
+    cdef int [::1] mcols = np.empty(marrsz, np.int32)
+    cdef double [::1] mdata = np.empty(marrsz, np.double)
+
+    # Populate these arrays
+    read_full(&numdat[0], &nref[0], &dref[0], &krows[0], &kcols[0], &kdata[0],
+              &mrows[0], &mcols[0], &mdata[0], &fheader[0], c_filename)
+
+    # Grab array sizes
+    nfree = numdat[0]
+    kentry = numdat[1]
+    mentry = numdat[2]
+
+    # Return these to python
+    return (np.asarray(nref)[:nfree],
+           np.asarray(dref)[:nfree],
+           np.asarray(krows)[:kentry], 
+           np.asarray(kcols)[:kentry],
+           np.asarray(kdata)[:kentry],
+           np.asarray(mrows)[:mentry],
+           np.asarray(mcols)[:mentry],
+           np.asarray(mdata)[:mentry])
+
+
+
+
+
+
+
+
+

pyansys/cython/_parsefull.pyx

@@ -0,0 +1,3 @@
+int return_fheader(char*, int*);
+
+void read_full(int*, int*, int*, int*, int*, double*, int*, int*, double*, int*, char*);