Target Audience¶

pyNastran target audience are users of Nastran and therefore are expected to be familiar with the software. This has greatly reduced the necessity of documenting every variable exhaustively as users can easily reference existing Nastran documentation. The BDF file has roughly 700 cards availble to a user with 238 being currently supported by pyNastran. The majority of the cards, defined as separate Python classes, are not documented. However, the Quick Reference Guide (QRG) defines each input to the card. A user with the QRG should have little effort in understanding what the various objects do. However, for convenience, it’s still good to document variables.

pyNastran target audience largely uses MATLAB, a matrix based programming language, and typically has little experience with general programming. There are also users that know Python, but have never used a class or a dictionary, which makes an API seems complicated.

Introduction¶

This is meant as a tutorial on how to use the pyNastran pyNastran.bdf.bdf.BDF class

The head/tail/file_slice methods can be found at:

https://github.com/SteveDoyle2/pyNastran/blob/v0.7/docs_sphinx/manual/py_docs/bdf_doc.py

These examples can be found at:

https://github.com/SteveDoyle2/pyNastran/blob/v0.7/docs_sphinx/manual/py_docs/bdf_doc.py

Example 1: Read/Write¶

this example will demonstate:

• reading the BDF
• getting some basic information
• writing the BDF

our model

>>> 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')

instantiate the model

>>> from pyNastran.bdf.bdf import BDF
>>> model = BDF()
>>> model.read_bdf(bdf_filename)

print information about the model

>>> print(model.get_bdf_stats())
---BDF Statistics---
SOL 101

bdf.loads[1]
  FORCE:   23

bdf.loads[2]
  LOAD:    1

bdf.params
  PARAM    : 2

bdf.nodes
  GRID     : 72

bdf.elements
  CTETRA   : 186

bdf.properties
  PSOLID   : 1

bdf.materials
  MAT1     : 1

bdf.coords
  CORD2R   : ???

write the file

>>> bdf_filename_out = os.path.join(test_path, 'solid_bending_out.bdf')
>>> model.write_bdf(bdf_filename_out)

looking at the output

>>> print(file_slice(bdf_filename_out, 94, 100))
GRID          71         .500008 1.61116      3.
GRID          72         .500015 1.00001      3.
$ELEMENTS_WITH_PROPERTIES
PSOLID         1       1
CTETRA         1       1       8      13      67      33
CTETRA         2       1       8       7      62      59

write the file with large field format; double precision

>>> bdf_filename_out2 = os.path.join(test_path, 'solid_bending_out2.bdf')
>>> model.write_bdf(bdf_filename_out2, size=16, is_double=False)
>>> print(file_slice(bdf_filename_out2, 166, 175))
GRID*                 71                         .500008         1.61116
*                     3.
GRID*                 72                         .500015         1.00001
*                     3.
$ELEMENTS_WITH_PROPERTIES
PSOLID         1       1
CTETRA         1       1       8      13      67      33
CTETRA         2       1       8       7      62      59
CTETRA         3       1       8      45      58      66

write the file with large field format; double precision

>>> bdf_filename_out3 = os.path.join(test_path, 'solid_bending_out3.bdf')
>>> model.write_bdf(bdf_filename_out3, size=16, is_double=True)
>>> print(file_slice(bdf_filename_out3, 166, 175))
GRID*                 71                5.0000800000D-011.6111600000D+00
*       3.0000000000D+00
GRID*                 72                5.0001500000D-011.0000100000D+00
*       3.0000000000D+00
$ELEMENTS_WITH_PROPERTIES
PSOLID         1       1
CTETRA         1       1       8      13      67      33
CTETRA         2       1       8       7      62      59
CTETRA         3       1       8      45      58      66

Example 2: Printing Nodes¶

this example will demonstate:

• writing cards

our model

>>> 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')

instantiate the model

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

>>> for nid,node in sorted(model.nodes.items()):
>>>     f.write(node.write_card(size=8, is_double=False))

>>> if model.gridSet:
>>>     f.write(model.gridSet.write_card(size=8, is_double=False))

>>> if model.spoints:
>>>     f.write(model.spoints.write_card(size=8, is_double=False))

>>> for cid,coord in sorted(model.coords.items()):
>>>     if cid != 0:  # if CID=0 is the global frame, skip it
>>>         f.write(coord)

>>> model._write_nodes(f)
>>> model._write_coords(f)

Example 3: Printing Elements/Properties¶

Print the Element ID and associated Node and Property to an Output File

note this skips rigidElements

this example will demonstate:

• using the BDF class to write cards/properties

our model

>>> 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')

instantiate the model

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

>>> for eid, element in sorted(model.elements.items()):
>>>     f.write(element.write_card(size=8, is_double=False))
>>> for pid, prop in sorted(model.properties.items()):
>>>     f.write(prop.write_card(size=8, is_double=False))

>>> model._write_elements_properties(f)

>>> model._write_elements(f)
>>> model._write_properties(f)

Example 4: Get Element ID & Type¶

Print the Element ID and its type(e.g. CQUAD4, CTRIA3, etc.) to a file

note this skips rigidElements

this example will demonstate:

• accessing element type information

our model

>>> 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')

instantiate the model

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

>>> for eid,element in sorted(model.elements.items()):
>>>     msg = 'eid=%s type=%s\n' %(eid, element.type)
>>> f.write(msg)

Example 5: Get Elements by Node ID¶

this example will demonstate:

• getting the list of elements that share a certain node

our model

>>> 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')

instantiate the model

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

given a Node, get the Elements Attached to that Node

assume node 55

doesnt support 0d/1d elements yet

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

convert to elements instead of element IDs

>>> elements = []
>>> for eid in eids:
>>>     elements.append(model.Element(eid))
>>> print("eids = %s" % eids)
>>> print("elements =\n %s" % elements)

Example 6: Get Elements by Property ID¶

this example will demonstate:

• getting a list of elements that have a certain property

our model

>>> 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')

instantiate the model

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

Creating a List of Elements based on a Property ID

assume pid=1

>>> 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]

convert to elements instead of element IDs

>>> elements4 = []
>>> for eid in eids4:
>>>     elements4.append(model.Element(eid))

just to verify

>>> elem = model.elements[eids4[0]]
>>> print(elem.pid)
PSHELL         4       1     .25       1               1

Example 7: Get Elements by Material ID¶

this example will demonstate:

• getting a list of elements that have a certain material

our model

>>> 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')

instantiate the model

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

assume you want the eids for material 10

>>> 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]

convert to elements instead of element IDs

>>> elements = []
>>> for eid in eids:
>>>     element = model.Element(eid)
>>>     elements.append(element)
>>>     print(str(element).rstrip())

CBAR          13       1      15      19      0.      1.      0.
$ Direct Text Input for Bulk Data
$ Pset: "shell" will be imported as: "pshell.1"
CHEXA          1       2       2       3       4       1       8       5
               6       7
CPENTA         2       2       6       8       5      10      11       9
CPENTA         3       2       6       7       8      10      12      11
CTETRA         4       2      10      11       9      13
CTETRA         5       2      10      12      11      13
CROD          14       3      16      20
CROD          15       3      17      21
CQUAD4         6       4       4       1      14      15
CQUAD4         7       4       3       2      17      16
CTRIA3         8       4       4       3      16
CTRIA3         9       4      16      15       4
CTRIA3        10       4       1       2      17
CTRIA3        11       4      17      14       1
$
CBEAM         12       5      14      18      0.      1.      0.     GGG

