pyNastran

https://github.com/stevedoyle2/pynastran
Admin
pyNastran is an open-source Python library and GUI that provides an interface to various Nastran...
Tokens:301,551
Snippets:1,516
Trust Score:8
License:BSD-3-Clause
Update:1 week ago
Show doc for...
Tokens:
Raw
### Example 6: Setup - Import pyNastran and define model paths

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_overview.rst

Sets up the pyNastran package path and constructs the BDF filename for the example model 'static_solid_shell_bar.bdf'.

```python
>>> import pyNastran
>>> pkg_path = pyNastran.__path__[0]
>>> test_path = os.path.join(pkg_path, '..', 'models', 'sol_101_elements')
>>> bdf_filename = os.path.join(test_path, 'static_solid_shell_bar.bdf')
```

--------------------------------

### Example 4: Setup model path and instantiate BDF model

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_overview.rst

Sets up the path to the solid_bending model and reads the BDF file. This is the common setup for Example 4.

```python
>>> import pyNastran
>>> pkg_path = pyNastran.__path__[0]
>>> test_path = os.path.join(pkg_path, '..', 'models', 'solid_bending')
>>> bdf_filename = os.path.join(test_path, 'solid_bending.bdf')
```

```python
>>> from pyNastran.bdf.bdf import BDF
>>> model = BDF()
>>> model.read_bdf(bdf_filename, xref=True)
>>> f = open('junk.out', 'w')
```

--------------------------------

### Install dependencies and build documentation

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/README.txt

Install Graphviz and add its bin folder to the PATH, then install the requirements file and run 'make html' to build the documentation.

```bash
>>> pip install requirements_docs.txt
```

```bash
>>> make html
```

--------------------------------

### Install from source (base)

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/installation.rst

Installs pyNastran from the source directory containing the 'models' folder.

```bash
pip install .
```

--------------------------------

### Verify GUI installation

Source: https://github.com/stevedoyle2/pynastran/blob/main/dev/how_to_build_gui.txt

Run the pyNastranGUI command to verify the GUI works after installation.

```bash
pyNastranGUI
```

--------------------------------

### test_op2 example output for ISat_Dploy_Sm.op2

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/test_op2.rst

Example output from running test_op2 -c on ISat_Dploy_Sm.op2, showing debug logs and table names read from the OP2.

```console
>>> test_op2 -c ISat_Dploy_Sm.op2

OP2_FILENAME = 'isat_dploy_sm.op2'
DEBUG:     fname=op2_scalar.py             lineNo=521    set_subcases - subcases = []
DEBUG:     fname=op2_scalar.py             lineNo=521    set_subcases - subcases = []
DEBUG:     fname=op2.py                    lineNo=385    combine=True
DEBUG:     fname=op2.py                    lineNo=386    -------- reading op2 with read_mode=1 (array sizing) --------
INFO:      fname=op2_scalar.py             lineNo=1398   op2_filename = 'isat_dploy_sm.op2'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='PVT0'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='CSTM'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GPL'
DEBUG:     fname=op2_scalar.py             lineNo=2241   table_name = 'GPL'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GPDT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='EPT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='MPT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM2'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM4'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM1'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='BGPDT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='DYNAMICS'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='CASECC'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='LAMA'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='BOPHIG'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='OES1'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='OEF1'
DEBUG:     fname=op2.py                    lineNo=398    -------- reading op2 with read_mode=2 (array filling) --------
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='PVT0'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='CSTM'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GPL'
DEBUG:     fname=op2_scalar.py             lineNo=2241   table_name = 'GPL'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GPDT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='EPT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='MPT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM2'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM4'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM1'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='BGPDT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='DYNAMICS'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='CASECC'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='LAMA'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='BOPHIG'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='OES1'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='OEF1'
DEBUG:     fname=op2.py                    lineNo=534    combine_results
DEBUG:     fname=op2.py                    lineNo=406    finished reading op2
DEBUG:     fname=op2.py                    lineNo=385    combine=True
DEBUG:     fname=op2.py                    lineNo=386    -------- reading op2 with read_mode=1 (array sizing) --------
INFO:      fname=op2_scalar.py             lineNo=1398   op2_filename = 'isat_dploy_sm.op2'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='PVT0'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='CSTM'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GPL'
DEBUG:     fname=op2_scalar.py             lineNo=2241   table_name = 'GPL'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GPDT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='EPT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='MPT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM2'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM4'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='GEOM1'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='BGPDT'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='DYNAMICS'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='CASECC'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='LAMA'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='BOPHIG'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='OES1'
DEBUG:     fname=op2_scalar.py             lineNo=1589     table_name='OEF1'
DEBUG:     fname=op2.py                    lineNo=534    combine_results
DEBUG:     fname=op2.py                    lineNo=406    finished reading op2
```

