added geometry and stress import

Author: akaszynski

doc/ansys_stress.png

@@ -20,7 +20,6 @@
 # import sys
 # sys.path.insert(0, os.path.abspath('.'))
 import sphinx_rtd_theme
-#from pyansys import __version__
 
 # -- General configuration ------------------------------------------------
 
@@ -55,9 +54,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = u'0.15'
+version = u'0.16'
 # The full version, including alpha/beta/rc tags.
-release = u'0.15'
+release = u'0.16'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

doc/beam_stress.png

@@ -2,15 +2,15 @@ Examples
 ========
 
 These examples show how ANSYS binary and ASCII files can be read and displayed
-using pyansys.
-
+using pyansys.  These examples are meant to demonstrate the capabilities of 
+pyansys.  For more details see the other reference pages.
 
 Loading and Plotting an ANSYS Archive File
 ------------------------------------------
 
 .. _examples_ref:
 
-ANSYS archive files containing solid elements (both legacy and current), can
+ANSYS archive files containing solid elements (both legacy and current) can
 be loaded using ReadArchive and then converted to a vtk object.
 
 
@@ -51,11 +51,14 @@ VTK.
     grid.Plot()
 
 
-Loading and Plotting an ANSYS Result File
------------------------------------------
+Loading and Plotting Results from an ANSYS Result File
+------------------------------------------------------
+
+Loading the Result File
+~~~~~~~~~~~~~~~~~~~~~~~
 
 This example reads in binary results from a modal analysis of a beam from
-ANSYS.  This section of code does not rely on vtk and can be used solely with
+ANSYS.  This section of code does not rely on ``VTK`` and can be used solely with
 numpy installed.
 
 .. code:: python
@@ -64,12 +67,10 @@ numpy installed.
     import pyansys
     from pyansys import examples
     
-    # Sample result file and associated archive file
+    # Sample result file
     rstfile = examples.rstfile
-    hexarchivefile = examples.hexarchivefile
-    
     
-    # Create result reader object by loading the result file
+    # Create result object by loading the result file
     result = pyansys.ResultReader(rstfile)
     
     # Get beam natural frequencies
@@ -78,8 +79,9 @@ numpy installed.
     # Get the node numbers in this result file
     nnum = result.nnum
     
-    # Get the 1st bending mode shape.  Nodes are ordered according to nnum.
-    disp = result.GetResult(0, True) # uses 0 based indexing 
+    # Get the 1st bending mode shape.  Results are ordered based on the sorted 
+    # node numbering (by default and same as `nnum` above).
+    disp = result.GetNodalResult(0) # uses 0 based indexing 
     print disp
     
 .. code::
@@ -92,20 +94,41 @@ numpy installed.
      [ 26.60384371 -17.14955041  -2.40527841]
      [ 31.50985156 -20.31588852  -2.4327859 ]]
 
-You can then load in the archive file associated with the result file and then 
-plots a nodal result.
+Plotting Nodal Results
+~~~~~~~~~~~~~~~~~~~~~~
+
+As the geometry of the model is contained within the result file, you can plot
+the result without having to load any additional geometry.  Below, displacement
+for the first bending mode of the beam is plotted using ``VTK``.  To use this functionality,
+``VTK`` must be installed.
 
 .. code:: python
     
-    # Load CDB (necessary for display)
-    result.LoadArchive(hexarchivefile)
-    
     # Plot the displacement of Mode 0 in the x direction
     result.PlotNodalResult(0, 'x', label='Displacement')
-
+    
 
 .. image:: hexbeam_disp.png
 
+
+Stress can be plotted as well using the below code.  The nodal stress is 
+computed in the same manner that ANSYS uses by to determine the stress at each
+node by averaging the stress evaluated at that node for all attached elements.
+For now, only component stresses can be displayed.
+
+.. code:: python
+    
+    # Display node averaged stress in x direction for result 6
+    result.PlotNodalStress(5, 'Sx')
+    
+
+.. image:: beam_stress.png
+
+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
@@ -151,10 +174,13 @@ Data from the full file can now be accessed from the object.  If you have
 
 
 Built-In Examples