Introduction¶

This is meant as a tutorial on how to use the pyNastran pyNastran.op2.op2.OP2 class

This page runs through examples relating to the vectorized OP2. The vectorized OP2 is preferred as it uses about 20% of the memory as the non-vectorized version of the OP2. It’s slower to parse as it has to do two passes, but calculations will be much faster.

Note that a static model is a SOL 101 or SOL 144. A dynamic/”transient” solution is any transient/modal/load step/frequency based solution (e.g. 103, 109, 145).

The head/tail/file_slice methods can be found at:

https://github.com/SteveDoyle2/pyNastran/blob/v0.7/docs_sphinx/manual/py_docs/bdf_doc.py

These examples can be found at:

https://github.com/SteveDoyle2/pyNastran/blob/v0.7/docs_sphinx/manual/py_docs/op2_doc.py

Example 1: Read Write¶

This example will demonstate:

• reading the OP2
• getting some basic information
• writing the F06

our model

>>> import pyNastran
>>> pkg_path = pyNastran.__path__[0]
>>> test_path = os.path.join(pkg_path, '..', 'models', 'solid_bending')
>>> op2_filename = os.path.join(test_path, 'solid_bending.op2')
>>> f06_filename = os.path.join(test_path, 'solid_bending_out.f06')

instantiate the model

>>> from pyNastran.op2.op2 import OP2
>>> model = OP2()
>>> model.read_op2(op2_filename, vectorized=True)
>>> print(model.get_op2_stats())
op2.displacements[1]
  type=RealDisplacementArray nnodes=72
  data: [t1, t2, t3, r1, r2, r3] shape=[1, 72, 6] dtype=float32
  gridTypes
  lsdvmns = [1]

op2.spc_forces[1]
  type=RealSPCForcesArray nnodes=72
  data: [t1, t2, t3, r1, r2, r3] shape=[1, 72, 6] dtype=float32
  gridTypes
  lsdvmns = [1]

op2.ctetra_stress[1]
  type=RealSolidStressArray nelements=186 nnodes=930
  nodes_per_element=5 (including centroid)
  eType, cid
  data: [1, nnodes, 10] where 10=[oxx, oyy, ozz, txy, tyz, txz, o1, o2, o3, von_mises]
  data.shape = (1, 930, 10)
  element types: CTETRA
  lsdvmns = [1]
>>> model.write_f06(f06_filename)
F06:
 RealDisplacementArray SUBCASE=1
 RealSPCForcesArray    SUBCASE=1
 RealSolidStressArray  SUBCASE=1 - CTETRA
>>> print(tail(f06_filename, 21))
0       186           0GRID CS  4 GP
0                CENTER  X   9.658666E+02  XY  -2.978357E+01   A   2.559537E+04  LX-0.02 0.20 0.98  -1.094517E+04    2.288671E+04
                         Y   7.329372E+03  YZ   5.895411E+02   B  -7.168877E+01  LY-1.00-0.03-0.01
                         Z   2.454026E+04  ZX  -5.050599E+03   C   7.311813E+03  LZ 0.03-0.98 0.20
0                     8  X   9.658666E+02  XY  -2.978357E+01   A   2.559537E+04  LX-0.02 0.20 0.98  -1.094517E+04    2.288671E+04
                         Y   7.329372E+03  YZ   5.895411E+02   B  -7.168877E+01  LY-1.00-0.03-0.01
                         Z   2.454026E+04  ZX  -5.050599E+03   C   7.311813E+03  LZ 0.03-0.98 0.20
0                    62  X   9.658666E+02  XY  -2.978357E+01   A   2.559537E+04  LX-0.02 0.20 0.98  -1.094517E+04    2.288671E+04
                         Y   7.329372E+03  YZ   5.895411E+02   B  -7.168877E+01  LY-1.00-0.03-0.01
                         Z   2.454026E+04  ZX  -5.050599E+03   C   7.311813E+03  LZ 0.03-0.98 0.20
0                     4  X   9.658666E+02  XY  -2.978357E+01   A   2.559537E+04  LX-0.02 0.20 0.98  -1.094517E+04    2.288671E+04
                         Y   7.329372E+03  YZ   5.895411E+02   B  -7.168877E+01  LY-1.00-0.03-0.01
                         Z   2.454026E+04  ZX  -5.050599E+03   C   7.311813E+03  LZ 0.03-0.98 0.20
0                    58  X   9.658666E+02  XY  -2.978357E+01   A   2.559537E+04  LX-0.02 0.20 0.98  -1.094517E+04    2.288671E+04
                         Y   7.329372E+03  YZ   5.895411E+02   B  -7.168877E+01  LY-1.00-0.03-0.01
                         Z   2.454026E+04  ZX  -5.050599E+03   C   7.311813E+03  LZ 0.03-0.98 0.20
1    MSC.NASTRAN JOB CREATED ON 28-JAN-12 AT 12:52:32                       JANUARY  28, 2012  pyNastran v0.7.1       PAGE     3

1                                        * * * END OF JOB * * *

Example 2: Displacement (static)¶

This example will demonstate:

• calculating total deflection of the nodes for a static case for a vectorized OP2
• calculate von mises stress and max shear

our model

>>> import pyNastran
>>> pkg_path = pyNastran.__path__[0]
>>> test_path = os.path.join(pkg_path, '..', 'models', 'solid_bending')
>>> op2_filename = os.path.join(test_path, 'solid_bending.op2')
>>> out_filename = os.path.join(test_path, 'solid_bending.out')

instantiate the model

>>> from pyNastran.op2.op2 import OP2
>>> model = OP2()
>>> model.read_op2(op2_filename, vectorized=True)
>>> print(model.get_op2_stats())

we’re analyzing a static problem, so itime=0

we’re also assuming subcase 1

>>> itime = 0
>>> isubcase = 1

get the displacement object

>>> disp = model.displacements[isubcase]

displacement is an array

# data = [tx, ty, tz, rx, ry, rz]
# for some itime
# all the nodes -> :
# get [tx, ty, tz] -> :3
>>> txyz = disp.data[itime, :, :3]

calculate the total deflection of the vector

>>> from numpy.linalg import norm
>>> total_xyz = norm(txyz, axis=1)

since norm’s axis parameter can be tricky, we’ll double check the length

>>> nnodes = disp.data.shape[1]
>>> assert len(total_xyz) == nnodes

we could also have found nnodes by using the attribute.

It has an underscore because the object is also used for elements.

>>> nnodes2 = disp._nnodes
>>> assert nnodes == nnodes2
>>> assert nnodes == 72

additionally we know we have 72 nodes from the shape:

op2.displacements[1]
  type=RealDisplacementArray nnodes=72
  data: [t1, t2, t3, r1, r2, r3] shape=[1, 72, 6] dtype=float32
  gridTypes
  lsdvmns = [1]

now we’ll loop over the nodes and print the total deflection