--------------------------------

### Install pyNastran with GUI options

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/installation.rst

Two alternative commands to install pyNastran with GUI support using either PySide2 or PyQt5.

```bash
pip install pyNastran[gui_pyside2] -U
```

```bash
pip install pyNastran[gui_pyqt5]   -U
```

--------------------------------

### Install from source with optional GUI support

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/installation.rst

Two alternative commands to install pyNastran from source with GUI support using either PySide2 or PyQt5.

```bash
pip install .[gui_pyside2]
```

```bash
pip install .[gui_pyqt5]
```

--------------------------------

### Set up pyNastran model paths

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/manual/docs_doc.rst

Imports pyNastran and constructs the path to the example OP2 file 'plate_py.op2'.

```python
>>> import pyNastran
>>> pkg_path = pyNastran.__path__[0]
>>> test_path = os.path.join(pkg_path, '..', 'models', 'plate_py')
>>> op2_filename = os.path.join(test_path, 'plate_py.op2')
```

--------------------------------

### Output of setup code

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/quick_start/demo/bdf_demo.ipynb

Shows the expected output from the setup code, including the pyNastran file path, version, and package path.

```text
Output:
C:\NASA\m4\formats\git\pyNastran_1.5.0\pyNastran\__init__.py
1.5.0
pkg_path = C:\NASA\m4\formats\git\pyNastran_1.5.0\pyNastran

```

--------------------------------

### Install from source with pandas and hdf5 support

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/installation.rst

Installs pyNastran with pandas and hdf5 support but without GUI options.

```bash
pip install .[nogui]
```

--------------------------------

### Set up model paths for solid_bending example

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_overview.rst

Defines the path to the solid_bending.bdf example model using pyNastran's package path.

```python
>>> import pyNastran
>>> pkg_path = pyNastran.__path__[0]
>>> test_path = os.path.join(pkg_path, '..', 'models', 'solid_bending')
>>> bdf_filename = os.path.join(test_path, 'solid_bending.bdf')
```

--------------------------------

### Install pyNastran in development mode

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/building_docs.rst

Run 'python setup.py develop' to install pyNastran in development mode. Use 'setup_no_gui.py' instead if you don't want the GUI. For a regular install, use 'install' instead of 'develop'.

```console
>>> python setup.py develop
```

--------------------------------

### Install Python packages for documentation

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/building_docs.rst

Install the required Python packages for building documentation: Sphinx, alabaster, numpydoc, sphinx_rtd_theme, and ipython. Also requires GraphViz to be installed separately.

```console
pip install Sphinx
pip install alabaster
pip install numpydoc
pip install sphinx_rtd_theme
pip install ipython
```

--------------------------------

### Install from source (editable)

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/installation.rst

Installs pyNastran in editable mode so changes to the source take effect immediately.

```bash
pip install -e .
```

--------------------------------

### Setup and import pyNastran

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/quick_start/demo/bdf_demo.ipynb

Initializes the notebook environment, imports pyNastran, and prints the package path and version. Also imports BDF and read_bdf for later use.

```python
from IPython.core.display import HTML
import os
import getpass
from pathlib import Path
import pyNastran
print (pyNastran.__file__)
print (pyNastran.__version__)
pkg_path = Path(pyNastran.__path__[0])
#pkg_path = Path(r'C:\Users\sdoyle\Desktop\demo\pyNastran\pyNastran')

from pyNastran.bdf.bdf import BDF, read_bdf
from pyNastran.utils import object_attributes, object_methods
IS_WINDOWS = 'nt' in os.name

print("pkg_path = %s" % pkg_path)
```

--------------------------------

### Output of using GRID card methods to get positions

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_demo.rst

Output from the previous example showing the GRID card, comments, and positions in various coordinate systems.

```default
$*
$*  GRID CARDS
$*
GRID           1       4    -4.5    -7.5    -14.       4

c1='$*n$*  GRID CARDSn$*n'
c2=''
xyz = [ -4.5  -7.5 -14. ]
position = [ -4.5  -7.5 -14. ]
wrt5 = [  2.12132034  14.         -26.59188309]
wrt4 = [ -4.5  -7.5 -14. ]
```

--------------------------------

### Install pyNastran from release

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/installation.rst

Installs the minimum required packages for pyNastran without GUI support.

```bash
pip install pyNastran -U
```

--------------------------------

