aero Module

All aero cards are defined in this file. This includes:

• AECOMP
• AEFACT
• AELINK
• AELIST
• AEPARM
• AESURF / AESURFS
• CAERO1 / CAERO2 / CAERO3 / CAERO4 / CAERO5
• PAERO1 / PAERO2 / PAERO3 / PAERO4 / PAERO5
• SPLINE1 / SPLINE2 / SPLINE3 / SPLINE4 / SPLINE5
• MONPNT1 / MONPNT2 / MONPNT3

All cards are BaseCard objects.

class pyNastran.bdf.cards.aero.aero.AECOMP(name, list_type, lists, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines a component for use in monitor point definition or external splines.

1	2	3	4	5	6	7	8	9
AECOMP	NAME	LISTTYPE	LIST1	LIST2	LIST3	LIST4	LIST5	LIST6
	LIST7	etc.
AECOMP	WING	AELIST	1001	1002

Attributes:

name : str

The name.

list_type : str

{‘SET1’, ‘AELIST’, ‘CAEROx’}

lists : list[int]

list of values of AECOMP lists

Creates an AECOMP card

Parameters:

name : str

the name of the component

list_type : str

One of CAERO, AELIST or CMPID for aerodynamic components and SET1 for structural components. Aerodynamic components are defined on the aerodynamic ks-set mesh while the structural components are defined on the g-set mesh.

lists : List[int, int, …]; int

The identification number of either SET1, AELIST or CAEROi entries that define the set of grid points that comprise the component

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds an AECOMP card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

allowed_list_types = ['SET1', 'AELIST', 'CAERO']

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

get_lists(self)

raw_fields(self)

safe_cross_reference(self, model)

type = 'AECOMP'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

The writer method used by BDF.write_card()

Parameters:

size : int; default=8

the size of the card (8/16)

class pyNastran.bdf.cards.aero.aero.AECOMPL(name, labels, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

1	2	3	4	5	6	7	8	9
AECOMPL	NAME	LABEL1	LABEL2	LABEL3	LABEL4	LABEL5	LABEL6	LABEL7
	LABEL8	etc.
AECOMPL	HORIZ	STAB	ELEV	BALANCE

Creates an AECOMPL card

Parameters:

name : str

the name of the component

labels : List[str, str, …]; str

A string of 8 characters referring to the names of other components defined by either AECOMP or other AECOMPL entries.

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds an AECOMPL card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

raw_fields(self)

safe_cross_reference(self, model)

type = 'AECOMPL'

uncross_reference(self)

Removes cross-reference links

write_card(self, size=8, is_double=False)

The writer method used by BDF.write_card()

Parameters:

size : int; default=8

the size of the card (8/16)

class pyNastran.bdf.cards.aero.aero.AEFACT(sid, fractions, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines real numbers for aeroelastic analysis.

1	2	3	4	5	6	7	8	9
AEFACT	SID	D1	D2	D3	D4	D5	D6	D7
	D8	D9	etc.
AEFACT	97	.3	0.7	1.0

TODO: Are these defined in percentages and thus,

should they be normalized if they are not?

Creates an AEFACT card, which is used by the CAEROx / PAEROx card to adjust the spacing of the sub-paneleing (and grid point paneling in the case of the CAERO3).

Parameters:

sid : int

unique id

fractions : List[float, …, float]

list of percentages

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds an AEFACT card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

fractions = None

Number (float)

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : List[int/float/str]

the fields that define the card

sid = None

Set identification number. (Unique Integer > 0)

type = 'AEFACT'

write_card(self, size=8, is_double=False)

The writer method used by BDF.write_card()

Parameters:

size : int; default=8

the size of the card (8/16)

class pyNastran.bdf.cards.aero.aero.AELINK(aelink_id, label, independent_labels, linking_coefficents, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines relationships between or among AESTAT and AESURF entries, such that:

\[u^D + \Sigma_{i=1}^n C_i u_i^I = 0.0\]

1	2	3	4	5	6	7	8	9
AELINK	ID	LABLD	LABL1	C1	LABL2	C2	LABL3	C3
	LABL4	C4	etc.
AELINK	10	INBDA	OTBDA	-2.0

Creates an AELINK card, which defines an equation linking AESTAT and AESURF cards

Parameters:

aelink_id : int/str

unique id

label : str

name of the dependent AESURF card

independent_labels : List[str, …, str]

name for the independent variables (AESTATs)

linking_coefficents : List[float]

linking coefficients

comment : str; default=’‘

a comment for the card

Cis

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds an AELINK card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

aelink_id = None

an ID=0 is applicable to the global subcase, ID=1 only subcase 1

independent_labels = None

defines the independent variable name (string)

label = None

defines the dependent variable name (string)

linking_coefficents = None

linking coefficients (real)

object_attributes(self, mode='public', keys_to_skip=None, filter_properties=False)

See also

pyNastran.utils.object_methods(…)

object_methods(self, mode='public', keys_to_skip=None)

See also

pyNastran.utils.object_methods(…)

raw_fields(self)

Gets the fields in their unmodified form

Returns:

list_fields : List[int/float/str]

the fields that define the card

type = 'AELINK'

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

The writer method used by BDF.write_card()

Parameters:

size : int; default=8

the size of the card (8/16)

class pyNastran.bdf.cards.aero.aero.AELIST(sid, elements, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines a list of aerodynamic elements to undergo the motion prescribed with the AESURF Bulk Data entry for static aeroelasticity.

1	2	3	4	5	6	7	8	9
AELIST	SID	E1	E2	E3	E4	E5	E6	E7
	E8	etc.
AELIST	75	1001	THRU	1075	1101	THRU	1109	1201
	1202

Notes

1. These entries are referenced by the AESURF entry.
2. When the THRU option is used, all intermediate grid points must exist. The word THRU may not appear in field 3 or 9 (2 or 9 for continuations).
3. Intervening blank fields are not allowed.

Creates an AELIST card, which defines the aero boxes for an AESURF/SPLINEx.

Parameters:

sid : int

unique id

elements : List[int, …, int]; int

list of box ids

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds an AELIST card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

clean_ids(self)

cross_reference(self, model)

elements = None

List of aerodynamic boxes generated by CAERO1 entries to define a surface. (Integer > 0 or ‘THRU’)

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : List[int/float/str]

the fields that define the card

safe_cross_reference(self, model)

sid = None

Set identification number. (Integer > 0)

type = 'AELIST'

uncross_reference(self)

Removes cross-reference links

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.AEPARM(aeparm_id, label, units, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines a general aerodynamic trim variable degree-of-freedom (aerodynamic extra point). The forces associated with this controller will be derived from AEDW, AEFORCE and AEPRESS input data.

1	2	3	4
AEPARM	ID	LABEL	UNITS
AEPARM	5	THRUST	LBS

Creates an AEPARM card, which defines a new trim variable.

Parameters:

id : int

the unique id

label : str

the variable name

units : str

unused by Nastran

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds an AEPARM card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : List[int/float/str]

the fields that define the card

safe_cross_reference(self, model)

type = 'AEPARM'

uncross_reference(self)

Removes cross-reference links

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.AESURF(aesid, label, cid1, alid1, cid2=None, alid2=None, eff=1.0, ldw='LDW', crefc=1.0, crefs=1.0, pllim=-1.5707963267948966, pulim=1.5707963267948966, hmllim=None, hmulim=None, tqllim=None, tqulim=None, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Specifies an aerodynamic control surface as a member of the set of aerodynamic extra points. The forces associated with this controller will be derived from rigid rotation of the aerodynamic model about the hinge line(s) and from AEDW, AEFORCE and AEPRESS input data. The mass properties of the control surface can be specified using an AESURFS entry.

1	2	3	4	5	6	7	8	9
AESURF	ID	LABEL	CID1	ALID1	CID2	ALID2	EFF	LDW
	CREFC	CREFS	PLLIM	PULIM	HMLLIM	HMULIM	TQLLIM	TQULIM

Creates an AESURF card, which defines a control surface

Parameters:

aesid : int

controller number

label : str

controller name

cid1 / cid2 : int / None

coordinate system id for primary/secondary control surface

alid1 / alid2 : int / None

AELIST id for primary/secondary control surface

eff : float; default=1.0

Control surface effectiveness

ldw : str; default=’LDW’

Linear downwash flag; [‘LDW’, ‘NODLW’]

crefc : float; default=1.0

reference chord for the control surface

crefs : float; default=1.0

reference area for the control surface

pllim / pulim : float; default=-pi/2 / pi/2

Lower/Upper deflection limits for the control surface in radians

hmllim / hmulim : float; default=None

Lower/Upper hinge moment limits for the control surface in force-length units

tqllim / tqulim : int; default=None

Set identification numbers of TABLEDi entries that provide the lower/upper deflection limits for the control surface as a function of the dynamic pressure

comment : str; default=’‘

a comment for the card

Cid1(self)

Cid2(self)

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds an AESURF card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

aelist_id1(self)

aelist_id2(self)

aesid = None

Controller identification number

alid1 = None

Identification of an AELIST Bulk Data entry that identifies all aerodynamic elements that make up the control surface component. (Integer > 0)

cid1 = None

Identification number of a rectangular coordinate system with a y-axis that defines the hinge line of the control surface component.

crefc = None

Reference chord length for the control surface. (Real>0.0; Default=1.0)

crefs = None

Reference surface area for the control surface. (Real>0.0; Default=1.0)

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

eff = None

Control surface effectiveness. See Remark 4. (Real != 0.0; Default=1.0)

hmllim = None

Lower and upper hinge moment limits for the control surface in force-length units. (Real, Default = no limit) -> 1e8

label = None

Controller name.

ldw = None

Linear downwash flag. See Remark 2. (Character, one of LDW or NOLDW; Default=LDW).

pllim = None

Lower and upper deflection limits for the control surface in radians. (Real, Default = +/- pi/2)

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fieldsreset_camera[int/float/str]

the fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : List[int/float/str]

the fields that define the card

safe_cross_reference(self, model, xref_errors)

tqllim = None

Set identification numbers of TABLEDi entries that provide the lower and upper deflection limits for the control surface as a function of the dynamic pressure. (Integer>0, Default = no limit)

type = 'AESURF'

uncross_reference(self)

Removes cross-reference links

update(self, unused_model, maps)

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.AESURFS(aesid, label, list1, list2, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Optional specification of the structural nodes associated with an aerodynamic control surface that has been defined on an AESURF entry. The mass associated with these structural nodes define the control surface moment(s) of inertia about the hinge line(s). Specifies rigid body motions to be used as trim variables in static aeroelasticity.

1	2	3	4	5	6	7
AESURFS	ID	LABEL		LIST1		LIST2
AESURFS	6001	ELEV		6002		6003

Creates an AESURFS card

Parameters:

aesid : int

the unique id

label : str

the AESURF name

list1 / list2 : int / None

the list (SET1) of node ids for the primary/secondary control surface(s) on the AESURF card

comment : str; default=’‘

a comment for the card

List1(self)

List2(self)

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds an AESURFS card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : List[int/float/str]

the fields that define the card

safe_cross_reference(self, model)

type = 'AESURFS'

uncross_reference(self)

Removes cross-reference links

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.CAERO1(eid, pid, igroup, p1, x12, p4, x43, cp=0, nspan=0, lspan=0, nchord=0, lchord=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines an aerodynamic macro element (panel) in terms of two leading edge locations and side chords. This is used for Doublet-Lattice theory for subsonic aerodynamics and the ZONA51 theory for supersonic aerodynamics.

1	2	3	4	5	6	7	8	9
CAERO1	EID	PID	CP	NSPAN	NCHORD	LSPAN	LCHORD	IGID
	X1	Y1	Z1	X12	X4	Y4	Z4	X43

1
|       |         |           |      4
|      |
|      |
2------3

Attributes:

eid : int

element id

pid : int, PAERO1

int : PAERO1 ID PAERO1 : PAERO1 object (xref)

igroup : int

Group number

p1 : (1, 3) ndarray float

xyz location of point 1 (leading edge; inboard)

p4 : (1, 3) ndarray float

xyz location of point 4 (leading edge; outboard)

x12 : float

distance along the flow direction from node 1 to node 2; (typically x, root chord)

x43 : float

distance along the flow direction from node 4 to node 3; (typically x, tip chord)

cp : int, CORDx

int : coordinate system CORDx : Coordinate object (xref)

nspan : int

int > 0 : N spanwise boxes distributed evenly int = 0 : use lchord

nchord : int

int > 0 : N chordwise boxes distributed evenly int = 0 : use lchord

lspan : int, AEFACT

int > 0 : AEFACT reference for non-uniform nspan int = 0 : use nspan AEFACT : AEFACT object (xref)

lchord : int, AEFACT

int > 0 : AEFACT reference for non-uniform nchord int = 0 : use nchord AEFACT : AEFACT object (xref)

comment : str; default=’‘

accesses the comment

Defines a CAERO1 card, which defines a simplified lifting surface (e.g., wing/tail).

Parameters:

eid : int

element id

pid : int, PAERO1

int : PAERO1 ID PAERO1 : PAERO1 object (xref)

igroup : int

Group number

p1 : (1, 3) ndarray float

xyz location of point 1 (leading edge; inboard)

p4 : (1, 3) ndarray float

xyz location of point 4 (leading edge; outboard)

x12 : float

distance along the flow direction from node 1 to node 2; (typically x, root chord)

x43 : float

distance along the flow direction from node 4 to node 3; (typically x, tip chord)

cp : int, CORDx; default=0

int : coordinate system CORDx : Coordinate object (xref)

nspan : int; default=0

int > 0 : N spanwise boxes distributed evenly int = 0 : use lchord

nchord : int; default=0

int > 0 : N chordwise boxes distributed evenly int = 0 : use lchord

lspan : int, AEFACT; default=0

int > 0 : AEFACT reference for non-uniform nspan int = 0 : use nspan AEFACT : AEFACT object (xref)

lchord : int, AEFACT; default=0

int > 0 : AEFACT reference for non-uniform nchord int = 0 : use nchord AEFACT : AEFACT object (xref)

comment : str; default=’‘

a comment for the card

Cp(self)

Pid(self)

_box_id_error(self, box_id)

Raise box_id IndexError.

_finalize_hdf5(self, encoding)

hdf5 helper function

_get_box_x_chord_center(self, box_id, x_chord)

The the location of the x_chord of the box along the centerline.

classmethod _init_from_empty()

_init_ids(self, dtype='int32')

Fill self.box_ids with the sub-box ids. Shape is (nchord, nspan)

_properties = ['_field_map', 'shape', 'xy', 'min_max_eid', 'npanels']

classmethod add_card(card, comment='')

Adds a CAERO1 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

classmethod add_quad(eid, pid, span, chord, igroup, p1, p2, p3, p4, cp=0, spanwise='y', comment='')

1
| \
|   \
|     \
|      4
|      |
|      |
2------3

TODO: CP not handled correctly

cp = None

Coordinate system for locating point 1.

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

eid = None

Element identification number

flip_normal(self)

flips the CAERO1 normal vector

get_LChord(self)

get_LSpan(self)

get_box_index(self, box_id)

Get the index of self.box_ids that coresponds to the given box id.

Parameters:

box_id : int

Box id to ge tthe index of.

Returns:

index : tuple

Index of self.box_ids that coresponds to the given box id.

get_box_mid_chord_center(self, box_id)

The the location of the mid chord of the box along the centerline.

Parameters:

box_id : int

Box id.

Returns:

xyz_mid_chord : ndarray

Location of box mid chord in global.

get_box_quarter_chord_center(self, box_id)

The the location of the quarter chord of the box along the centerline.

Parameters:

box_id : int

Box id.

Returns:

xyz_quarter_chord : ndarray

Location of box quater chord in global.

get_leading_edge_points(self)

gets the leading edge points

get_npanel_points_elements(self)

Gets the number of sub-points and sub-elements for the CAERO card

Returns:

npoints : int

The number of nodes for the CAERO

nelmements : int

The number of elements for the CAERO

get_points(self)

Get the 4 corner points for the CAERO card

Returns:

p1234 : (4, 3) list

List of 4 corner points in the global frame

min_max_eid

Gets the min and max element ids of the CAERO card

Returns:

min_max_eid : (2, ) list

The [min_eid, max_eid]

npanels

panel_points_elements(self)

Gets the sub-points and sub-elements for the CAERO1 card

Returns:

points : (nnodes,3) ndarray of floats

the array of points

elements : (nelements,4) ndarray of integers

the array of point ids

pid = None

Property identification number of a PAERO2 entry.

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list

the fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : LIST

The fields that define the card

safe_cross_reference(self, model, xref_errors)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

set_points(self, points)

shape

returns (nelements_nchord, nelements_span)

shift(self, dxyz)

shifts the aero panel

type = 'CAERO1'

uncross_reference(self)

Removes cross-reference links

update(self, maps)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

xy

Returns:

x : (nchord,) ndarray

The percentage x location in the chord-wise direction of each panel

y : (nspan,) ndarray

The percentage y location in the span-wise direction of each panel

class pyNastran.bdf.cards.aero.aero.CAERO2(eid, pid, igroup, p1, x12, cp=0, nsb=0, nint=0, lsb=0, lint=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Aerodynamic Body Connection Defines aerodynamic slender body and interference elements for Doublet-Lattice aerodynamics.

1	2	3	4	5	6	7	8	9
CAERO2	EID	PID	CP	NSB	NINT	LSB	LINT	IGID
	X1	Y1	Z1	X12

Defines a CAERO2 card, which defines a slender body (e.g., fuselage/wingtip tank).

Parameters:

eid : int

element id

pid : int, PAERO2

int : PAERO2 ID PAERO2 : PAERO2 object (xref)

igroup : int

Group number

p1 : (1, 3) ndarray float

xyz location of point 1 (forward position)

x12 : float

length of the CAERO2

cp : int, CORDx; default=0

int : coordinate system CORDx : Coordinate object (xref)

nsb : int; default=0

Number of slender body elements

lsb : int; default=0

AEFACT id for defining the location of the slender body elements

nint : int; default=0

Number of interference elements

lint : int; default=0

AEFACT id for defining the location of interference elements

comment : str; default=’‘

a comment for the card

Cp(self)

Lint(self)

Lsb(self)

Pid(self)

classmethod _init_from_empty()

_init_ids(self, dtype='int32')

_properties = ['nboxes']

classmethod add_card(card, comment='')

Adds a CAERO2 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cp = None

Coordinate system for locating point 1.

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

eid = None

Element identification number

get_points(self)

creates a 1D representation of the CAERO2

get_points_elements_3d(self)

Gets the points/elements in 3d space as CQUAD4s The idea is that this is used by the GUI to display CAERO panels.

TODO: doesn’t support the aero coordinate system

igroup = None

Interference group identification. Aerodynamic elements with different IGIDs are uncoupled. (Integer >= 0)

lint = None

ID of an AEFACT data entry containing a list of division points for interference elements; used only if NINT is zero or blank. (Integer > 0)

lsb = None

ID of an AEFACT Bulk Data entry for slender body division points; used only if NSB is zero or blank. (Integer >= 0)

nboxes

nint = None

Number of interference elements. If NINT > 0, then NINT equal divisions are assumed; if zero or blank, specify a list of divisions in LINT. (Integer >= 0)

nsb = None

Number of slender body elements. If NSB > 0, then NSB equal divisions are assumed; if zero or blank, specify a list of divisions in LSB. (Integer >= 0)

p1 = None

Location of point 1 in coordinate system CP

pid = None

Property identification number of a PAERO2 entry.

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list

The fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : list

The fields that define the card

safe_cross_reference(self, model, xref_errors)

set_points(self, points)

shift(self, dxyz)

shifts the aero panel

type = 'CAERO2'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

x12 = None

Length of body in the x-direction of the aerodynamic coordinate system. (Real > 0)

class pyNastran.bdf.cards.aero.aero.CAERO3(eid, pid, list_w, p1, x12, p4, x43, cp=0, list_c1=None, list_c2=None, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Creates a CAERO2 card, which defines a wing with a wing break/cant.

Parameters:

eid : int

element id

pid : int

PAERO3 property id

p1 : (3,) float ndarray

???

x12 : float

???

p4 : (3,) float ndarray

???

x43 : float

???

cp : int; default=0

coordinate system for locating point 1

list_w : int

???

list_c1 : int; default=None

defines an AEFACT for ???

list_c2 : int; default=None

defines an AEFACT for ???

comment : str; default=’‘

a comment for the card

Cp(self)

List_c1(self)

List_c2(self)

List_w(self)

Pid(self)

classmethod _init_from_empty()

_properties = ['shape', 'xy']

classmethod add_card(card, comment='')

Adds a CAERO3 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cp = None

Coordinate system for locating point 1.

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

eid = None

Element identification number

get_npanel_points_elements(self)

Gets the number of sub-points and sub-elements for the CAERO card

Returns:

npoints : int

The number of nodes for the CAERO

nelmements : int

The number of elements for the CAERO

get_points(self)

Get the 4 corner points for the CAERO card

Returns:

p1234 : (4, 3) list

List of 4 corner points in the global frame

panel_points_elements(self)

Gets the sub-points and sub-elements for the CAERO card

Returns:

points : (nnodes,3) ndarray of floats

the array of points

elements : (nelements,4) ndarray of integers

the array of point ids

pid = None

Property identification number of a PAERO3 entry.

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list

The fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : list

The fields that define the card

safe_cross_reference(self, model, xref_errors)

shape

returns (nelements_nchord, nelements_span)

type = 'CAERO3'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

xy

Returns:

x : (nchord,) ndarray

The percentage x location in the chord-wise direction of each panel

y : (nspan,) ndarray

The percentage y location in the span-wise direction of each panel

class pyNastran.bdf.cards.aero.aero.CAERO4(eid, pid, p1, x12, p4, x43, cp=0, nspan=0, lspan=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Aerodynamic Macro-Strip Element Connection Defines an aerodynamic macro element for Strip theory.

1	2	3	4	5	6	7	8	9
CAERO4	EID	PID	CP	NSPAN	NCHORD
	X1	Y1	Z1	X12	X4	Y4	Z4	X43

Defines a CAERO4 card, which defines a strip theory surface.

Parameters:

eid : int

element id

pid : int, PAERO4

int : PAERO4 ID PAERO4 : PAERO4 object (xref)

p1 : (1, 3) ndarray float

xyz location of point 1 (leading edge; inboard)

p4 : (1, 3) ndarray float

xyz location of point 4 (leading edge; outboard)

x12 : float

distance along the flow direction from node 1 to node 2 (typically x, root chord)

x43 : float

distance along the flow direction from node 4 to node 3 (typically x, tip chord)

cp : int, CORDx; default=0

int : coordinate system CORDx : Coordinate object (xref)

nspan : int; default=0

int > 0 : N spanwise boxes distributed evenly int = 0 : use lchord

lspan : int, AEFACT; default=0

int > 0 : AEFACT reference for non-uniform nspan int = 0 : use nspan

comment : str; default=’‘

a comment for the card

Cp(self)

Pid(self)

classmethod _init_from_empty()

_init_ids(self, dtype='int32')

Fill self.box_ids with the sub-box ids. Shape is (nchord, nspan)

_properties = ['shape', 'xy']

classmethod add_card(card, comment='')

Adds a CAERO4 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cp = None

Coordinate system for locating point 1.

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

eid = None

Element identification number

get_LSpan(self)

get_npanel_points_elements(self)

Gets the number of sub-points and sub-elements for the CAERO card

Returns:

npoints : int

The number of nodes for the CAERO

nelmements : int

The number of elements for the CAERO

get_points(self)

panel_points_elements(self)

Gets the sub-points and sub-elements for the CAERO card

Returns:

points : (nnodes,3) ndarray of floats

the array of points

elements : (nelements,4) ndarray of integers

the array of point ids

pid = None

Property identification number of a PAERO4 entry.

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list

The fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : list

The fields that define the card

safe_cross_reference(self, model, xref_errors)

shape

returns (nelements_nchord, nelements_span)

type = 'CAERO4'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

xy

Returns:

x : (nchord,) ndarray

The percentage x location in the chord-wise direction of each panel

y : (nspan,) ndarray

The percentage y location in the span-wise direction of each panel

class pyNastran.bdf.cards.aero.aero.CAERO5(eid, pid, p1, x12, p4, x43, cp=0, nspan=0, lspan=0, ntheory=0, nthick=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines an aerodynamic macro element for Piston theory.

1	2	3	4	5	6	7	8	9
CAERO5	EID	PID	CP	NSPAN	LSPAN	NTHRY	NTHICK
	X1	Y1	Z1	X12	X4	Y4	Z4	X43
CAERO5	6000	6001	100		315	0	0
	0.0	0.0	0.0	1.0	0.2	1.0		0.8

Defines a CAERO5 card, which defines elements for Piston theory (high supersonic flow where the normal Mach is less than 1).

Parameters:

eid : int

element id

pid : int

PAERO5 ID

p1 : (1, 3) ndarray float

xyz location of point 1 (leading edge; inboard)

p4 : (1, 3) ndarray float

xyz location of point 4 (leading edge; outboard)

x12 : float

distance along the flow direction from node 1 to node 2; (typically x, root chord)

x43 : float

distance along the flow direction from node 4 to node 3; (typically x, tip chord)

cp : int, CORDx; default=0

int : coordinate system

nspan : int; default=0

int > 0 : N spanwise boxes distributed evenly int = 0 : use lchord

lspan : int, AEFACT; default=0

int > 0 : AEFACT reference for non-uniform nspan int = 0 : use nspan

ntheory : int; default=0

??? valid_theory = {0, 1, 2}

nthick : int; default=0

???

comment : str; default=’‘

a comment for the card

Cp(self)

LSpan(self)

Pid(self)

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds a CAERO5 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

c1_c2(self, mach)

cp = None

Coordinate system for locating point 1.

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

eid = None

Element identification number

get_npanel_points_elements(self)

get_points(self)

panel_points_elements(self)

pid = None

Property identification number of a PAERO5 entry.

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : list

The fields that define the card

safe_cross_reference(self, model, xref_errors)

type = 'CAERO5'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.MONPNT1(name, label, axes, aecomp_name, xyz, cp=0, cd=None, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

1	2	3	4	5	6	7	8	9
MONPNT1	NAME	LABEL
	AXES	COMP	CP	X	Y	Z	CD
MONPNT1	WING155	Wing Integrated Load to Butline 155
	34	WING		0.0	155.0	15.0

Creates a MONPNT1 card

Parameters:

name : str

Character string of up to 8 characters identifying the monitor point

label : str

A string comprising no more than 56 characters that identifies and labels the monitor point.

axes : str

components {1,2,3,4,5,6}

aecomp_name : str

name of the AECOMP/AECOMPL entry

xyz : List[float, float, float]; default=None

The coordinates in the CP coordinate system about which the loads are to be monitored. None : [0., 0., 0.]

cp : int, CORDx; default=0

coordinate system of XYZ

cd : int; default=None -> cp

the coordinate system for load outputs

comment : str; default=’‘

a comment for the card

Notes

CD - MSC specific field

Cd(self)

Cp(self)

classmethod _init_from_empty()

classmethod add_card(card, comment='')

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

raw_fields(self)

safe_cross_reference(self, model, xref_errors)

type = 'MONPNT1'

uncross_reference(self)

Removes cross-reference links

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.MONPNT2(name, label, table, Type, nddl_item, eid, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

MSC Nastran specific card

classmethod _init_from_empty()

classmethod add_card(card, comment='')

cross_reference(self, model)

raw_fields(self)

safe_cross_reference(self, model, unused_xref_errors)

type = 'MONPNT2'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.MONPNT3(name, label, axes, grid_set, elem_set, xyz, cp=0, cd=None, xflag=None, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

MSC Nastran specific card

Cd(self)

Cp(self)

classmethod _init_from_empty()

classmethod add_card(card, comment='')

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

raw_fields(self)

safe_cross_reference(self, model, xref_errors)

type = 'MONPNT3'

uncross_reference(self)

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.PAERO1(pid, caero_body_ids=None, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines associated bodies for the panels in the Doublet-Lattice method.

1	2	3	4	5	6	7	8
PAERO1	PID	B1	B2	B3	B4	B5	B6

Creates a PAERO1 card, which defines associated bodies for the panels in the Doublet-Lattice method.

Parameters:

pid : int

PAERO1 id

caero_body_ids : List[int]; default=None

CAERO2 ids that are within the same IGROUP group

comment : str; default=’‘

a comment for the card

Bi

Bodies(self)

classmethod _init_from_empty()

_properties = ['_field_map']

classmethod add_card(card, comment='')

Adds a PAERO1 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

object_attributes(self, mode='public', keys_to_skip=None, filter_properties=False)

List the names of attributes of a class as strings. Returns public attributes as default.

Parameters:

mode : str

defines what kind of attributes will be listed * ‘public’ - names that do not begin with underscore * ‘private’ - names that begin with single underscore * ‘both’ - private and public * ‘all’ - all attributes that are defined for the object

keys_to_skip : List[str]; default=None -> []

names to not consider to avoid deprecation warnings

Returns:

attribute_names : List[str]

sorted list of the names of attributes of a given type or None if the mode is wrong

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list[varies]

the fields that define the card

safe_cross_reference(self, model, xref_errors)

type = 'PAERO1'

uncross_reference(self)

Removes cross-reference links

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.PAERO2(pid, orient, width, AR, thi, thn, lrsb=None, lrib=None, lth=None, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines the cross-sectional properties of aerodynamic bodies.

1	2	3	4	5	6	7	8	9
PAERO2	PID	ORIENT	WIDTH	AR	LRSB	LRIB	LTH1	LTH2
THI1	THN1	THI2	THN2	THI3	THN3

Creates a PAERO2 card, which defines additional cross-sectional properties for the CAERO2 geometry.

Parameters:

pid : int

PAERO1 id

orient : str

Orientation flag. Type of motion allowed for bodies. Refers to the aerodynamic coordinate system of ACSID. See AERO entry. valid_orientations = {Z, Y, ZY}

width : float

Reference half-width of body and the width of the constant width interference tube

AR : float

Aspect ratio of the interference tube (height/width)

thi / thn : List[int]

The first (thi) and last (thn) interference element of a body to use the theta1/theta2 array

lrsb : int; default=None

int : AEFACT id containing a list of slender body half-widths

at the end points of the slender body elements

None : use width

lrib : int; default=None

int : AEFACT id containing a list of interference body

half-widths at the end points of the interference elements

None : use width

lth : List[int, int]; default=None

AEFACT id for defining theta arrays for interference calculations for theta1/theta2

comment : str; default=’‘

a comment for the card

AR = None

Aspect ratio of the interference tube (height/width). float>0.

Lrib(self)

AEFACT id

Lrsb(self)

AEFACT id

classmethod _init_from_empty()

_properties = ['_field_map', 'lth1', 'lth2']

classmethod add_card(card, comment='')

Adds a PAERO2 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

lrib = None

Identification number of an AEFACT entry containing a list of slender body half-widths at the end points of the interference elements. If blank, the value of WIDTH will be used. (Integer > 0 or blank)

lrsb = None

Identification number of an AEFACT entry containing a list of slender body half-widths at the end points of the slender body elements. If blank, the value of WIDTH will be used. (Integer > 0 or blank)

lth1

lth2

orient = None

Orientation flag. Type of motion allowed for bodies. Refers to the aerodynamic coordinate system of ACSID. See AERO entry. (Character = ‘Z’, ‘Y’, or ‘ZY’)

pid = None

Property identification number. (Integer > 0)

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list[varies]

the fields that define the card

safe_cross_reference(self, model, xref_errors)

type = 'PAERO2'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

width = None

Reference half-width of body and the width of the constant width interference tube. (Real > 0.0)

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.PAERO3(pid, nbox, ncontrol_surfaces, x, y, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines the number of Mach boxes in the flow direction and the location of cranks and control surfaces of a Mach box lifting surface.

1	2	3	4	5	6	7	8	9
PAERO3	PID	NBOX	NCTRL		X5	Y5	X6	Y6
	X7	Y7	X8	Y8	X9	Y9	X10	Y10
	X11	Y11	X12	Y12
PAERO3	2001	15	1
						97.5		97.5

Creates a PAERO3 card, which defines the number of Mach boxes in the flow direction and the location of cranks and control surfaces of a Mach box lifting surface.

Parameters:

pid : int

PAERO1 id

nbox : int

Number of Mach boxes in the flow direction; 0 < nbox < 50

ncontrol_surfaces : int

Number of control surfaces. (0, 1, or 2)

x / y : List[float, None]

float : locations of points 5 through 12, which are in the aerodynamic coordinate system, to define the cranks and control surface geometry.

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

_properties = ['npoints']

classmethod add_card(card, comment='')

Adds a PAERO3 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

npoints

pid = None

Property identification number. (Integer > 0)

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list[varies]

the fields that define the card

safe_cross_reference(self, model, unused_xref_errors)

type = 'PAERO3'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.PAERO4(pid, docs, caocs, gapocs, cla=0, lcla=0, circ=0, lcirc=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines properties of each strip element for Strip theory.

1	2	3	4	5	6	7	8	9
PAERO4	PID	CLA	LCLA	CIRC	LCIRC	DOC1	CAOC1	GAPOC1
	DOC2	CAOC2	GAPOC2	DOC3	CAOC3	GAPOC3	etc.
PAERO4	6001	1	501	0	0	0.0	0.0	0.0
	0.50	0.25	0.02	0.53	0.24	0.0

## TODO: what happens for DOC4?

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds a PAERO4 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

pid = None

Property identification number. (Integer > 0)

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list[varies]

the fields that define the card

safe_cross_reference(self, model, xref_errors)

type = 'PAERO4'

uncross_reference(self)

Removes cross-reference links

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.PAERO5(pid, caoci, nalpha=0, lalpha=0, nxis=0, lxis=0, ntaus=0, ltaus=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

1	2	3	4	5	6	7	8
PAERO5	PID	NALPHA	LALPHA	NXIS	LXIS	NTAUS	LTAUS
	CAOC1	CAOC2	CAOC3	CAOC4	CAOC5
PAERO5	7001	1	702	1	701	1	700
	0.0	0.0	5.25	3.99375	0.0

classmethod _init_from_empty()

_properties = ['ltaus_id', 'lxis_id']

classmethod add_card(card, comment='')

Adds a PAERO5 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

ltaus_id

lxis_id

raw_fields(self)

safe_cross_reference(self, model, xref_errors)

type = 'PAERO5'

uncross_reference(self)

Removes cross-reference links

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.SPLINE1(eid, caero, box1, box2, setg, dz=0.0, method='IPS', usage='BOTH', nelements=10, melements=10, comment='')

Bases: pyNastran.bdf.cards.aero.aero.Spline

Surface Spline Methods Defines a surface spline for interpolating motion and/or forces for aeroelastic problems on aerodynamic geometries defined by regular arrays of aerodynamic points.

1	2	3	4	5	6	7	8	9
SPLINE1	EID	CAERO	BOX1	BOX2	SETG	DZ	METH	USAGE
	NELEM	MELEM
SPLINE1	3	111	115	122	14

Creates a SPLINE1, which defines a surface spline.

Parameters:

eid : int

spline id

caero : int

CAEROx id that defines the plane of the spline

box1 / box2 : int

First/last box id that is used by the spline

setg : int

SETx id that defines the list of GRID points that are used by the surface spline

dz : float; default=0.0

linear attachment flexibility dz = 0.; spline passes through all grid points

method : str; default=IPS

method for spline fit valid_methods = {IPS, TPS, FPS} IPS : Harder-Desmarais Infinite Plate Spline TPS : Thin Plate Spline FPS : Finite Plate Spline

usage : str; default=BOTH

Spline usage flag to determine whether this spline applies to the force transformation, displacement transformation, or both valid_usage = {FORCE, DISP, BOTH}

nelements : int; default=10

The number of FE elements along the local spline x-axis if using the FPS option

melements : int; default=10

The number of FE elements along the local spline y-axis if using the FPS option

comment : str; default=’‘

a comment for the card

CAero(self)

Set(self)

classmethod _init_from_empty()

_properties = ['aero_element_ids']

classmethod add_card(card, comment='')

Adds a SPLINE1 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

aero_element_ids

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list[varies]

the fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : List[varies]

the fields that define the card

safe_cross_reference(self, model, xref_errors)

type = 'SPLINE1'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.SPLINE2(eid, caero, box1, box2, setg, dz=0.0, dtor=1.0, cid=0, dthx=0.0, dthy=0.0, usage='BOTH', comment='')

Bases: pyNastran.bdf.cards.aero.aero.Spline

Linear Spline Defines a beam spline for interpolating motion and/or forces for aeroelastic problems on aerodynamic geometries defined by regular arrays of aerodynamic points.

1	2	3	4	5	6	7	8	9
SPLINE2	EID	CAERO	ID1	ID2	SETG	DZ	DTOR	CID
	DTHX	DTHY	None	USAGE
SPLINE2	5	8	12	24	60		1.0	3

Creates a SPLINE2 card, which defines a beam spline.

Parameters:

eid : int

spline id

caero : int

CAEROx id that defines the plane of the spline

box1 / box2 : int

First/last box/body id that is used by the spline

setg : int

SETx id that defines the list of GRID points that are used by the beam spline

dz : float; default=0.0

linear attachment flexibility dz = 0.; spline passes through all grid points

dtor : float; default=1.0

Torsional flexibility ratio (EI/GJ). Use 1.0 for bodies (CAERO2).

cid : int; default=0

Rectangular coordinate system for which the y-axis defines the axis of the spline. Not used for bodies, CAERO2

dthx : float; default=0.

Rotational attachment flexibility. DTHX : Used for rotation about the spline’s x-axis (in-plane

bending rotations). It is not used for bodies (CAERO2).

DTHY : Used for rotation about the spline’s y-axis (torsion).

It is used for slope of bodies.

usage : str; default=BOTH

Spline usage flag to determine whether this spline applies to the force transformation, displacement transformation, or both valid_usage = {FORCE, DISP, BOTH}

comment : str; default=’‘

a comment for the card

CAero(self)

Cid(self)

Set(self)

classmethod _init_from_empty()

_properties = ['aero_element_ids']

classmethod add_card(card, comment='')

Adds a SPLINE2 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

aero_element_ids

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list[varies]

the fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : List[varies]

the fields that define the card

safe_cross_reference(self, model, xref_errors)

type = 'SPLINE2'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.SPLINE3(eid, caero, box_id, components, nodes, displacement_components, coeffs, usage='BOTH', comment='')

Bases: pyNastran.bdf.cards.aero.aero.Spline

Defines a constraint equation for aeroelastic problems. Useful for control surface constraints.

1	2	3	4	5	6	7	8	9
SPLINE3	EID	CAERO	BOXID	COMP	G1	C1	A1	USAGE
	G2	C2	A2		G3	C3	A2
	G4	C4	A4	etc.
SPLINE3	7000	107	109	6	5	3	1.0	BOTH
	43	5	-1.0

Creates a SPLINE3 card, which is useful for control surface constraints.

Parameters:

eid : int

spline id

caero : int

CAEROx id that defines the plane of the spline

box_id : int

Identification number of the aerodynamic box number.

components : int

The component of motion to be interpolated. 3, 5 (CAERO1) 2, 3, 5, 6 (CAERO2) 3 (CAERO3) 3, 5, 6 (CAERO4) 3, 5, 6 (CAERO5) 1, 2, 3, 5, 6 (3D Geometry) 2-lateral displacement 3-transverse displacement 5-pitch angle 6-relative control angle for CAERO4/5; yaw angle for CAERO2

nodes : List[int]

Grid point identification number of the independent grid point.

displacement_components

Component numbers in the displacement coordinate system. 1-6 (GRIDs) 0 (SPOINTs)

coeffs

Coefficient of the constraint relationship.

usage : str; default=BOTH

Spline usage flag to determine whether this spline applies to the force transformation, displacement transformation, or both valid_usage = {FORCE, DISP, BOTH}

comment : str; default=’‘

a comment for the card

CAero(self)

classmethod _init_from_empty()

_properties = ['node_ids']

classmethod add_card(card, comment='')

Adds a SPLINE3 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

node_ids

raw_fields(self)

1	2	3	4	5	6	7	8	9
SPLINE3	EID	CAERO	BOXID	COMP	G1	C1	A1	USAGE
	G2	C2	A2		G3	C3	A2	—
	G4	C4	A4	etc.

safe_cross_reference(self, model, xref_errors)

type = 'SPLINE3'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.SPLINE4(eid, caero, aelist, setg, dz, method, usage, nelements, melements, comment='')

Bases: pyNastran.bdf.cards.aero.aero.Spline

Surface Spline Methods Defines a curved surface spline for interpolating motion and/or forces for aeroelastic problems on general aerodynamic geometries using either the Infinite Plate, Thin Plate or Finite Plate splining method.

1	2	3	4	5	6	7	8	9
SPLINE4	EID	CAERO	AELIST		SETG	DZ	METH	USAGE
	NELEM	MELEM
SPLINE4	3	111	115		14		IPS

Creates a SPLINE4 card, which defines a curved Infinite Plate, Thin Plate, or Finite Plate Spline.

Parameters:

eid : int

spline id

caero : int

CAEROx id that defines the plane of the spline

box1 / box2 : int

First/last box id that is used by the spline

setg : int

SETx id that defines the list of GRID points that are used by the surface spline

dz : float; default=0.0

linear attachment flexibility dz = 0.; spline passes through all grid points

method : str; default=IPS

method for spline fit valid_methods = {IPS, TPS, FPS} IPS : Harder-Desmarais Infinite Plate Spline TPS : Thin Plate Spline FPS : Finite Plate Spline

usage : str; default=BOTH

Spline usage flag to determine whether this spline applies to the force transformation, displacement transformation, or both valid_usage = {FORCE, DISP, BOTH}

nelements : int; default=10

The number of FE elements along the local spline x-axis if using the FPS option

melements : int; default=10

The number of FE elements along the local spline y-axis if using the FPS option

comment : str; default=’‘

a comment for the card

AEList(self)

CAero(self)

Set(self)

classmethod _init_from_empty()

_properties = ['aero_element_ids']

classmethod add_card(card, comment='')

Adds a SPLINE4 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

aero_element_ids

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list[varies]

the fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : List[varies]

the fields that define the card

safe_cross_reference(self, model, xref_errors)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

type = 'SPLINE4'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.SPLINE5(eid, caero, aelist, setg, thx, thy, dz=0.0, dtor=1.0, cid=0, usage='BOTH', method='BEAM', ftype='WF2', rcore=None, comment='')

Bases: pyNastran.bdf.cards.aero.aero.Spline

Linear Spline Defines a 1D beam spline for interpolating motion and/or forces for aeroelastic problems on aerodynamic geometries defined by irregular arrays of aerodynamic points. The interpolating beam supports axial rotation and bending in the yz-plane.

+=========+======+=======+========+=======+======+====+=======+=======+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +=========+======+=======+========+=======+======+====+=======+=======+ | SPLINE5 | EID | CAERO | AELIST | | SETG | DZ | DTOR | CID | +———+——+——-+——–+——-+——+—-+——-+——-+ | | DTHX | DTHY | | USAGE | METH | | FTYPE | RCORE | +———+——+——-+——–+——-+——+—-+——-+——-+

METH, FTYPE, RCORE are in 2012+ (not MSC.2005r2 or NX.10)

AEList(self)

CAero(self)

Cid(self)

Set(self)

classmethod _init_from_empty()

_properties = ['aero_element_ids']

classmethod add_card(card, comment='')

Adds a SPLINE5 card from BDF.add_card(...)

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

aero_element_ids

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

raw_fields(self)

Gets the fields in their unmodified form

Returns:

fields : list[varies]

the fields that define the card

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : List[varies]

the fields that define the card

safe_cross_reference(self, model, xref_errors)

type = 'SPLINE5'

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

write_card(self, size=8, is_double=False)

Writes the card with the specified width and precision

Parameters:

size : int (default=8)

size of the field; {8, 16}

is_double : bool (default=False)

is this card double precision

Returns:

msg : str

the string representation of the card

class pyNastran.bdf.cards.aero.aero.Spline

Bases: pyNastran.bdf.cards.base_card.BaseCard