>>> msg = 'nid, gridtype, tx, ty, tz, txyz'
>>> print(msg)
>>> for (nid, grid_type), txyz, total_xyzi in zip(disp.node_gridtype, txyz, total_xyz):
>>>     msg = '%s, %s, %s, %s, %s, %s' % (nid, grid_type, txyz[0], txyz[1], txyz[2], total_xyzi)
>>>     print(msg)

nid, gridtype, tx, ty, tz, txyz
1, 1, 0.00764469, 4.01389e-05, 0.000111137, 0.00764561
2, 1, 0.00762899, 5.29171e-05, 0.000142154, 0.0076305
3, 1, 0.00944763, 6.38675e-05, 7.66179e-05, 0.00944816
4, 1, 0.00427092, 2.62277e-05, 7.27848e-05, 0.00427162
5, 1, 0.00152884, 1.71054e-05, -3.47525e-06, 0.00152894
...

Example 3: Eigenvector (transient)¶

This example will demonstate:

• calculate von mises stress and max shear for solid elements for a static case for a vectorized OP2

our model

>>> import pyNastran
>>> pkg_path = pyNastran.__path__[0]
>>> test_path = os.path.join(pkg_path, '..', 'models', 'solid_bending')
>>> op2_filename = os.path.join(test_path, 'solid_bending.op2')
>>> out_filename = os.path.join(test_path, 'solid_bending.out')

instantiate the model

>>> from pyNastran.op2.op2 import OP2
>>> model = OP2()
>>> model.read_op2(op2_filename, vectorized=True)
>>> print(model.get_op2_stats())

op2.ctetra_stress[1]
  type=RealSolidStressArray nelements=186 nnodes=930
  nodes_per_element=5 (including centroid)
  eType, cid
  data: [1, nnodes, 10] where 10=[oxx, oyy, ozz, txy, tyz, txz, o1, o2, o3, von_mises]
  data.shape = (1, 930, 10)
  element types: CTETRA
  lsdvmns = [1]

we’re analyzing a static problem, so itime=0

we’re also assuming subcase 1

>>> itime = 0
>>> isubcase = 1

get the stress object (there is also cpenta_stress and chexa_stress as well as ctetra_strain/cpenta_strain/chexa_strain)

>>> stress = model.ctetra_stress[isubcase]

The stress/strain data can often be von_mises/max_shear (same for fiber_distance/curvature), so check!

 #data = [oxx, oyy, ozz, txy, tyz, txz, o1, o2, o3, von_mises]
>>> o1 = stress.data[itime, :, 6]
>>> o3 = stress.data[itime, :, 8]
>>> if stress.is_von_mises():
>>>     max_shear = (o1 - o3) / 2.
>>>     von_mises = stress.data[itime, :, 9]
>>> else:
>>>     from numpy import sqrt
>>>     o2 = data[itime, :, 8]
>>>     von_mises = sqrt(0.5*((o1-o2)**2 + (o2-o3)**2, (o3-o1)**2))
>>>     max_shear = stress.data[itime, :, 9]
>>> for (eid, node), vm, ms in zip(stress.element_node, von_mises, max_shear):
>>>     print(eid, 'CEN/4' if node == 0 else node, vm, ms)

1 CEN/4 15900.2 2957.35
1 8     15900.2 2957.35
1 13    15900.2 2957.35
1 67    15900.2 2957.35
1 33    15900.2 2957.35
2 CEN/4 16272.3 6326.18
2 8     16272.3 6326.18
2 7     16272.3 6326.18
2 62    16272.3 6326.18
2 59    16272.3 6326.18

Note that because element_node is an integer array, the centroid is 0. We renamed it to CEN/4 when we wrote it

Example 4: Solid Stress (static)¶

This example will demonstate:

• calculating total deflection of the nodes for a dynamic case for a vectorized OP2

our model

>>> 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')

ut_filename = os.path.join(test_path, ‘solid_bending.out’)

instantiate the model

>>> from pyNastran.op2.op2 import OP2
>>> model = OP2()
>>> model.read_op2(op2_filename, vectorized=True)
>>> print(model.get_op2_stats())

op2.eigenvectors[1]
  type=RealEigenvectorArray ntimes=10 nnodes=231
  data: [t1, t2, t3, r1, r2, r3] shape=[10, 231, 6] dtype=float32
  gridTypes
  modes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
eigrs = [-0.00037413835525512695, -0.00022113323211669922, -0.0001882314682006836, -0.00010025501251220703, 0.0001621246337890625, 0.00
07478296756744385, 1583362560.0, 2217974016.0, 10409966592.0, 11627085824.0]
mode_cycles = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> isubcase = 1
>>> eigenvector = model.eigenvectors[isubcase]

“time/mode/frequency are stored by id, so to get mode 5:

>>> modes = eigenvector._times  # it may not be "time" so we don't use the name "time"
>>> from numpy import where
>>> imode5 = where(modes == 5)[0]
>>> txyz = eigenvector.data[imode5, :, :3]

calculate the total deflection of the vector

>>> from numpy.linalg import norm
>>> total_xyz = norm(txyz, axis=1)

get the eigenvalue

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

Example 5: Isotropic Plate Stress (static)¶

This example will demonstate:

• print the fiber distance and the max principal stress for a static case for a vectorized OP2

our model

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

instantiate the model

>>> from pyNastran.op2.op2 import OP2
>>> model = OP2()
>>> model.read_op2(op2_filename, vectorized=True)
>>> print(model.get_op2_stats())

op2.cquad4_stress[1]
  type=RealPlateStressArray nelements=2 nnodes_per_element=5 nlayers=2 ntotal=20
  data: [1, ntotal, 8] where 8=[fiber_distance, oxx, oyy, txy, angle, omax, omin, von_mises]
  data.shape=(1L, 20L, 8L)
  element types: CQUAD4
  lsdvmns = [1]
>>> isubcase = 1
>>> itime = 0 # this is a static case
>>> stress = model.cquad4_stress[isubcase]
>>> assert stress.nnodes == 5, 'this is a bilinear quad'

write the data

#[fiber_dist, oxx, oyy, txy, angle, majorP, minorP, ovm]
>>> eids = stress.element_node[:, 0]
>>> nids = stress.element_node[:, 1]
>>> if stress.is_fiber_distance():
>>>     fiber_dist = stress.data[itime, :, 0]
>>> else:
>>>     raise RuntimeError('found fiber curvature; expected fiber distance')
>>> maxp = stress.data[itime, :, 5]
>>> for (eid, nid, fdi, maxpi) in zip(eids, nids, fiber_dist, maxp):
>>>     print(eid, 'CEN/4' if nid == 0 else nid, fdi, maxpi)

6 CEN/4 -0.125 8022.26
6 CEN/4  0.125 12015.9
6 4     -0.125 7580.84
6 4      0.125 11872.9
6 1     -0.125 8463.42
6 1      0.125 12158.9
6 14    -0.125 8463.69
6 14     0.125 12158.9
6 15    -0.125 7581.17
6 15     0.125 11872.9
7 CEN/4 -0.125 10016.3
7 CEN/4  0.125 10019.5
7 3     -0.125 10307.1
7 3      0.125 10311.0
7 2     -0.125 9725.54
7 2      0.125 9727.9
7 17    -0.125 9725.54
7 17     0.125 9728.06
7 16    -0.125 10307.1
7 16     0.125 10311.1

note we have 2 layers (upper and lower surface) for any PSHELL-based elements