### Output of manually setting up cross-referenced attributes

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_demo.rst

Output from the previous example showing the GRID card.

```default
$*
$*  GRID CARDS
$*
GRID           1       4    -4.5    -7.5    -14.       4
```

--------------------------------

### Install GUI dependencies with pip

Source: https://github.com/stevedoyle2/pynastran/blob/main/dev/how_to_build_gui.txt

Install the required packages for the pyNastran GUI: pyqt5, vtk, imageio, and py-splash.

```bash
pip install pyqt5 vtk imageio py-splash
```

--------------------------------

### Instantiate BDF model and open output file (Example 2)

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_overview.rst

Creates a BDF object, reads the BDF file with cross-referencing enabled, and opens an output file for writing.

```python
>>> from pyNastran.bdf.bdf import BDF
>>> model = BDF()
>>> model.read_bdf(bdf_filename, xref=True)
>>> f = open('junk.out', 'w')
```

--------------------------------

### format_converter example commands

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/installed_programs.rst

Example invocations of format_converter: joining Tecplot files with slicing, converting Nastran to binary STL, Nastran to Cart3d, and STL glob to Nastran.

```console
>>> format_converter tecplot tecplot.*.plt tecplot.tecplot_joined.plt -x 0.0 -y 0.0 -z 0.0
>>> format_converter nastran fem.bdf stl fem.stl -b
>>> format_converter nastran fem.bdf cart3d fem.tri
>>> format_converter stl model.*.stl nastran fem.bdf
```

--------------------------------

### Import modules for test_bdf demo

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/quick_start/demo/test_bdf.ipynb

Imports the HTML display utility from IPython and the BDF, read_bdf, and CaseControlDeck classes from pyNastran.bdf.bdf. This is the initial setup for the demo.

```python
from IPython.display import HTML as html_print
from pyNastran.bdf.bdf import BDF, read_bdf, CaseControlDeck

```

--------------------------------

### Print read_op4 docstring with help()

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/op4_demo.rst

Use help(read_op4) to display the function's docstring, which explains parameters, return values, and usage examples.

```ipython3
help(read_op4)
```

--------------------------------

### Example 5: Get element IDs attached to node 55

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_overview.rst

Uses model.get_node_id_to_element_ids_map() to get element IDs for node 55. Does not support 0d/1d elements yet.

```python
>>> nid_to_eids_map = model.get_node_id_to_element_ids_map()
>>> eids = nid_to_eids_map[55]
```

--------------------------------

### Nastran comment example

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/how_to/bdf/bdf_model_groups.rst

Shows a standard Nastran comment line starting with '$' followed by a GRID card. Nastran ignores the comment.

```nastran
$ CG
GRID        1001         742.959    270. 89.4568
```

--------------------------------

### Generate index.rst with sphinx-quickstart

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/README.txt

Run sphinx-quickstart.exe to generate the index.rst file and the root directory.

```bash
sphinx-quickstart.exe
```

--------------------------------

### Example 7: Get element IDs by material ID (mid=1)

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_overview.rst

Uses get_property_id_to_element_ids_map() and get_material_id_to_property_ids_map() to find element IDs for material 1, then aggregates them.

```python
>>> pid_to_eids_map = model.get_property_id_to_element_ids_map()
>>> mid_to_pids_map = model.get_material_id_to_property_ids_map()
>>> pids1 = mid_to_pids_map[1]
>>> print('pids1 = %s' % pids1)
pids1 = [1, 2, 3, 4, 5]
>>> eids = []
>>> for pid in pids1:
>>>     eids += pid_to_eids_map[pid]
```

--------------------------------

### Example 6: Get element IDs by property ID (pid=1)

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_overview.rst

Uses get_property_id_to_element_ids_map() to retrieve element IDs for property ID 4 (PSHELL) and prints them.

```python
>>> pid_to_eids_map = model.get_property_id_to_element_ids_map()
>>> eids4  = pid_to_eids_map[4] # PSHELL
>>> print("eids4 = %s" % eids4)
eids4 = [6, 7, 8, 9, 10, 11]
```

--------------------------------

### Build documentation with make html

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/building_docs.rst

Navigate to the pyNastran/docs/html_docs directory and run 'make html' to build the documentation.

```console
>>> make html
```

--------------------------------

### Get element by ID using dictionary access

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/manual/bdf_developer.rst

Accesses an element from the model's elements dictionary using its integer ID. The example retrieves the CQUAD4 with element ID 1000.

```default
elem = model.elements[1000]
```

--------------------------------

### Get pyNastran and platform versions for bug report