-=================
+-----------------
+
+The following examples can be run natively from pyansys by importing the 
+examples subpackage.
 
-Display Cell Quality
---------------------
+Plot Cell Quality
+~~~~~~~~~~~~~~~~~
 
 This built in example displays the minimum scaled jacobian of each element of a tetrahedral beam:
 
@@ -169,11 +195,14 @@ This is the source code for the example:
 
 .. code:: python
 
+    import pyansys
+
     # load archive file and parse for subsequent FEM queries
+    from pyansys import examples
     if meshtype == 'hex':
-        archive = pyansys.ReadArchive(hexarchivefile)
+        archive = pyansys.ReadArchive(examples.hexarchivefile)
     else:
-        archive = pyansys.ReadArchive(tetarchivefile)
+        archive = pyansys.ReadArchive(examples.tetarchivefile)
             
     # create vtk object
     archive.ParseFEM()
@@ -183,4 +212,35 @@ This is the source code for the example:
     
     # plot cell quality
     archive.uGrid.Plot(scalars=qual, stitle='Cell Minimum Scaled\nJacobian',
-                       rng=[0, 1])
+                       rng=[0, 1])
+    
+
+Plot Nodal Stress
+~~~~~~~~~~~~~~~~~
+This built in example plots the x component stress from a hexahedral beam.
+    
+.. code:: python
+
+    from pyansys import examples
+    examples.DisplayStress()
+
+.. image:: beam_stress.png
+
+This is the source code for the example:
+
+.. code:: python
+
+    import pyansys
+
+    # get location of the example file
+    from pyansys import examples
+    rstfile = examples.rstfile
+    
+    # Create rsult object
+    result = pyansys.ResultReader(rstfile)
+    
+    # Plot node averaged stress in x direction for result 6
+    result.PlotNodalStress(5, 'Sx')
+    
+    
+    

doc/cellqual.png

@@ -15,6 +15,7 @@ Contents
    :maxdepth: 2
 
    examples
+   loading_results
 
 Installation
 ------------
@@ -37,7 +38,7 @@ be installed with Python bindings.
 License
 -------
 
-pyansys is licensed under the MIT license.
+This module, pyansys is licensed under the MIT license.
 
 
 
@@ -46,4 +47,4 @@ Indices and tables
 
 * :ref:`genindex`
 * :ref:`modindex`
-* :ref:`search`
+* :ref:`search`

doc/conf.py