Example 6: Composite Plate Stress (static)¶

This example will demonstate:

• print the fiber distance and the max principal stress for a static case for a vectorized OP2

our model

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

instantiate the model

>>> from pyNastran.op2.op2 import OP2
>>> model = OP2()
>>> model.read_op2(op2_filename, vectorized=True)
>>> print(model.get_op2_stats())
op2.ctria3_composite_stress[1]
  type=RealCompositePlateStressArray nelements=4 ntotal=18
  data: [1, ntotal, 9] where 9=[o11, o22, t12, t1z, t2z, angle, major, minor, max_shear]
  data.shape = (1, 18, 9)
  element types: CTRIA3
  lsdvmns = [1]
>>> isubcase = 1
>>> itime = 0 # this is a static case
>>> stress = model.ctria3_composite_stress[isubcase]

In the previous example, we had an option for a variable number of nodes for the CQUAD4s (1/5), but only nnodes=1 for the CTRIA3s.

In this example, we have 4 layers on one element and 5 on another, but they’re all at the centroid.

#[o11, o22, t12, t1z, t2z, angle, major, minor, ovm]
   >>> eids = stress.element_layer[:, 0]
   >>> layers = stress.element_layer[:, 1]
   >>> maxp = stress.data[itime, :, 6]
   >>> if stress.is_fiber_distance():
   >>>     fiber_dist = stress.data[itime, :, 0]
   >>> else:
   >>>     raise RuntimeError('found fiber curvature; expected fiber distance')
   >>> maxp = stress.data[itime, :, 5]
   >>> for (eid, layer, maxpi) in zip(eids, layers, maxp):
   >>>     print(eid, 'CEN/4', layer, maxpi)

   7  CEN/4 1  89.3406
   7  CEN/4 2  89.3745
   7  CEN/4 3  89.4313
   7  CEN/4 4  89.5115
   8  CEN/4 1 -85.6691
   8  CEN/4 2 -85.6121
   8  CEN/4 3 -85.5193
   8  CEN/4 4 -85.3937
   8  CEN/4 5 -85.2394
   9  CEN/4 1  86.3663
   9  CEN/4 2  86.6389
   9  CEN/4 3  87.0977
   9  CEN/4 4  87.7489
   10 CEN/4 1 -87.6962
   10 CEN/4 2 -87.4949
   10 CEN/4 3 -87.1543
   10 CEN/4 4 -86.6662
   10 CEN/4 5 -86.0192

bdf Module¶

bdf_Methods Module¶

This file contains additional methods that do not directly relate to the reading/writing/accessing of BDF data. Such methods include:

• Mass

  get the mass of the model

• Mass Poperties

  get the mass & moment of inertia of the model

• sumMoments / sum_moments

  find the net force/moment on the model

• sumForces / sum_forces

  find the net force on the model

• resolve_grids

  change all nodes to a specific coordinate system

• unresolve_grids

  puts all nodes back to original coordinate system

class pyNastran.bdf.bdf_Methods.BDFMethods[source]¶

Bases: pyNastran.bdf.deprecated.BDFMethodsDeprecated

_BDFMethods__gravity_load(loadcase_id)¶

Todo

1. resolve the load case
2. grab all of the GRAV cards and combine them into one GRAV vector
3. run mass_properties to get the mass
4. multiply by the gravity vector

_apply_mass_symmetry(sym_axis, scale, mass, cg, I)[source]¶

Scales the mass & moement of inertia based on the symmetry axes and the PARAM WTMASS card

_mass_properties_mp(num_cpus, elements, masses, nelements, reference_point=None)[source]¶

Caclulates mass properties in the global system about the reference point.

Parameters:	self – the BDF object num_cpus – the number of CPUs to use; 2 < num_cpus < 20 reference_point – an array that defines the origin of the frame. default = <0,0,0>.
Returns mass:	the mass of the model
Returns cg:	the cg of the model as an array.
Returns I:	moment of inertia array([Ixx, Iyy, Izz, Ixy, Ixz, Iyz])

See also

self.mass_properties

_mass_properties_sp(elements, masses, reference_point)[source]¶

mass_properties(element_ids=None, reference_point=None, sym_axis=None, num_cpus=1, scale=None)[source]¶

Caclulates mass properties in the global system about the reference point.

Parameters:	self – the BDF object element_ids – an array of element ids reference_point – an array that defines the origin of the frame. default = <0,0,0>. sym_axis – the axis to which the model is symmetric. If AERO cards are used, this can be left blank allowed_values = ‘x’, ‘y’, ‘z’, ‘xy’, ‘yz’, ‘xz’, ‘xyz’ scale – the WTMASS scaling value default=None -> PARAM, WTMASS is used float > 0.0
Returns mass:	the mass of the model
Returns cg:	the cg of the model as an array.
Returns I:	moment of inertia array([Ixx, Iyy, Izz, Ixy, Ixz, Iyz])

I = mass * centroid * centroid

\[I_{xx} = m (dy^2 + dz^2)\]

\[I_{yz} = -m * dy * dz\]

where:

\[dx = x_{element} - x_{ref}\]

See also

http://en.wikipedia.org/wiki/Moment_of_inertia#Moment_of_inertia_tensor

Note

This doesn’t use the mass matrix formulation like Nastran. It assumes m*r^2 is the dominant term. If you’re trying to get the mass of a single element, it will be wrong, but for real models will be correct.

resolve_grids(cid=0)[source]¶

Puts all nodes in a common coordinate system (mainly for cid testing)

Parameters:	self – the object pointer cid – the cid to resolve the nodes to (default=0)

Note

loses association with previous coordinate systems so to go back requires another fem

sum_forces_moments(p0, loadcase_id, include_grav=False)[source]¶

Sums applied forces & moments about a reference point p0 for all load cases. Considers:

• FORCE, FORCE1, FORCE2
• MOMENT, MOMENT1, MOMENT2
• PLOAD, PLOAD2, PLOAD4
• LOAD

Parameters:	p0 (NUMPY.NDARRAY shape=(3,) or integer (node ID)) – the reference point loadcase_id (integer) – the LOAD=ID to analyze include_grav (bool) – includes gravity in the summation (not supported)
Returns Forces:	the forces
Returns Moments:
	the moments

Warning

not full validated

Todo

It’s super slow for cid != 0. We can speed this up a lot if we calculate the normal, area, centroid based on precomputed node locations.

Pressure acts in the normal direction per model/real/loads.bdf and loads.f06

sum_forces_moments_elements(p0, loadcase_id, eids, nids, include_grav=False)[source]¶

Sum the forces/moments based on a list of nodes and elements.

Parameters:	eids – the list of elements to include (e.g. the loads due to a PLOAD4) nids – the list of nodes to include (e.g. the loads due to a FORCE card) p0 – the point to sum moments about type = int sum moments about the specified grid point type = (3, ) ndarray/list (e.g. [10., 20., 30]): the x, y, z location in the global frame

Nodal Types : FORCE, FORCE1, FORCE2,

MOMENT, MOMENT1, MOMENT2, PLOAD

Element Types: PLOAD1, PLOAD2, PLOAD4, GRAV

If you have a CQUAD4 (eid=3) with a PLOAD4 (eid=3) and a FORCE card (nid=5) acting on it, you can incldue the PLOAD4, but not the FORCE card by using:

For just pressure:

eids = [3]
nids = []

For just force:

eids = []
nids = [5]

or both:

eids = [3]
nids = [5]

Note

If you split the model into sections and sum the loads on each section, you may not get the same result as if you summed the loads on the total model. This is due to the fact that nodal loads on the boundary are double/triple/etc. counted depending on how many breaks you have.

Todo

not done...

unresolve_grids(model_old)[source]¶

Puts all nodes back to original coordinate system.

Parameters:	self – the object pointer model_old – the old model that hasnt lost it’s connection to the node cids

Warning

hasnt been tested well...

pyNastran.bdf.bdf_Methods._mass_properties_mass_mp_func(element)[source]¶

helper method for mass properties multiprocessing

bdf_replacer Module¶

caseControlDeck Module¶

CaseControlDeck parsing and extraction class

class pyNastran.bdf.caseControlDeck.CaseControlDeck(lines, log=None)[source]¶

Bases: object

CaseControlDeck parsing and extraction class

Parameters:	self – the CaseControlDeck object lines – list of lines that represent the case control deck ending with BEGIN BULK log – a :mod: logging object

_add_parameter_to_subcase(key, value, options, param_type, isubcase)[source]¶

Internal method

self: the CaseControlDeck object

_parse_data_from_user(param)[source]¶

Parses a case control line

Parameters:	self – the CaseControlDeck object param – the variable to add

_parse_entry(lines)[source]¶

Internal method for parsing a card of the case control deck

Parses a single case control deck card into 4 sections

1. paramName - obvious
2. Value - still kind of obvious
3. options - rarely used data
4. paramType - STRESS-type, SUBCASE-type, PARAM-type, SET-type, BEGIN_BULK-type

It’s easier with examples:

paramType = SUBCASE-type

SUBCASE 1 -> paramName=SUBCASE value=1 options=[]

paramType = STRESS-type

STRESS = ALL -> paramName=STRESS value=ALL options=[] STRAIN(PLOT) = 5 -> paramName=STRAIN value=5 options=[PLOT] TITLE = stuff -> paramName=TITLE value=stuff options=[]

paramType = SET-type

SET 1 = 10,20,30 -> paramName=SET value=[10,20,30] options = 1

paramType = BEGIN_BULK-type

BEGIN BULK -> paramName=BEGIN value=BULK options = []

paramType = CSV-type

PARAM,FIXEDB,-1 -> paramName=PARAM value=FIXEDB options = [-1]

The paramType is the “macro” form of the data (similar to integer, float, string). The value is generally whats on the RHS of the equals sign (assuming it’s there). Options are modifiers on the data. Form things like the PARAM card or the SET card they arent as clear, but the paramType lets the program know how to format it when writing it out.

Parameters:	self – the CaseControlDeck object lines – list of lines
Returns:	paramName see brief
Returns:	value see brief
Returns:	options see brief
Returns:	paramType see brief

_read(lines)[source]¶

Reads the case control deck

Note

supports comment lines

Warning

doesnt check for 72 character width lines, but will follow that when it’s written out

add_parameter_to_global_subcase(param)[source]¶

Takes in a single-lined string and adds it to the global Subcase.

Parameters:	self – the CaseControlDeck object param – the variable to add

Note

dont worry about overbounding the line

>>> bdf = BDF()
>>> bdf.read_bdf(bdf_filename)
>>> bdf.case_control.add_parameter_to_global_subcase('DISP=ALL')
>>> print(bdf.case_control)
TITLE = DUMMY LINE
DISP = ALL

add_parameter_to_local_subcase(isubcase, param)[source]¶

Takes in a single-lined string and adds it to a single Subcase.

Parameters:	self – the CaseControlDeck object isubcase – the subcase ID to add param – the variable to add

Note

dont worry about overbounding the line

>>> bdf = BDF()
>>> bdf.read_bdf(bdf_filename)
>>> bdf.case_control.add_parameter_to_local_subcase(1, 'DISP=ALL')
>>> print(bdf.case_control)
TITLE = DUMMY LINE
SUBCASE 1
    DISP = ALL
>>>

begin_bulk = None¶

stores a single copy of ‘BEGIN BULK’ or ‘BEGIN SUPER’

convert_to_sol_200(model)[source]¶

Takes a case control deck and changes it from a SOL xxx to a SOL 200

Parameters:	self – the CaseControlDeck object

Todo

not done...

copy_subcase(i_from_subcase, i_to_subcase, overwrite_subcase=True)[source]¶

Overwrites the parameters from one subcase to another.

Parameters:	self – the CaseControlDeck object i_from_subcase – the Subcase to pull the data from i_to_subcase – the Subcase to map the data to overwrite_subcase – NULLs i_to_subcase before copying i_from_subcase

create_new_subcase(isubcase)[source]¶

Method create_new_subcase:

Parameters:	isubcase (int) – the subcase ID

Warning

be careful you dont add data to the global subcase after running this...is this True???

cross_reference(model)[source]¶

delete_subcase(isubcase)[source]¶

Deletes a subcase.

Parameters:	self – the CaseControlDeck object isubcase (int) – the Subcase to delete

finish_subcases()[source]¶

Removes any unwanted data in the subcase...specifically the SUBCASE data member. Otherwise it will print out after a key like stress.

Parameters:	self – the CaseControlDeck object

get_local_subcase_list()[source]¶

Gets the list of subcases that aren’t the global subcase ID

Parameters:	self – the CaseControlDeck object

get_op2_data()[source]¶

Gets the relevant op2 parameters required for a given subcase

Parameters:	self – the CaseControlDeck object

Todo

not done...

get_subcase_list()[source]¶

Gets the list of subcases including the global subcase ID (0)

Parameters:	self – the CaseControlDeck object

get_subcase_parameter(isubcase, param_name)[source]¶

Get the [value, options] of a subcase’s parameter. For example, for STRESS(PLOT,POST)=ALL, param_name=STRESS, value=ALL, options=[‘PLOT’, ‘POST’]

Parameters:	self – the CaseControlDeck object isubcase – the subcase ID to check param_name – the parameter name to get the [value, options] for

has_parameter(isubcase, param_name)[source]¶

Checks to see if a parameter (e.g. STRESS) is defined in a certain subcase ID.

Parameters:	self – the CaseControlDeck object isubcase – the subcase ID to check param_name – the parameter name to look for

has_subcase(isubcase)[source]¶

Checks to see if a subcase exists.

Parameters:	self – the CaseControlDeck object isubcase (int) – the subcase ID
Returns val:	does_subcase_exist (type = bool)

update_solution(isubcase, sol)[source]¶

sol = STATICS, FLUTTER, MODAL, etc.

Parameters:	self – the CaseControlDeck object isubcase – the subcase ID to update sol – the solution type to change the solution to

>>> print(bdf.case_control)
SUBCASE 1
    DISP = ALL

>>> bdf.case_control.update_solution(1, 'FLUTTER')
>>> print(bdf.case_control)
SUBCASE 1
    ANALYSIS FLUTTER
    DISP = ALL
>>>

class pyNastran.bdf.caseControlDeck.CaseControlDeckDeprecated[source]¶

Bases: object

pyNastran.bdf.caseControlDeck._clean_lines(case_control, lines)[source]¶