Source: https://github.com/stevedoyle2/pynastran/blob/main/contributing.rst

Run these Python commands to capture the pyNastran version and Python platform version, which are required when submitting a bug report. The output shows example versions '1.3.3' and '3.7.7'.

```python
>>> import pyNastran
>>> pyNastran.__version__
'1.3.3'
>>> import platform
>>> platform.python_version()
'3.7.7'
```

--------------------------------

### Accessing element data without cross-referencing (xref=False)

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_demo.rst

Shows how to access raw element data when cross-referencing is disabled. The example retrieves a CQUAD4 element, gets its first node ID, then looks up the node and its coordinate system to print the transformation matrix.

```ipython3
cquad = bdf.elements[1]
print(cquad)
nid1 = cquad.nodes[0]
print("nid1 = %s" % nid1)
n1 = bdf.nodes[nid1]
cd4 = n1.cd
c4 = bdf.coords[cd4]
print("i (xref=False) = %s" % str(c4.i))
#print object_attributes(c4)
```

--------------------------------

### Install dependencies manually

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/installation.rst

Installs pyNastran without automatically installing dependencies, allowing manual dependency installation.

```bash
pip install . --no-dependencies
```

--------------------------------

### Build BDF model with elements, materials, and design responses

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/test_bdf.rst

Creates a BDF model, adds grid points, CBAR and CQUAD4 elements, a PSHELL, a PBARL, a MAT1 material, SPC1 constraints, DRESP1 responses, a DCONSTR, a DV PREL1, DESVARs, and loads, then sets up a SOL 144 trim analysis and writes the BDF file.

```ipython3
model = BDF()

# add_grid(nid, xyz, cp=0, cd=0, ps='', seid=0)
model.add_grid(1, [0., 0., 0.])
model.add_grid(2, [1., 0., 0.])
model.add_grid(3, [1., 1., 0.])
model.add_grid(4, [0., 1., 0.])

eid = 10
pid = 100
mid = 1000
# add_cbar(eid, pid, nids, x, g0, offt='GGG', pa=0, pb=0, wa=None, wb=None)
model.add_cbar(eid,   pid, [1, 2], [0., 0., 1.], None, offt='GGG')
model.add_cbar(eid+1, pid, [2, 3], [0., 0., 1.], None, offt='GGG')
model.add_cbar(eid+2, pid, [3, 4], [0., 0., 1.], None, offt='GGG')
model.add_cbar(eid+3, pid, [4, 1], [0., 0., 1.], None, offt='GGG')

eid_cquad4 = 15
pid_pshell = 101
# add_pshell(pid, mid1=None, t=None, mid2=None, twelveIt3=1.0,
#            mid3=None, tst=0.833333,
#            nsm=0.0, z1=None, z2=None, mid4=None)
model.add_pshell(pid_pshell, mid1=mid, t=0.1, mid2=mid, mid3=mid)
model.add_cquad4(eid_cquad4, pid_pshell, [1, 2, 3, 4])

dim = [3., 3., 1., 1.] # TODO: should be [1., 2., 3., 4.]
# add_pbarl(pid, mid, Type, dim, group='MSCBML0', nsm=0.0)
pbarl = model.add_pbarl(pid, mid, 'BOX', dim, nsm=0.0)
pbarl.validate()

E = 3.e7
G = None
nu = 0.3
mat = model.add_mat1(mid, E, G, nu)

spc_id = 1
nids = 1
# add_spc1(conid, components, nodes
model.add_spc1(spc_id, 123456, nids)


dresp_id = 100
label = 'resp1'
response_type = 'STRESS'
property_type = 'PSHELL'
pid = 3
atta = 9 # von mises upper surface stress
region = None
attb = None
atti = [pid_pshell]
# add_dresp1(dresp_id, label, response_type, property_type, region, atta, attb, atti)
model.add_dresp1(dresp_id, label, response_type, property_type, region, atta, attb, atti)

dresp_id += 1
atta = 17 # von mises lower surface stress
model.add_dresp1(dresp_id, label, response_type, property_type, region, atta, attb, atti)

# add_dconstr(oid, dresp_id, lid=-1e+20, uid=1e+20, lowfq=0.0, highfq=1e+20)
dconstr_id = 10000
model.add_dconstr(dconstr_id, dresp_id, lid=-35000., uid=35000.)

dresp_id += 1
dresp = model.add_dresp1(dresp_id, 'WT', 'WEIGHT', None, None, None, None, None)
dresp.validate()

oid = 1000
dvids = 1
coeffs = 1.
# add_dvprel1(oid, prop_type, pid, pname_fid, dvids, coeffs,
#             p_min=None, p_max=1e+20, c0=0.0)
model.add_dvprel1(oid, 'PSHELL', pid_pshell, 'T', dvids, coeffs)

# add_desvar(desvar_id, label, xinit, xlb=-1e+20, xub=1e+20,
#            delx=None, ddval=None)
model.add_desvar(1, 'DIM1', 0.1, xlb=1e-5)
model.add_desvar(2, 'DIM2', 0.2, xlb=1e-5)
model.add_desvar(3, 'DIM3', 0.3, xlb=1e-5)
model.add_desvar(4, 'DIM4', 0.4, xlb=1e-5)
model.add_desvar(5, 'DV5', 0.1, xlb=1e-5)

#model.add_dlink(6)

eid = 10 # TODO: remove
load_id = 1
# add_pload4(sid, eids, pressures, g1=None, g34=None,
#            cid=0, nvector=None, surf_or_line='SURF', line_load_dir='NORM')
pload4 = model.add_pload4(load_id, [eid_cquad4], [1., None, None, None],
                          comment=' load')
#print(pload4.get_stats())

eid = 10 # TODO: should be 100
scale = 'LE' # TODO: should be 100.
# add_pload1(sid, eid, load_type, scale, x1, p1, x2=None, p2=None)
model.add_pload1(load_id, eid, 'FZ', scale, 0., 1.)  # TODO: change atti to None

# add_eigrl(sid, v1=None, v2=None, nd=None, msglvl=0, maxset=None, shfscl=None,
#           norm=None, options=None, values=None)
eigrl = model.add_eigrl(42, nd=42)

model.sol = 103  # start=103
cc = CaseControlDeck([
    'DESOBJ = 102',  # DRESP1
    'DESSUB = %s' % dconstr_id,  # DCONSTR
    'SUBCASE 1',
    '  METHOD = 42',  # TODO: remove
    '  LOAD = %s' % load_id,  # TODO: remove
    '  SPC = %s' % spc_id,
    #'  TRIM = 42',  # TODO: add
    'ANALYSIS = SAERO',
])
#print(cc)
model.case_control_deck = cc
model.validate()

# rerun between each change
# 1. change SOL=103 -> SOL=144
model.sol = 144
# 2. add the trim in the case control deck
#help(model.add_trim)
mach = 0.8
q = 100.
labels = ['Z']
uxs = [2.5]
trim = model.add_trim(42, mach, q, labels, uxs, aeqr=1.0, trim_type=1)
print(trim)
# 3. add a trim card
# x. change to SOL=200
print(model.trims)
model.write_bdf('junk.bdf')
!cat junk.bdf
print('----------------------------------------------------------------------------------------------------')
```

