Metadata-Version: 2.1
Name: pyansys
Version: 0.41.0
Summary: Pythonic interface to ANSYS binary files
Home-page: https://github.com/akaszynski/pyansys
Author: Alex Kaszynski
Author-email: akascap@gmail.com
License: MIT
Keywords: vtk ANSYS cdb full rst
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Scientific/Engineering :: Information Analysis
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX
Classifier: Operating System :: MacOS
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Requires-Dist: numpy (>=1.14.0)
Requires-Dist: pyvista (>=0.25.0)
Requires-Dist: ansys-corba
Requires-Dist: appdirs
Requires-Dist: psutil (>=5.0.0)
Requires-Dist: pexpect

pyansys
=======
.. image:: https://img.shields.io/pypi/v/pyansys.svg
    :target: https://pypi.org/project/pyansys/

.. image:: https://dev.azure.com/femorph/pyansys/_apis/build/status/akaszynski.pyansys?branchName=master
    :target: https://dev.azure.com/femorph/pyansys/_build/latest?definitionId=8&branchName=master


This Python module allows you to:
 - Interactively control an instance of ANSYS v14.5 + using Python on
   Linux, >=17.0 on Windows.
 - Extract data directly from binary ANSYS v14.5+ files and to display
   or animate them.
 - Rapidly read in binary result ``(.rst)``, binary mass and stiffness
   ``(.full)``, and ASCII block archive ``(.cdb)`` files.

See the `Documentation <https://akaszynski.github.io/pyansys/>`_ page for more details.


Installation
------------
Installation through pip::

    pip install pyansys

You can also visit `GitHub <https://github.com/akaszynski/pyansys>`_
to download the source.


Quick Examples
--------------
Many of the following examples are built in and can be run from the
build-in examples module.  For a quick demo, run:

.. code:: python

    from pyansys import examples
    examples.run_all()


Controlling ANSYS
~~~~~~~~~~~~~~~~~
Create an instance of ANSYS and interactively send commands to it.
This is a direct interface and does not rely on writing a temporary
script file.  You can also generate plots using ``matplotlib``.

.. code:: python

    import os
    import pyansys

    path = os.getcwd()
    mapdl = pyansys.launch_mapdl(run_location=path, interactive_plotting=True)

    # create a square area using keypoints
    mapdl.prep7()
    mapdl.k(1, 0, 0, 0)
    mapdl.k(2, 1, 0, 0)
    mapdl.k(3, 1, 1, 0)
    mapdl.k(4, 0, 1, 0)    
    mapdl.l(1, 2)
    mapdl.l(2, 3)
    mapdl.l(3, 4)
    mapdl.l(4, 1)
    mapdl.al(1, 2, 3, 4)
    mapdl.aplot()
    mapdl.save()
    mapdl.exit()

.. figure:: https://github.com/akaszynski/pyansys/raw/master/docs/images/aplot.png
    :width: 500pt


Loading and Plotting an ANSYS Archive File
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ANSYS archive files containing solid elements (both legacy and current), can be loaded using Archive and then converted to a vtk object.


.. code:: python

    import pyansys
    from pyansys import examples

    # Sample *.cdb
    filename = examples.hexarchivefile

    # Read ansys archive file
    archive = pyansys.Archive(filename)

    # Print raw data from cdb
    for key in archive.raw:
       print("%s : %s" % (key, archive.raw[key]))

    # Create a vtk unstructured grid from the raw data and plot it
    grid = archive.parse_vtk(force_linear=True)
    grid.plot(color='w', show_edges=True)

    # write this as a vtk xml file 
    grid.save('hex.vtu')

    # or as a vtk binary
    grid.save('hex.vtk')

.. figure:: https://github.com/akaszynski/pyansys/raw/master/docs/images/hexbeam.png
    :width: 500pt

You can then load this vtk file using ``pyvista`` or another program that uses VTK.

.. code:: python

    # Load this from vtk
    import pyvista as pv
    grid = pv.UnstructuredGrid('hex.vtu')
    grid.plot()


Loading the Result File
~~~~~~~~~~~~~~~~~~~~~~~
This example reads in binary results from a modal analysis of a beam
from ANSYS.

.. code:: python

    # Load the reader from pyansys
    import pyansys
    from pyansys import examples

    # Sample result file
    rstfile = examples.rstfile

    # Create result object by loading the result file
    result = pyansys.read_binary(rstfile)

    # Beam natural frequencies
    freqs = result.time_values

