Getting started#

To use the solver features of PyDYNA, you must have a valid LS-DYNA license.

For information on getting a licensed copy of LS-DYNA, see the Ansys LS-DYNA page on the Ansys website.

Installation#

PyDYNA consists of two modules, ansys.dyna.core.pre and ansys.dyna.core.solver. Both these modules are gRPC enabled and hence need to be run using server-client connection.

Install the client#

The ansys.dyna.core package supports Python 3.9 through Python 3.12 on Windows, Linux, and MacOS.

You should consider installing PyDYNA in a virtual environment. For more information, see Python’s venv – Creation of virtual environments.

PyDYNA has three installation modes: user, developer, and offline.

Install in user mode#

Before installing PyDYNA in user mode, make sure you have the latest version of pip with this command:

python -m pip install -U pip

Then, install PyDYNA with this command:

python -m pip install ansys-dyna-core

Install in developer mode#

Installing PyDYNA in developer mode allows you to modify the source and enhance it.

Note

Before contributing to the project, ensure that you are thoroughly familiar with the PyAnsys Developer’s Guide.

Start by cloning and installing the repository with these commands:

git clone https://github.com/pyansys/pyDyna
cd pyDyna
pip install -e .

Install in offline mode#

If you lack an internet connection on your installation machine, you should install PyDYNA by downloading the wheelhouse archive for your corresponding machine architecture from the Releases Page.

Each wheelhouse archive contains all the Python wheels necessary to install PyDYNA from scratch on Windows and Linux for Python 3.9 through 3.12. You can install PyDYNA on an isolated system with a fresh Python installation or on a virtual environment.

For example, on Linux with Python 3.9, unzip the wheelhouse archive and install PyDYNA with these commands:

unzip ansys-dyna-core-v0.3.dev0-wheelhouse-Linux-3.9.zip -d wheelhouse
pip install ansys-dyna-core -f wheelhouse --no-index --upgrade --ignore-installed

If you’re on Windows with Python 3.9, unzip the wheelhouse archive to a wheelhouse directory and install PyDYNA using the preceding command.

Run PyDYNA server locally#

Launching the servers directly on local machines.

Start PyDYNA preprocessing server locally#

Run an example on the client side#

hostname = "localhost"
if len(sys.argv) > 1:
    hostname = sys.argv[1]
    solution = launch_dynapre(ip = hostname)
    ......

The function of launch_dynapre() can download and start the preprocessing server automatically.

Start PyDYNA solver server locally#

Prerequisites#

Start server on Windows#

If you want to start the server on Windows,please ensure that you have installed the ANSYS locally.

Start server on Linux(Centos7)#

If you want to start the server on Linux,please ensure that you have installed the Open MPI package.
```
yum install openmpi3 openmpi3-dev
```

set environment variable for Open MPI

export LD_LIBRARY_PATH=/usr/lib64/openmpi3/lib:$LD_LIBRARY_PATH
export PATH=/usr/lib64/openmpi3/bin:$PATH

Run an example on the client side#

import ansys.dyna.core.solver as solver

hostname = "localhost"
port = "5000"
dyna=launch_dyna(ip = hostname,port = port)     # connect to the server
dyna.push("./output/ball_plate.k")        # push an input file
dyna.start_locally(input = "ball_plate.k",nproc=1)

The function of DynaSolver() can download and start the solver server automatically.

Run PyDYNA Server in a Docker container#

PyDYNA server can be run in a Docker container.

Build the Docker image for the `pre` service#

You must build the Docker image for the PyDYNA pre service and then run the image as a container.

Prerequisites#

Ensure that you have cloned the PyDYNA repository locally with these commands:
```
git clone https://github.com/pyansys/pydyna.git
cd pydyna
```
The docker file in the docker/pre directory is used to build the Linux-based Docker image.
If you are building the image on Windows, ensure that the Windows Subsystem for Linux (WSL) is installed. For installation information, see Microsoft’s Install Linux on Windows with WSL.
Install docker engine. Based on the Linux distro you can use the corresponding installation instructions from this page.
Download the latest Linux release artifacts for the pre Docker container: linux-binaries.zip.
Move this ZIP file to the docker/pre directory.

Once all prerequisites are met, you can build the Docker container for the pre service.

Build the Docker container for the `pre` service#

To build the Docker image, perform these steps:

In your terminal, go to the docker directory.
Run the following Docker command, replacing <DOCKERFILE_NAME> with Dockerfile and <DOCKER_IMAGE_TAG> with latest.
```
docker build -t ghcr.io/ansys/ls-pre:<DOCKER_IMAGE_TAG> -f <DOCKERFILE_NAME> .
```

Check that the image has been built successfully by running this command:

docker images

Your output should look similar to this:

>>> REPOSITORY                                               TAG                                IMAGE ID       CREATED          SIZE
>>> ghcr.io/ansys/ls-pre                                     *******-latest                     ............   X seconds ago    188MB
>>> ......                                                   ......                             ............   ..............   ......

Run the image as a container#

Once the Docker image of the pre service is built successfully, perform these steps to run this image as a container:

Run this Docker command:

docker run -d -p 50051:50051 ghcr.io/ansys/ls-pre

Check that the image is running successfully by running this command.

docker ps

Your output should look similar to this:

>>> CONTAINER ID   IMAGE                  COMMAND                  CREATED         STATUS         PORTS                                           NAMES
>>> c77ffd67f9fa   ghcr.io/ansys/ls-pre   "python3 ./linux-bin…"   7 seconds ago   Up 7 seconds   0.0.0.0:50051->50051/tcp, :::50051->50051/tcp   hardcore_margulis

Alternatively, you can start the container for the pre service from a docker-compose.yml file.

Ensure that Docker Compose has been installed on your computer. If Docker Compose is not installed, see Overview of installing Docker Compose in the Docker documentation.
In your terminal, go to the docker/pre directory and run this Docker command:

docker compose up -d

Copy files from Docker#

To copy files back from the pre docker container to your host machine use the command below:

docker cp <containerId>:/file/path/within/container /host/target/path

The path within the container is /server/output.

Build the Docker image for the `solver` service#

You must build the Docker image for the PyDYNA solver service and then run the image as a container.

Prerequisites#

Ensure that you have cloned the PyDYNA repository locally with these commands:
```
git clone https://github.com/pyansys/pydyna.git
cd pydyna
```
The docker file in the docker/solver directory is used to build the Linux-based Docker image.
If you are building the image on Windows, ensure that the Windows Subsystem for Linux (WSL) is installed. For installation information, see Microsoft’s Install Linux on Windows with WSL.
Install docker engine. Based on the Linux distro you can use the corresponding installation instructions from this page.
Download the latest Linux release artifacts for the solver Docker container: mppdyna_docker_centos7.zip.
Move this ZIP file to the docker/solver directory.

The files in this folder should look similar to this:
```
>>> Dockerfile README.rst docker-compose.yml  mppdyna_docker_centos7.zip
```

Once all prerequisites are met, you can build the Docker image for the solver service.

Build the Docker image#

To build the Docker image for the solver service, perform these steps:

In your terminal, go to the pydyna/docker/solver directory.
Run this Docker command:
```
docker build -t dyna_solver_v04 .
```

Check that the image has been built successfully by running this command:

docker images

Your output should look similar to this:

>>> REPOSITORY                        TAG                                        IMAGE ID       CREATED          SIZE
>>> dyna_solver_v04                   latest                                     defbadbeee8e   16 minutes ago   730MB
>>> ......                                                   ......                             ............   ..............   ......

Start the container from a `docker-compose.yml` file#

Alternatively, you can start the container for the pre service from a docker-compose.yml file.

Ensure that Docker Compose has been installed on your computer. If Docker Compose is not installed, see Overview of installing Docker Compose in the Docker documentation.
In the docker-compose.yml file, replace <license_server_name> with the correct license server hosting the LS-DYNA license.
In your terminal, go to the docker/solver directory and run this Docker command:
```
docker compose up -d
```

Check that the image is running successfully by running this command.

docker ps

Your output should look similar to this:

>>> CONTAINER ID   IMAGE             COMMAND                  CREATED          STATUS         PORTS                            NAMES
>>> be84c95db31d   dyna_solver_v04   "/ansys_inc/server.p…"   18 minutes ago   Up 8 seconds   22/tcp, 0.0.0.0:5000->5000/tcp   mppdyna_docker_centos7_dyna_1

Copy files from Docker#

To copy files back from the solver container to your host machine use the command below:

docker cp <containerId>:/file/path/within/container /host/target/path

The path within the container is /rundir.

Example#

The next few sections show how to preprocessing, solve, and postprocessing a ball plate example.

Preprocessing#

The following code processes a ball plate example. In the repository, you can get the input file from src/ansys/dyna/core/pre/examples/explicit/ball_plate/ball_plate.k and the Python file from examples/Explicit/ball_plate.py.

import os
import sys
from ansys.dyna.core.pre import launch_dynapre
from ansys.dyna.core.pre.dynamech import (
    DynaMech,
    Velocity,
    PartSet,
    ShellPart,
    SolidPart,
    NodeSet,
    Contact,
    ContactSurface,
    ShellFormulation,
    SolidFormulation,
    ContactType,
    AnalysisType
)
from ansys.dyna.core.pre.dynamaterial import (
    MatRigid,
    MatPiecewiseLinearPlasticity,
)
from ansys.dyna.core.pre import examples