Removes comment characters defined by a $.

Parameters:	case_control – the CaseControlDeck object lines – the lines to clean.

pyNastran.bdf.caseControlDeck.verify_card(key, value, options, line)[source]¶

pyNastran.bdf.caseControlDeck.verify_card2(key, value, options, line)[source]¶

Make sure there are no obvious errors

deprecated Module¶

class pyNastran.bdf.deprecated.AeroDeprecated[source]¶

Bases: object

DisableGroundEffect()[source]¶

EnableGroundEffect()[source]¶

IsAntiSymmetricalXY()[source]¶

IsAntiSymmetricalXZ()[source]¶

IsSymmetricalXY()[source]¶

IsSymmetricalXZ()[source]¶

class pyNastran.bdf.deprecated.BDFMethodsDeprecated[source]¶

Bases: object

Mass()[source]¶

See also

mass

MassProperties()[source]¶

See also

mass_properties

mass(element_ids=None, sym_axis=None)[source]¶

Calculates mass in the global coordinate system

resolveGrids(cid=0)[source]¶

See also

resolve_grids

unresolveGrids(femOld)[source]¶

See also

unresolve_grids

class pyNastran.bdf.deprecated.BaseCardDeprecated[source]¶

Bases: object

Deprecated in:

• version 0.7

Removed in:

• version 0.8

printRawFields(size=8)[source]¶

rawFields()[source]¶

reprCard()[source]¶

reprFields()[source]¶

repr_card()[source]¶

class pyNastran.bdf.deprecated.CAERO1Deprecated[source]¶

Bases: object

Points()[source]¶

SetPoints(points)[source]¶

class pyNastran.bdf.deprecated.CAERO2Deprecated[source]¶

Bases: object

Points()[source]¶

SetPoints(points)[source]¶

class pyNastran.bdf.deprecated.CoordDeprecated[source]¶

Bases: object

T()[source]¶

Gets the 6 x 6 transformation

\[[\lambda] = [B_{ij}]\]

\[\begin{split}[T] = \left[ \begin{array}{cc} \lambda & 0 \\ 0 & \lambda \\ \end{array} \right]\end{split}\]

transformNodeToGlobal(p)[source]¶

transformToGlobal(p, debug=False)[source]¶

Transforms a node from the local frame to the global frame

Parameters:	p – the xyz point in the local frame debug – debug flag (default=False; unused)
Retval p2:	the xyz point in the global frame
Retval matrix:	the transformation matrix

transformToLocal(p, beta, debug=False)[source]¶

transformVectorToGlobal(p)[source]¶

transform_to_local(p, beta, debug=False)[source]¶

class pyNastran.bdf.deprecated.DeprecatedCompositeShellProperty[source]¶

Bases: object

To be deprecated in:

• Version 0.7

To be removed in:

• Version 0.8

MassPerArea(iply='all', method='nplies')[source]¶

Nsm()[source]¶

Rho(iply)[source]¶

Theta(iply)[source]¶

Thickness(iply='all')[source]¶

isSymmetrical()[source]¶

nPlies()[source]¶

sout(iply)[source]¶

class pyNastran.bdf.deprecated.ElementDeprecated[source]¶

Bases: object

nodePositions(nodes=None)[source]¶

class pyNastran.bdf.deprecated.GetMethodsDeprecated[source]¶

Bases: object

Flfact(sid, msg)[source]¶

Deprecated since version will: be removed in version 0.8

_get_element_ids_with_pids(pids, mode='list')[source]¶

coordIDs()[source]¶

deprecated

elementIDs()[source]¶

deprecated

getElementIDsWithPID(pid)[source]¶

Gets all the element IDs with a specific property ID

Parameters:	pid – property ID
Returns elementIDs:
	as a list

Deprecated since version will: be removed in version 0.8

The same functionality may be used by calling

>>> self.getElementIDsWithPIDs([pid], mode='list')

getElementIDsWithPIDs(pids, mode='list')[source]¶

deprecated

getMaterialIDToPropertyIDsMap()[source]¶

deprecated

getNodeIDToElementIDsMap()[source]¶

deprecated

getNodeIDsWithElement(eid)[source]¶

deprecated

getNodeIDsWithElements(eids, msg='')[source]¶

deprecated

getNodes()[source]¶

deprecated

getPropertyIDToElementIDsMap()[source]¶

deprecated

get_coord_ids()[source]¶

get_element_ids()[source]¶

deprecated

get_ncaeros()[source]¶

get_nelements()[source]¶

deprecated

get_nnodes()[source]¶

deprecated

get_node_ids()[source]¶

deprecated

get_property_ids()[source]¶

deprecated

materialIDs()[source]¶

deprecated

nCAeros()[source]¶

deprecated

nElements()[source]¶

deprecated

nNodes()[source]¶

deprecated

nodeIDs()[source]¶

deprecated

propertyIDs()[source]¶

deprecated

structuralMaterialIDs()[source]¶

deprecated

thermalMaterialIDs()[source]¶

deprecated

class pyNastran.bdf.deprecated.GridDeprecated[source]¶

Bases: object

Position(debug=False)[source]¶

PositionWRT(model, cid, debug=False)[source]¶

UpdatePosition(model, xyz, cid=0)[source]¶

class pyNastran.bdf.deprecated.PointDeprecated[source]¶

Bases: object

Position(debug=False)[source]¶

PositionWRT(model, cid, debug=False)[source]¶

UpdatePosition(model, xyz, cid=0)[source]¶

class pyNastran.bdf.deprecated.SPOINTsDeprecated[source]¶

Bases: object

nDOF()[source]¶

class pyNastran.bdf.deprecated.ShellElementDeprecated[source]¶

Bases: object

Rho()[source]¶

Returns the density

fieldWriter Module¶

Defines legacy import functions

pyNastran.bdf.fieldWriter.print_card(fields, size=8, is_double=False)[source]¶

Prints a card in 8-character of 16-character Nastran format.

Parameters:	fields – all the fields in the BDF card (no trailing Nones) size – 8/16 is_double – True/False
Returns card:	string representation of the card

Note

be careful of using is_double on cards that aren’t GRID or COORDx

field_writer_8 Module¶

Defines functions for single precision 8 character field writing.

pyNastran.bdf.field_writer_8.is_same(value1, value2)[source]¶

Checks to see if 2 values are the same

Note

this method is used by almost every card when printing

pyNastran.bdf.field_writer_8.print_card_8(fields)[source]¶

Prints a nastran-style card with 8-character width fields.

Parameters:	fields – all the fields in the BDF card (no trailing Nones)
Returns card:	string representation of the card in small field format

Note

An internal field value of None or ‘’ will be treated as a blank field

Note

A small field format follows the 8-8-8-8-8-8-8-8 = 80 format where the first 8 is the card name or blank (continuation). The last 8-character field indicates an optional continuation, but because it’s a left-justified unneccessary field, print_card doesnt use it.

>>> fields = ['DUMMY', 1, 2, 3, None, 4, 5, 6, 7, 8.]
>>> print_card_8(fields)
DUMMY          1       2       3               4       5       6       7
DUMMY          1       2       3               4       5       6       7
              8.

pyNastran.bdf.field_writer_8.print_field(value)[source]¶

helper method for writing cards