--------------------------------

### Command line: pyNastranGUI --help output

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/gui.rst

Shows the full help output for pyNastranGUI, including usage and options.

```console
>>> pyNastranGUI --help

  Usage:
    pyNastranGUI [-f FORMAT] INPUT [-o OUTPUT]
                 [-s SHOT] [-m MAGNIFY]
                 [-g GSCRIPT] [-p PSCRIPT]
                 [-u POINTS_FNAME...] [--user_geom GEOM_FNAME...]
                 [-q] [--groups]
    pyNastranGUI [-f FORMAT] INPUT OUTPUT [-o OUTPUT]
                 [-s SHOT] [-m MAGNIFY]
                 [-g GSCRIPT] [-p PSCRIPT]
                 [-u POINTS_FNAME...] [--user_geom GEOM_FNAME...]
                 [-q] [--groups]
    pyNastranGUI [-f FORMAT] [-i INPUT] [-o OUTPUT...]
                 [-s SHOT] [-m MAGNIFY]
                 [-g GSCRIPT] [-p PSCRIPT]
                 [-u POINTS_FNAME...] [--user_geom GEOM_FNAME...]
                 [-q] [--groups]
    pyNastranGUI -h | --help
    pyNastranGUI -v | --version

  Primary Options:
    -f FORMAT, --format FORMAT  format type (avus, cart3d, lawgs, nastran, panair,
                                             plot3d, stl, surf, tetgen, ugrid, usm3d)
    -i INPUT, --input INPUT     path to input file
    -o OUTPUT, --output OUTPUT  path to output file

  Secondary Options:
    -g GSCRIPT, --geomscript        path to geometry script file (runs before load geometry)
    -p PSCRIPT, --postscript        path to post script file (runs after load geometry)
    -s SHOT, --shots SHOT           path to screenshot (only 1 for now)
    -m MAGNIFY, --magnify           how much should the resolution on a picture be magnified [default: 5]
    --groups                        enables groups
    --user_geom GEOM_FNAME          add user specified points to an alternate grid (repeatable)
    -u POINTS_FNAME, --user_points  add user specified points to an alternate grid (repeatable)

  Info:
    -q, --quiet    prints debug messages (default=True)
    -h, --help     show this help message and exit
    -v, --version  show program's version number and exit
```