.. code:: python

    >>> print(freq)
    [ 7366.49503969  7366.49503969 11504.89523664 17285.70459456
      17285.70459457 20137.19299035]

    # Get the 1st bending mode shape.  Results are ordered based on the sorted 
    # node numbering.  Note that results are zero indexed
    nnum, disp = result.nodal_solution(0)

.. code:: python

    >>> print(disp)
    [[ 2.89623914e+01 -2.82480489e+01 -3.09226692e-01]
     [ 2.89489249e+01 -2.82342416e+01  2.47536161e+01]
     [ 2.89177130e+01 -2.82745126e+01  6.05151053e+00]
     [ 2.88715048e+01 -2.82764960e+01  1.22913304e+01]
     [ 2.89221536e+01 -2.82479511e+01  1.84965333e+01]
     [ 2.89623914e+01 -2.82480489e+01  3.09226692e-01]
     ...


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 mode of the modal analysis beam is
plotted using ``VTK``.

.. code:: python

    # Plot the displacement of Mode 0 in the x direction
    result.plot_nodal_solution(0, 'x', label='Displacement')


.. figure:: https://github.com/akaszynski/pyansys/raw/master/docs/images/hexbeam_disp.png
    :width: 500pt


Results can be plotted non-interactively and screenshots saved by
setting up the camera and saving the result.  This can help with the
visualization and post-processing of a batch result.

First, get the camera position from an interactive plot:

.. code:: python

    >>> cpos = result.plot_nodal_solution(0)
    >>> print(cpos)
    [(5.2722879880979345, 4.308737919176047, 10.467694436036483),
     (0.5, 0.5, 2.5),
     (-0.2565529433509593, 0.9227952809887077, -0.28745339908049733)]

Then generate the plot:

.. code:: python

    result.plot_nodal_solution(0, 'x', label='Displacement', cpos=cpos,
                               screenshot='hexbeam_disp.png',
                               window_size=[800, 600], interactive=False)

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.plot_nodal_stress(5, 'Sx')

.. figure:: https://github.com/akaszynski/pyansys/raw/master/docs/images/beam_stress.png
    :width: 500pt


Nodal stress can also be generated non-interactively with:

.. code:: python

    result.plot_nodal_stress(5, 'Sx', cpos=cpos, screenshot=beam_stress.png,
                           window_size=[800, 600], interactive=False)


Animating a Modal Solution
~~~~~~~~~~~~~~~~~~~~~~~~~~
Mode shapes from a modal analysis can be animated using ``animate_nodal_solution``:

.. code:: python

    result.animate_nodal_solution(0)

If you wish to save the animation to a file, specify the movie_filename and animate it with:

.. code:: python

    result.animate_nodal_solution(0, movie_filename='/tmp/movie.mp4', cpos=cpos)

.. figure:: https://github.com/akaszynski/pyansys/raw/master/docs/images/beam_mode_shape.gif
    :width: 500pt


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
    from scipy import sparse

    # load the full file
    fobj = pyansys.FullReader('file.full')
    dofref, k, m = fobj.load_km()  # returns upper triangle only

    # make k, m full, symmetric matrices
    k += sparse.triu(k, 1).T
    m += sparse.triu(m, 1).T

If you have ``scipy`` installed, you can solve the eigensystem for its
natural frequencies and mode shapes.

.. code:: python

    from scipy.sparse import linalg

    # condition the k matrix
    # to avoid getting the "Factor is exactly singular" error
    k += sparse.diags(np.random.random(k.shape[0])/1E20, shape=k.shape)

    # 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


Additional Tools
----------------
There are additional tools created by @natter1 at `pyansysTools <https://github.com/natter1/pyansysTools.git>`_ which include the following features:

 - Inline class: Implementing the ANSYS inline functions
 - Macros class: Macros for repeating tasks
 - The ``geo2d`` class: Easily create 2d geometries

You can also install `pyansystools` with

```
pip install pyansystools
```


License and Acknowledgments
---------------------------
``pyansys`` is licensed under the MIT license.

This module, ``pyansys`` makes no commercial claim over ANSYS
whatsoever.  This tool extends the functionality of ``ANSYS`` by
adding a Python interface in both file interface as well as
interactive scripting without changing the core behavior or license of
the original software.  The use of the interactive APDL control of
``pyansys`` requires a legally licensed local copy of ANSYS.

To get a copy of ANSYS, please visit `ANSYS <https://www.ansys.com/>`_