pyNastran.bdf.field_writer_8.print_field_8(value)[source]¶

Prints a 8-character width field

Parameters:	value – the value to print
Returns field:	an 8-character string

pyNastran.bdf.field_writer_8.print_float_8(value)[source]¶

Prints a float in nastran 8-character width syntax using the highest precision possbile.

pyNastran.bdf.field_writer_8.print_int_card(fields)[source]¶

Prints a nastran-style card with 8-character width fields. All fields (other than the first field) must be integers. This is used to speed up SET cards.

Parameters:	fields – The list of fields to write to a nastran card.

Warning

Blanks are not allowed! Floats and strings are not allowed.

fields = ['SET', 1, 2, 3, 4, 5, 6, ..., n]

pyNastran.bdf.field_writer_8.print_int_card_blocks(fields_blocks)[source]¶

Prints a nastran-style card with 8-character width fields. All fields other than the card name must be written in “block” format. This is used to speed up SET cards.

param fields_blocks:
	The fields written in “block” notation.
type msg:	list or tuple
returns msg:	the field blocks as a 8-character width Nastran card
type msg:	str

Note

Blanks are allowed in the False block.

fields_blocks = [
    'SET1',
    [['a', 1.0, 3], False], # these are not all integers
    [[1, 2, 3], True],      # these are all integers
]
msg = print_int_card_blocks(fields_blocks)
print(msg)
>>> 'SET1           a      1.       3       1       2       3

‘

pyNastran.bdf.field_writer_8.print_scientific_8(value)[source]¶

Prints a value in 8-character scientific notation. This is a sub-method and shouldnt typically be called

pyNastran.bdf.field_writer_8.set_blank_if_default(value, default)[source]¶

Used when setting the output data of a card to clear default values

Parameters:	value – the field value the may be set to None (blank) if value=default, the default value for the field

Note

this method is used by almost every card when printing

pyNastran.bdf.field_writer_8.set_default_if_blank(value, default)[source]¶

Used when initializing a card and the default value isn’t set Used on PBARL

pyNastran.bdf.field_writer_8.set_string8_blank_if_default(value, default)[source]¶

helper method for writing BDFs

field_writer_16 Module¶

Defines functions for single precision 16 character field writing.

pyNastran.bdf.field_writer_16.print_card_16(fields, wipe_fields=True)[source]¶

Prints a nastran-style card with 16-character width fields.

Parameters:	fields – all the fields in the BDF card (no trailing Nones) wipe_fields – some cards (e.g. PBEAM) have ending fields that need to be there, others cannot have them.

Note

An internal field value of None or ‘’ will be treated as a blank field

Note

A large field format follows the 8-16-16-16-16-8 = 80 format where the first 8 is the card name or blank (continuation). The last 8-character field indicates an optional continuation, but because it’s a left-justified unneccessary field, print_card doesnt use it.

>>> fields = ['DUMMY', 1, 2, 3, None, 4, 5, 6, 7, 8.]
>>> print_card_16(fields)
DUMMY*                 1               2               3
*                      4               5               6               7
*                     8.
*

pyNastran.bdf.field_writer_16.print_field_16(value)[source]¶

Prints a 16-character width field

Parameters:	value – the value to print
Returns field:	an 16-character string

pyNastran.bdf.field_writer_16.print_float_16(value)[source]¶

Prints a float in nastran 16-character width syntax using the highest precision possbile. .. seealso:: print_float_8

pyNastran.bdf.field_writer_16.print_scientific_16(value)[source]¶

Prints a value in 16-character scientific notation. This is a sub-method and shouldnt typically be called

See also

print_float_16 for a better method

pyNastran.bdf.field_writer_16.set_string16_blank_if_default(value, default)[source]¶

helper method for writing BDFs

field_writer_double Module¶

Defines functions for double precision 16 character field writing.

pyNastran.bdf.field_writer_double.print_card_double(fields, wipe_fields=True)[source]¶

Prints a nastran-style card with 16-character width fields.

Parameters:	fields – all the fields in the BDF card (no trailing Nones) wipe_fields – some cards (e.g. PBEAM) have ending fields that need to be there, others cannot have them.

Note

An internal field value of None or ‘’ will be treated as a blank field

Note

A large field format follows the 8-16-16-16-16-8 = 80 format where the first 8 is the card name or blank (continuation). The last 8-character field indicates an optional continuation, but because it’s a left-justified unneccessary field, print_card doesnt use it.

>>> fields = ['DUMMY', 1, 2, 3, None, 4, 5, 6, 7, 8.]
>>> print_card_double(fields)
DUMMY*                 1               2               3
*                      4               5               6               7
*       8.0000000000D+00
*

pyNastran.bdf.field_writer_double.print_field_double(value)[source]¶

Prints a 16-character width field

Parameters:	value – the value to print
Returns field:	an 16-character string

pyNastran.bdf.field_writer_double.print_scientific_double(value)[source]¶

Prints a value in 16-character scientific double precision.

Scientific Notation: 5.0E+1 Double Precision Scientific Notation: 5.0D+1

subcase Module¶

Subcase creation/extraction class

class pyNastran.bdf.subcase.Subcase(id=0)[source]¶

Bases: object

Subcase creation/extraction class

_add_data(key, value, options, param_type)[source]¶

_simplify_data(key, value, options, param_type)[source]¶

cross_reference(model)[source]¶

Method crossReference:

Parameters:	self – the Subcase object model – the BDF object

Note

this is not integrated and probably never will be as it’s not really that necessary. it’s only really useful when running an analysis.

finish_subcase()[source]¶

Removes the subcase parameter from the subcase to avoid printing it in a funny spot

Parameters:	self – the Subcase object

get_analysis_code(sol)[source]¶

• 8 - post-buckling (maybe 7 depending on NLPARM???)

# not important

• 3/4 - differential stiffness (obsolete)
• 11 - old geometric nonlinear statics
• 12 - contran (???)

Todo

verify

get_device_code(options, value)[source]¶

Gets the device code of a given set of options and value

Parameters:	self – the Subcase object options – the options for a parameter value – the value of the parameter

get_format_code(options, value)[source]¶

Gets the format code that will be used by the op2 based on the options.

Parameters:	self – the Subcase object options – the options for a parameter value – the value of the parameter

Todo

not done...only supports REAL, IMAG, PHASE, not RANDOM

get_op2_data(sol, solmap_toValue)[source]¶

get_parameter(param_name)[source]¶

Gets the [value, options] for a subcase.

Parameters:	self – the Subcase object param_name – the case control parameter to check for

get_sort_code(options, value)[source]¶

Gets the sort code of a given set of options and value

Parameters:	self – the Subcase object options – the options for a parameter value – the value of the parameter

get_stress_code(key, options, value)[source]¶

Method get_stress_code:

Note

the individual element must take the stress_code and reduce

it to what the element can return. For example, for an isotropic CQUAD4 the fiber field doesnt mean anything.

BAR - no von mises/fiber ISOTROPIC - no fiber

Todo

how does the MATERIAL bit get turned on? I’m assuming it’s element dependent...

get_table_code(sol, table_name, options)[source]¶

Gets the table code of a given parameter. For example, the DISPLACMENT(PLOT,POST)=ALL makes an OUGV1 table and stores the displacement. This has an OP2 table code of 1, unless you’re running a modal solution, in which case it makes an OUGV1 table of eigenvectors and has a table code of 7.