--------------------------------

### Load OP2 with build_dataframe=True

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/op2_pandas_DataFrames.rst

Sets up pandas and PyNastran, runs Nastran if the OP2 file is missing, and reads the OP2 file with build_dataframe=True to create pandas DataFrames. Excludes strain energy results and skips undefined matrices.

```ipython3
import os
import pandas as pd
pd.set_option('precision', 3)

import pyNastran
pkg_path = pyNastran.__path__[0]
from pyNastran.op2.op2 import read_op2
from pyNastran.utils.nastran_utils import run_nastran

bdf_filename = os.path.join(pkg_path, '..', 'models', 'iSat', 'iSat_launch_100Hz.dat')
op2_filename = os.path.join(pkg_path, '..', 'models', 'iSat', 'iSat_launch_100Hz.op2')
if not os.path.exists(op2_filename):
    run_nastran(bdf_filename)
    assert os.path.exists(op2_filename)

isat = read_op2(op2_filename, build_dataframe=True, debug=False, skip_undefined_matrices=True,
                exclude_results='*strain_energy')
```

--------------------------------

### Install pyNastran without GUI in development mode

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/installation/building_docs.rst

Run 'python setup_no_gui.py develop' to install pyNastran without the GUI in development mode. Use 'install' instead of 'develop' if you don't intend to make code changes.

```console
>>> python setup_no_gui.py develop
```

--------------------------------

### Import PyNastran and set up model path

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/op2_pandas_multi_case.rst

Imports os, pandas, pyNastran, and read_op2, then sets the model path to the PyNastran models directory.

```ipython3
import os
import pandas as pd
import pyNastran
from pyNastran.op2.op2 import read_op2

pkg_path = pyNastran.__path__[0]
model_path = os.path.join(pkg_path, '..', 'models')
```

--------------------------------

### Using GRID card methods to get positions

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_demo.rst

Shows various GRID card methods: printing the node, accessing comments, getting the position in local and global coordinate systems, and getting the position with respect to arbitrary coordinate systems.

```ipython3
# some Grid methods
n1 = bdf_xref.nodes[1]
print(n1)

# the comment
c1 = bdf_xref.nodes[1].comment
c2 = bdf_xref.nodes[2].comment
print("c1=%r" % c1)
print("c2=%r" % c2)


# get the position of a node
# in the local cooordinate system
print("xyz = %s" % n1.xyz)

# in the global frame
print("position = %s" % n1.get_position())

# in an arbitrary frame
print("wrt5 = %s" % n1.get_position_wrt(bdf, 5))
print("wrt4 = %s" % n1.get_position_wrt(bdf, 4))
```

--------------------------------

### Launch pyNastranGUI with results file

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_demo.rst

Shows how to load both the model and results by adding the -o flag with an OP2 file.

```default
>>> pyNastranGUI -f nastran -i bdf_filename -o op2_filename
```

--------------------------------

### Load the model and run Nastran if OP2 doesn't exist

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/op2_demo_numpy2.rst

Sets up paths, runs Nastran to generate the OP2 file if missing, then reads the OP2 file and prints its stats. Requires the BWB model files and Nastran executable.

```ipython3
import os
import copy
import numpy as np
np.set_printoptions(precision=2, threshold=20, linewidth=100, suppress=True)

import pyNastran
from pyNastran.op2.op2 import read_op2
from pyNastran.utils.nastran_utils import run_nastran
pkg_path = pyNastran.__path__[0]
model_path = os.path.join(pkg_path, '..', 'models')

bdf_filename = os.path.join(model_path, 'bwb', 'bwb_saero.bdf')
op2_filename = os.path.join(model_path, 'bwb', 'bwb_saero.op2')
if not os.path.exists(op2_filename):
    keywords = ['scr=yes', 'bat=no', 'old=no']
    run_nastran(bdf_filename, nastran_cmd='nastran', keywords=keywords, run=True)
    import shutil
    op2_filename2 = os.path.join('bwb_saero.op2')
    shutil.move(op2_filename2, op2_filename)

assert os.path.exists(op2_filename), print_bad_path(op2_filename)
model = read_op2(op2_filename, build_dataframe=False, debug=False)

print(model.get_op2_stats(short=True))
```