hostname = "localhost"
if len(sys.argv) > 1:
    hostname = sys.argv[1]
solution = launch_dynapre(ip = hostname)

fns = []
path = examples.ball_plate + os.sep
fns.append(path+"ball_plate.k")
solution.open_files(fns)

solution.set_termination(termination_time=10)

ballplate = DynaMech(AnalysisType.NONE)
solution.add(ballplate)

matrigid = MatRigid(mass_density=7.83e-6, young_modulus=207, poisson_ratio=0.3)
matplastic = MatPiecewiseLinearPlasticity(mass_density=7.83e-6, young_modulus=207, yield_stress=0.2, tangent_modulus=2)

plate = ShellPart(1)
plate.set_element_formulation(ShellFormulation.BELYTSCHKO_TSAY)
plate.set_material(matplastic)
plate.set_thickness(1)
plate.set_integration_points(5)
ballplate.parts.add(plate)

ball = SolidPart(2)
ball.set_material(matrigid)
ball.set_element_formulation(SolidFormulation.CONSTANT_STRESS_SOLID_ELEMENT)
ballplate.parts.add(ball)

selfcontact = Contact(type=ContactType.AUTOMATIC)
surf1 = ContactSurface(PartSet([1, 2]))
selfcontact.set_slave_surface(surf1)
ballplate.contacts.add(selfcontact)

spc = [34,35,51,52,68,69,85,86,102,103,119,120,136,137,153,154,170,171,187,188,204,205,221,222,238,239,255,256]
for i in range(1,19):
    spc.append(i)
for i in range(272,290):
    spc.append(i)
ballplate.boundaryconditions.create_spc(NodeSet(spc),rx=False,ry=False,rz=False)

for i in range(1,1652):
    ballplate.initialconditions.create_velocity_node(i,trans=Velocity(0, 0, -10))

solution.set_output_database(glstat=0.1, matsum=0.1, sleout=0.1)
solution.create_database_binary(dt=1)
serverpath = solution.save_file()

serveroutfile = '/'.join((serverpath,"ball_plate.k"))
downloadpath = os.path.join(os.getcwd(), "output")
if not os.path.exists(downloadpath):
    os.makedirs(downloadpath)
downloadfile = os.path.join(downloadpath,"ball_plate.k")
solution.download(serveroutfile,downloadfile)

Solve#

The following code solves this basic ball plate example. In the repository, you can get the Python file from examples/solver/ball_plate_solver.py.

import ansys.dyna.core.solver as solver

hostname = "localhost"
port = "5000"
dyna=launch_dyna(ip = hostname,port = port)            # connect to the container
dyna.push("./output/ball_plate.k")                            # push an input file
dyna.start(4)                                   # start 4 ranks of mppdyna
dyna.run("i=ball_plate.k memory=10m ncycle=20000")   # begin execution

Post processing#

The following code processes results from the solve of this basic ball plate example:

from ansys.dpf import core as dpf
import os

ds = dpf.DataSources()
data_path = os.path.join(os.getcwd(), 'd3plot')
ds.set_result_file_path(data_path, 'd3plot')

model = dpf.Model(ds)
# Extract displacements for all time steps from d3plot
D = model.results.displacement.on_all_time_freqs().eval()
D.animate()

stress = dpf.operators.result.stress()
stress.inputs.data_sources(ds)
stress.inputs.time_scoping([12])
stress.connect(25, [1])
stress.inputs.requested_location.connect("Nodal")
fields = stress.outputs.fields_container()

shell_layer_extract = dpf.operators.utility.change_shell_layers()
shell_layer_extract.inputs.fields_container.connect(fields)
print(shell_layer_extract.inputs.e_shell_layer)
shell_layer_extract.inputs.e_shell_layer.connect(0)
fields_top = shell_layer_extract.outputs.fields_container_as_fields_container()
print(fields_top)
fields_top.animate()

For more examples, see Examples in the PyDYNA documentation.

Getting started#

Installation#

Install the client#

Install in user mode#

Install in developer mode#

Install in offline mode#

Run PyDYNA server locally#

Start PyDYNA preprocessing server locally#

Run an example on the client side#

Start PyDYNA solver server locally#

Prerequisites#

Start server on Windows#

Start server on Linux(Centos7)#

Run an example on the client side#

Run PyDYNA Server in a Docker container#

Build the Docker image for the pre service#

Prerequisites#

Build the Docker container for the pre service#

Run the image as a container#

Copy files from Docker#

Build the Docker image for the solver service#

Prerequisites#

Build the Docker image#

Start the container from a docker-compose.yml file#

Copy files from Docker#

Example#

Preprocessing#

Solve#

Post processing#

Build the Docker image for the `pre` service#

Build the Docker container for the `pre` service#

Build the Docker image for the `solver` service#

Start the container from a `docker-compose.yml` file#