Parameters:	self – the Subcase object options – the options for a parameter value – the value of the parameter

has_parameter(param_name)[source]¶

Checks to see if a parameter name is in the subcase.

Parameters:	self – the Subcase object param_name – the case control parameter to check for

print_param(key, param)[source]¶

Prints a single entry of the a subcase from the global or local subcase list.

Parameters:	self – the Subcase object

solCodeMap = {64: 106, 1: 101, 66: 106, 68: 106, 76: 101, 144: 101, 21: 101, 24: 101, 26: 101, 99: 129, 187: 101, 61: 101}¶

subcase_sorted(lst)[source]¶

Does a “smart” sort on the keys such that SET cards increment in numerical order. Also puts the sets first.

Parameters:	self – the Subcase object lst – the list of subcase list objects
Returns listB:	the sorted version of listA

write_subcase(subcase0)[source]¶

Internal method to print a subcase

Parameters:	self – the Subcase object subcase0 – the global Subcase object

pyNastran.bdf.subcase.update_param_name(param_name)[source]¶

Takes an abbreviated name and expands it so the user can type DISP or DISPLACEMENT and get the same answer

Parameters:	param_name – the parameter name to be standardized (e.g. DISP vs. DIPLACEMENT)

Todo

not a complete list

utils Module¶

exception pyNastran.bdf.utils.CardParseSyntaxError[source]¶

Bases: exceptions.SyntaxError

pyNastran.bdf.utils.Position(xyz, cid, model, is_cid_int=True)[source]¶

Gets the point in the global XYZ coordinate system.

Parameters:	xyz (TYPE = NDARRAY. SIZE=(3,)) – the position of the GRID in an arbitrary coordinate system cid (int) – the coordinate ID for xyz model (BDF()) – the BDF model object
Returns xyz2:	the position of the GRID in an arbitrary coordinate system

pyNastran.bdf.utils.PositionWRT(xyz, cid, cid_new, model, is_cid_int=True)[source]¶

Gets the location of the GRID which started in some arbitrary system and returns it in the desired coordinate system

Parameters:	xyz (TYPE = NDARRAY. SIZE=(3,)) – the position of the GRID in an arbitrary coordinate system cid (int) – the coordinate ID for xyz cid_new (int) – the desired coordinate ID model (BDF()) – the BDF model object
Returns xyz_local:
	the position of the GRID in an arbitrary coordinate system

pyNastran.bdf.utils.TransformLoadWRT(F, M, cid, cid_new, model, is_cid_int=True)[source]¶

Transforms a force/moment from an arbitrary coordinate system to another coordinate system.

Parameters:	Fxyz (TYPE = NDARRAY. SIZE=(3,)) – the force in an arbitrary coordinate system Mxyz (TYPE = NDARRAY. SIZE=(3,)) – the moment in an arbitrary coordinate system cid (int) – the coordinate ID for xyz cid_new (int) – the desired coordinate ID model (BDF()) – the BDF model object is_cid_int (bool) – is cid/cid_new an integer or a Coord object
Returns Fxyz_local:
	the force in an arbitrary coordinate system
Returns Mxyz_local:
	the force in an arbitrary coordinate system

pyNastran.bdf.utils._clean_comment(comment, end=-1)[source]¶

Removes specific pyNastran comment lines so duplicate lines aren’t created.

Parameters:	comment – the comment to possibly remove

pyNastran.bdf.utils.clean_empty_lines(lines)[source]¶

Removes leading and trailing empty lines don’t remove internally blank lines

pyNastran.bdf.utils.get_include_filename(card_lines, include_dir='')[source]¶

Parses an INCLUDE file split into multiple lines (as a list).

Parameters:	card_lines – the list of lines in the include card (all the lines!) include_dir – the include directory (default=’‘)
Returns filename:
	the INCLUDE filename

pyNastran.bdf.utils.parse_executive_control_deck(executive_control_lines)[source]¶

Extracts the solution from the executive control deck

pyNastran.bdf.utils.parse_patran_syntax(node_sets)[source]¶

Parses Patran’s syntax for compressing nodes/elements

Parameters:	node_sets – the node_set to parse
Returns nodes:	list of integers

Patran has a short syntax of the form:

String	Output
“1 2 3”	[1, 2, 3]
“5:10”	[5, 6, 7, 8, 9, 10]
“12:20:2”	[12, 14, 16, 18, 20]

>>> node_sets = "1 2 3 5:10 12:20:2"
>>> data = parse_patran_syntax(node_sets)
>>> data
data = [1, 2, 3, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20]

Warning

Don’t include the n/node or e/element or any other identifier, just a string of “1 2 3 5:10 12:20:2”. Use parse_patran_syntax_dict to consider the identifier.

Note

doesn’t support “1:#”

pyNastran.bdf.utils.parse_patran_syntax_dict(node_sets)[source]¶

Parses Patran’s syntax for compressing nodes/elements

Parameters:	node_sets – the node_set to parse
Returns nodes:	list of integers

node_sets = "e 1:3 n 2:6:2 Node 10:13"
data = parse_patran_syntax_dict(node_sets)
data = {
    'e'    : [1, 2, 3],
    'n'    : [2, 4, 6],
    'Node' : [10, 11, 12, 13],
}

Note

the identifier (e.g. “e”) must be used. Use parse_patran_syntax to skip the identifier.

Note

doesn’t support “1:#”

pyNastran.bdf.utils.print_filename(filename, relpath)[source]¶

Takes a path such as C:/work/fem.bdf and locates the file using relative paths. If it’s on another drive, the path is not modified.

Parameters:	filename – a filename string
Returns filename_string:
	a shortened representation of the filename

pyNastran.bdf.utils.to_fields(card_lines, card_name)[source]¶

Converts a series of lines in a card into string versions of the field. Handles large, small, and CSV formatted cards.

Parameters:	lines – the lines of the BDF card object card_name – the card_name -> ‘GRID’
Returns fields:	the string formatted fields of the card

Warning

this function is used by the reader and isn’t intended to be called by a separate process

>>> card_lines = []'GRID,1,,1.0,2.0,3.0']
>>> card_name = 'GRID'
>>> fields = to_fields(lines, card_name)
>>> fields
['GRID', '1', '', '1.0', '2.0', '3.0']

write_path Module¶

pyNastran.bdf.write_path.main()[source]¶

pyNastran.bdf.write_path.split_path(abspath)[source]¶

Takes a path and splits it into the various components

pyNastran.bdf.write_path.write_include(filename, is_windows=True)[source]¶

Writes a bdf INCLUDE file line given an imported filename.

Parameters:	filename – the filename to write is_windows – Windows has a special format for writing INCLUDE files so the format for a BDF that will run on Linux and Windows is different. We could check the platform, but since you might need to change platforms, it’s an option (default=True)

For a model that will run on Linux:

..code-blocK:: python

fname = r’/opt/NASA/test1/test2/test3/test4/formats/pynastran_v0.6/pyNastran/bdf/model.inc’ write_include(fname, is_windows=False)

..code-blocK:: python

INCLUDE /opt/NASA/test1/test2/test3/test4/formats/pynastran_v0.6/

pyNastran/bdf/model.inc