--------------------------------

### Write F06 file with write_f06 and preview with head

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/quick_start/demo/op2_demo.ipynb

Changes to the user's Desktop directory, then writes the F06 file 'isat.f06' using op2.write_f06 with is_mag_phase=False. The shell command 'head -n 40 isat.f06' previews the first 40 lines of the generated file.

```python
import getpass
name = getpass.getuser()
desktop = os.path.join(r'C:\Users', name, 'Desktop')
try:
    os.chdir(desktop)
except:
    pass

# write the F06 with Real/Imaginary or Magnitude/Phase
# only matters for complex results
op2.write_f06('isat.f06', is_mag_phase=False)

!head -n 40 isat.f06
```

--------------------------------

### Load OP2 file with build_dataframe=True

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/quick_start/demo/op2_pandas_DataFrames.ipynb

Sets up pandas display precision, defines paths to the iSat model, runs Nastran if the OP2 file is missing, and reads the OP2 file with build_dataframe=True. Excludes strain energy results and skips undefined matrices.

```python
import os
from pathlib import Path
import pandas as pd
pd.set_option('display.precision', 3)

import pyNastran
pkg_path = pyNastran.__path__[0]
from pyNastran.op2.op2 import read_op2
from pyNastran.utils.nastran_utils import run_nastran

isat_path = Path(pkg_path) / '..' / 'models' / 'iSat'
bdf_filename = isat_path / 'iSat_launch_100Hz.dat'
op2_filename = isat_path / 'iSat_launch_100Hz.op2'
if not os.path.exists(op2_filename):
    run_nastran(bdf_filename)
    assert os.path.exists(op2_filename)

isat = read_op2(op2_filename, build_dataframe=True, debug=False, skip_undefined_matrices=True,
                exclude_results='*strain_energy')
```

--------------------------------

### Print stress keys for buckling example

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/quick_start/demo/op2_pandas_multi_case.ipynb

Prints the keys of the CQUAD4 stress result and defines two example keys for static and buckling cases.

```python
op2_results = model.op2_results
stress = op2_results.stress
stress_keys = stress.cquad4_stress.keys()
print (stress_keys)

# subcase, analysis_code, sort_method, count, isuperelmemnt_adaptivity_index, pval_step
key0 = (1, 1, 1, 0, 0, '', '')
key1 = (1, 8, 1, 0, 0, '', '')
```

--------------------------------

### Build HTML documentation with make html

Source: https://github.com/stevedoyle2/pynastran/blob/main/dev/release_process.txt

Builds the Sphinx documentation as HTML. Run from the docs directory.

```bash
make html
```

--------------------------------

### Load iSat model and launch GUI in Python

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_demo.rst

Sets the BDF filename to the iSat model and launches pyNastranGUI from Python using the ! shell command, redirecting output to junk.out.

```ipython3
bdf_filename = os.path.abspath(os.path.join(pkg_path, '..', 'models', 'iSat', 'ISat_Launch_Sm_Rgd.dat'))
#bdf_filename = os.path.abspath(os.path.join(pkg_path, '..', 'models', 'iSat', 'ISat_Dploy_Sm.dat'))
print(bdf_filename)

# look at the model
!pyNastranGUI -f nastran -i {bdf_filename} > junk.out
```

--------------------------------

### BDF group definitions with correct and incorrect examples

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/gui.rst

Defines groups in a BDF file using the $ group: syntax. Shows correct usage, an incorrect example with a semicolon in the name, and unioned groups where multiple spcs definitions are combined.

```default
Correct:
$ group: name='RLongeron MainFuseStruct Gridpoint'; nodes=167:205
$ group: name='Skin MainFuseStruc'; elements=6001:15017
$ group: name="ULFuseCanardAtch MainFuseStruct Fixed point constraints, 123"; spcs=3

Incorrect:
$ group: name="ULFuseCanardAtch MainFuseStruct Fixed point constraints; 123"; spcs=3    (semicolon in name)

Unioned Groups (spcs becomes [1,2,3] internally):
$ group: name="spcs"; spcs=1
$ group: name="ULFuseCanardAtch MainFuseStruct Fixed point constraints, all"; spcs=1
SPC1           1  123456      13
$ group: name="spcs"; spcs=2
$ group: name="ULFuseCanardAtch MainFuseStruct Fixed point constraints, 123456"; spcs=2
SPC1           2  123456      13
$ group: name="spcs"; spcs=3
$ group: name="ULFuseCanardAtch MainFuseStruct Fixed point constraints, 123"; spcs=3
SPC1           3  123         13
```