@@ -0,0 +1,118 @@
+Working with a ANSYS Result File (rst)
+======================================
+
+The ANSYS result file is a fortran formatted binary file containing the results
+written from an ANSYS analysis.  The results, at a minimum, contain the geometry
+of the model analyzed along with the nodal and element results.  Depending on
+the analysis, these results could be anything from modal displacements to 
+nodal temperatures.  At this time, only the following results are supported by
+this code
+    - Nodal DOF results from a static analysis or harmonic analysis.
+    - Nodal averaged component stresses (i.e. x, y, z, xy, xz, yz)
+
+We're working on adding additional plotting and retrival functions to the code 
+If you would like us to add an additional result type to be loaded, 
+please open an issue in `GitHub <https://github.com/akaszynski/pyansys>`_  and 
+include result file for the result type you wish to load.
+
+
+Loading the Result File
+~~~~~~~~~~~~~~~~~~~~~~~
+
+As the ANSYS result files are binary files, the entire file does not need to be
+loaded into memory in order to retrieve results.  This module
+accesses the results through a python object `result` which you can create with
+
+.. code:: python
+
+    import pyansys
+    result = pyansys.ResultReader('file.rst')
+    
+Upon initialization this result file contains several properties to include the
+time values from the analysis, node numbering, element numbering, etc.
+
+
+Result File Properties
+~~~~~~~~~~~~~~~~~~~~~~
+
+The properties of the result file can be listed the below code.  At the moment,
+the property listing is limited to only the number of results in the file.
+
+.. code:: python
+
+    result_dic = result.ResultsProperties()
+
+To obtain the time or frequency values of an analysis use:
+    
+.. code:: python
+
+    tval = result.GetTimeValues()
+    
+The sorted node and element numbering of a result can be obtained with:
+
+.. code:: python
+
+    # sorted node numbering
+    nnum = result.nnum
+    
+    # sorted element numbering
+    enum = result.enum
+    
+Geometry
+~~~~~~~~
+    
+The geometry of the model can be accessed directly from the dictionary by 
+accessing
+
+.. code:: python
+
+    result.geometry
+    
+Which contains the following keys
+
+    - ``'nnum'`` (sorted node numbering )
+    - ``'nodes'`` (node positions)
+    - ``'etype'`` (element type)
+    - ``'enum'`` (non-sorted element numbers associated with elem array)
+    - ``'elem'`` (numpy array showing nodes associated with each element, -1 indicates unused entry)
+    - ``'ekey'`` (2xn element type reference array)
+    
+
+Accessing Solution Results
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The DOF solution for an analysis for each node in the analysis can be obtained
+using the code block below.  These results correspond to the node numbers in
+the result file.  This array is sized by the number of nodes by the number of 
+degrees of freedom.
+
+.. code:: python    
+
+    # Create an array of results (nnod x dof)
+    disp = result.GetNodalResult(0) # uses 0 based indexing 
+    
+    # which corresponds to the sorted node numbers from
+    nnum = result.nnum
+
+    # The same results can be plotted using 
+    display_string = 'Displacement' # optional string
+    result.PlotNodalResult(0, 'x', label=display_string) # x displacement
+
+    # normalized displacement can be plotted by excluding the direction string
+    result.PlotNodalResult(0, label='Normalized')
+
+Stress can be obtained as well using the below code.  The nodal stress is 
+computed in the same manner that ANSYS uses by to determine the stress at each
+node by averaging the stress evaluated at that node for all attached elements.
+For now, only component stresses can be displayed.
+
+.. code:: python
+    
+    # obtain the component node averaged stress for the first result
+    # organized with one [Sx, Sy Sz, Sxy, Syz, Sxz] entry for each node
+    stress = result.NodalStress(0) # results in a np array (nnod x 6)
+
+    # Display node averaged stress in x direction for result 6
+    result.PlotNodalStress(5, 'Sx')
+    
+  

doc/examples.rst

@@ -1,4 +1,4 @@
-__version__ = u'0.15'
+__version__ = u'0.16'
 
 #from pyansys import Reader
 #from pyansys.Reader import ResultReader

doc/index.rst

@@ -21,7 +21,7 @@
 
 # Attempt to load VTK dependent modules
 try:
-    from vtkInterface import utilities
+    import vtkInterface
     vtk_loaded = True
 except:
     warnings.warn('Unable to load vtk dependent modules')
@@ -132,7 +132,7 @@ def ParseVTK(self, use_cython=True, force_linear=False):
 
 
         # Create unstructured grid
-        uGrid = utilities.MakeuGrid(offset, cells, cell_type, nodes)
+        uGrid = vtkInterface.MakeuGrid(offset, cells, cell_type, nodes)
 
         # Store original ANSYS cell and node numbering
         uGrid.AddPointScalars(nnum, 'ANSYSnodenum')
@@ -172,9 +172,9 @@ def ParseFEM(self, use_cython=True, raw=None):
             self.data = PythonParser.ParseForFEM(self.raw)
 
         # Create unstructured grid
-        self.uGrid = utilities.MakeuGrid(self.data['offset'], self.data['cells'], 
-                                         self.data['cell_type'],
-                                         self.data['nodes'][:, :3])
+        self.uGrid = vtkInterface.MakeuGrid(self.data['offset'], self.data['cells'], 
+                                            self.data['cell_type'],
+                                            self.data['nodes'][:, :3])
 
         # Store original ANSYS cell and node numbering
         self.uGrid.AddPointScalars(self.data['orignode'], 'ANSYSnodenum')