--------------------------------

### Get displacement object

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/manual/docs_doc.rst

Retrieves the displacement object for the specified subcase.

```python
>>> disp = model.displacements[isubcase]
```

--------------------------------

### Import pyNastran and set up paths

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/quick_start/demo/op4_demo.ipynb

Imports pyNastran and necessary modules, sets the package path, and reduces numpy output precision for better readability.

```python
from pathlib import Path
import pyNastran
pkg_path = Path(pyNastran.__path__[0])
#pkg_path = r'C:\Users\sdoyle\Desktop\demo\pyNastran\pyNastran'

from pyNastran.utils import print_bad_path
from pyNastran.op4.op4 import read_op4
import numpy as np
#from numpy import float32, float64, int32, int64, product

# decrease output precision
np.set_printoptions(precision=3, threshold=20)
```

--------------------------------

### Import packages for numpy-style OP2 processing

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/op2_demo_numpy1.rst

Sets up the environment by importing os, copy, numpy, and pyNastran modules. Configures numpy print options and defines the model path. This is the required setup before loading an OP2 model.

```ipython3
import os
import copy
import numpy as np
np.set_printoptions(precision=2, threshold=20, suppress=True, linewidth=100)

import pyNastran
pkg_path = pyNastran.__path__[0]
model_path = os.path.join(pkg_path, '..', 'models')

from pyNastran.utils import print_bad_path
from pyNastran.op2.op2 import read_op2
from pyNastran.utils import object_methods, object_attributes
np.set_printoptions(precision=3, threshold=20, edgeitems=10)
```

--------------------------------

### Output of accessing cross-referenced element data

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_demo.rst

Output from the previous example showing the transformation matrix.

```default
i (xref=True) = [1. 0. 0.]
```

--------------------------------

### Build from scratch with pyinstaller

Source: https://github.com/stevedoyle2/pynastran/blob/main/dev/how_to_build_gui.txt

Build the GUI from scratch using pyinstaller with debug options and specifying distpath and workpath.

```bash
pyinstaller --log-level DEBUG --debug all --distpath distpath --workpath workpath --onedir --name pyNastranGUI ..\pyNastran\gui\gui.py
```

--------------------------------

### Read OP2 file and set pandas options

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/op2_pandas_unstack.rst

Imports pyNastran and pandas, sets precision to 2, and reads the iSat_launch_100Hz.op2 file with build_dataframe=True. The read_op2 call also skips undefined matrices.

```ipython3
import os
import pyNastran
pkg_path = pyNastran.__path__[0]
from pyNastran.op2.op2 import read_op2
import pandas as pd
pd.set_option('precision', 2)

op2_filename = os.path.join(pkg_path, '..', 'models', 'iSat', 'iSat_launch_100Hz.op2')
from pyNastran.op2.op2 import read_op2
isat = read_op2(op2_filename, build_dataframe=True, debug=False, skip_undefined_matrices=True)
```

--------------------------------

### Debug output from test_bdf

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/test_bdf.rst

Debug output showing that the BDF model is being written and the test_bdf function is starting.

```default
debug = False
bdf_model = junk.bdf
```

--------------------------------

### Instantiate OP2 model and read OP2 file

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/manual/docs_doc.rst

Creates an OP2 object and reads the OP2 file, then prints model statistics. The model is used for subsequent displacement analysis.

```python
>>> from pyNastran.op2.op2 import OP2
>>> model = OP2()
>>> model.read_op2(op2_filename)
>>> print(model.get_op2_stats())
```

--------------------------------

### Get eigenvalue for mode 5

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/manual/docs_doc.rst

Prints the eigenvalue corresponding to mode 5. The output shows the value 0.000162124633789.

```python
>>> print('eigr5 = %s' % eigenvector.eigrs[imode5])
```

```text
eigr5 = 0.000162124633789
```

--------------------------------

### Skip cards header flag

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/how_to/bdf/bdf_headers.rst

Deletes specified cards from the file. This example removes CBUSH and PBUSH cards.

```text
$ pyNastran: skip_cards = CBUSH, PBUSH
```

--------------------------------

### Output of accessing element data without cross-referencing

Source: https://github.com/stevedoyle2/pynastran/blob/main/docs/html_docs/quick_start/bdf_demo.rst

Output from the previous example showing the CQUAD4 card and the transformation matrix.

```default
$*
$*  ELEMENT CARDS
$*
CQUAD4         1       1       1       2       4       3

nid1 = 1
i (xref=False) = [1. 0. 0.]
```
Tokens:
Raw