static_loads Module

All static loads are defined in this file. This includes:

• LOAD
• GRAV
• ACCEL
• ACCEL1
• FORCE / MOMENT
• FORCE1 / MOMENT1
• FORCE2 / MOMENT2
• MOMENT
• PLOAD
• PLOAD2
• PLOAD4
• PLOADX1

class pyNastran.bdf.cards.loads.static_loads.ACCEL(sid, N, direction, locs, vals, cid=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Acceleration Load

Defines static acceleration loads, which may vary over a region of the structural model. The load variation is based upon the tabular input defined on this Bulk Data entry.

1	2	3	4	5	6	7	8	9
ACCEL	SID	CID	N1	N2	N3	DIR
	LOC1	VAL1	LOC2	VAL2	Continues in Groups of 2
ACCEL	100	2	0.0	1.0	2.0 | X | |
	1.0	1.1	2.0	2.1	3.0	3.1	4.0	4.1

Creates an ACCEL card

Parameters:

sid : int

load id

N : (3, ) float ndarray

the acceleration vector in the cid frame

direction : str

Component direction of acceleration variation {X, Y, Z}

locs : List[float]

Location along direction DIR in coordinate system CID for specification of a load scale factor.

vals : List[float]

The load scale factor associated with location LOCi

cid : int; default=0

the coordinate system for the load

comment : str; default=’‘

a comment for the card

Cid(self)

N = None

Components of the acceleration vector measured in coordinate system CID. (Real; at least one Ni != 0)

classmethod _init_from_empty()

classmethod add_card(card, comment='')

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

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cid = None

Coordinate system identification number. (Integer>0: Default=0)

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

direction = None

Component direction of acceleration variation. (Character; one of X,Y or Z)

get_loads(self)

raw_fields(self)

safe_cross_reference(self, model, xref_errors, debug=True)

sid = None

Load set identification number (Integer>0)

type = 'ACCEL'

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.loads.static_loads.ACCEL1(sid, scale, N, nodes, cid=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Acceleration Load

Defines static acceleration loads at individual GRID points.

1	2	3	4	5	6	7
ACCEL1	SID	CID	A	N1	N2	N3
	GRIDID1	GRIDID2	etc

Creates an ACCEL1 card

Parameters:

sid : int

load id

scale : float

scale factor for load

N : (3, ) float ndarray

the acceleration vector in the cid frame

direction : str

Component direction of acceleration variation {X, Y, Z}

nodes : List[int]

the nodes to apply acceleration to

cid : int; default=0

the coordinate system for the load

comment : str; default=’‘

a comment for the card

Cid(self)

N = None

Components of the acceleration vector measured in coordinate system CID. (Real; at least one Ni != 0)

classmethod _init_from_empty()

_properties = ['node_ids']

classmethod add_card(card, comment='')

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

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cid = None

Coordinate system identification number. (Integer>0: Default=0)

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

get_loads(self)

node_ids

nodes = None

nodes to apply the acceleration to

raw_fields(self)

safe_cross_reference(self, model, xref_errors)

scale = None

Acceleration vector scale factor. (Real)

sid = None

Load set identification number (Integer>0)

type = 'ACCEL1'

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.loads.static_loads.FORCE(sid, node, mag, xyz, cid=0, comment='')

Bases: pyNastran.bdf.cards.loads.static_loads.Load0

Defines a static concentrated force at a grid point by specifying a scale factor and a vector that determines the direction.

1	2	3	4	5	6	7	8
FORCE	SID	NODE	CID	MAG	FX	FY	FZ
FORCE	3	1

Creates a FORCE card

Parameters:

sid : int

load id

node : int

the node to apply the load to

mag : float

the load’s magnitude

xyz : (3, ) float ndarray

the load direction in the cid frame

cid : int; default=0

the coordinate system for the load

comment : str; default=’‘

a comment for the card

type = 'FORCE'

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.loads.static_loads.FORCE1(sid, node, mag, g1, g2, comment='')

Bases: pyNastran.bdf.cards.loads.static_loads.Load1

Defines a static concentrated force at a grid point by specification of a magnitude and two grid points that determine the direction.

1	2	3	4	5	6
FORCE1	SID	G	F	G1	G2
FORCE1	6	13	-2.93	16	13

Creates a FORCE1 card

Parameters:

sid : int

load id

node : int

the node to apply the load to

mag : float

the load’s magnitude

n1 / n2 : int / int

defines the load direction n = n2 - n1

comment : str; default=’‘

a comment for the card

type = 'FORCE1'

class pyNastran.bdf.cards.loads.static_loads.FORCE2(sid, node, mag, g1, g2, g3, g4, comment='')

Bases: pyNastran.bdf.cards.loads.static_loads.Load2

Defines a static concentrated force at a grid point by specification of a magnitude and four grid points that determine the direction.

1	2	3	4	5	6	7	8
FORCE2	SID	G	F	G1	G2	G3	G4

_properties = ['scaled_vector', 'node_id', 'node_ids']

type = 'FORCE2'

class pyNastran.bdf.cards.loads.static_loads.GMLOAD(sid, normal, entity, entity_id, method, load_magnitudes, cid=0, comment='')

Bases: pyNastran.bdf.cards.loads.loads.Load

Defines a static concentrated force at a grid point by specification of a magnitude and two grid points that determine the direction.

Creates a GMLOAD object

Cid(self)

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds a GMLOAD 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

get_loads(self)

raw_fields(self)

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 = 'GMLOAD'

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.loads.static_loads.GRAV(sid, scale, N, cid=0, mb=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines acceleration vectors for gravity or other acceleration loading.

1	2	3	4	5	6	7	8
GRAV	SID	CID	A	N1	N2	N3	MB
GRAV	1	3	32.2	0.0	0.0	-1.0

Creates an GRAV card

Parameters:

sid : int

load id

scale : float

scale factor for load

N : (3, ) float ndarray

the acceleration vector in the cid frame

cid : int; default=0

the coordinate system for the load

mb : int; default=0

???

comment : str; default=’‘

a comment for the card

Cid(self)

GravityVector(self)

returns the gravity vector in absolute coordinates

N = None

Acceleration vector components measured in coordinate system CID

classmethod _init_from_empty()

classmethod add_card(card, comment='')

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

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cid = None

Coordinate system identification number.

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

get_loads(self)

mb = None

Indicates whether the CID coordinate system is defined in the main Bulk Data Section (MB = -1) or the partitioned superelement Bulk Data Section (MB = 0). Coordinate systems referenced in the main Bulk Data Section are considered stationary with respect to the assembly basic coordinate system. See Remark 10. (Integer; Default = 0)

raw_fields(self)

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, debug=True)

scale = None

scale factor

sid = None

Set identification number

type = 'GRAV'

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.loads.static_loads.LOAD(sid, scale, scale_factors, load_ids, comment='')

Bases: pyNastran.bdf.cards.loads.loads.LoadCombination

1	2	3	4	5	6	7	8	9
LOAD	SID	S	S1	L1	S2	L2	S3	L3
	S4	L4	etc.
LOAD	101	-0.5	1.0	3	6.2	4

Creates a LOAD card

Parameters:

sid : int

load id

scale : float

overall scale factor

scale_factors : List[float]

individual scale factors (corresponds to load_ids)

load_ids : List[int]

individual load_ids (corresponds to scale_factors)

comment : str; default=’‘

a comment for the card

.. note:: MSC can handle self-referencing loads, NX cannot

classmethod _init_from_empty()

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

get_load_types(self)

Note

requires a cross referenced load

get_reduced_loads(self, resolve_load_card=False, filter_zero_scale_factors=False)

Get all load objects in a simplified form, which means all scale factors are already applied and only base objects (no LOAD cards) will be returned.

Parameters:

resolve_load_card : bool; default=False

Nastran requires that LOAD cards do not reference other load cards This feature can be enabled.

filter_zero_scale_factors : bool; default=False

Nastran does not filter loads with a 0.0 scale factor. So, if you have a 0.0 load, but are missing load ids, Nastran will throw a fatal error.

.. todo:: lots more object types to support

raw_fields(self)

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, debug=True)

type = 'LOAD'

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.loads.static_loads.Load0(sid, node, mag, xyz, cid=0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

common class for FORCE, MOMENT

Creates a FORCE/MOMENT card

Parameters:

sid : int

load id

node : int

the node to apply the load to

mag : float

the load’s magnitude

xyz : (3, ) float ndarray

the load direction in the cid frame

cid : int; default=0

the coordinate system for the load

comment : str; default=’‘

a comment for the card

Cid(self)

classmethod add_card(card, comment='')

Adds a FORCE/MOMENT 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

classmethod export_to_hdf5(h5_file, model, loads)

exports the loads in a vectorized way

get_loads(self)

node_id

raw_fields(self)

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, debug=True)

scaled_vector

to_global(self)

uncross_reference(self)

Removes cross-reference links

validate(self)

card checking method that should be overwritten

class pyNastran.bdf.cards.loads.static_loads.Load1(sid, node, mag, g1, g2, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

common class for FORCE1, MOMENT1

Creates a FORCE1/MOMENT1 card

Parameters:

sid : int

load id

node : int

the node to apply the load to

mag : float

the load’s magnitude

n1 / n2 : int / int

defines the load direction n = n2 - n1

comment : str; default=’‘

a comment for the card

G1(self)

G2(self)

classmethod _init_from_empty()

_properties = ['node_id', 'node_ids', 'scaled_vector']

classmethod add_card(card, comment='')

Adds a FORCE1/MOMENT1 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

get_loads(self)

node_id

node_ids

raw_fields(self)

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, safe_coord, debug=True)

Todo

cross reference and fix repr function

scaled_vector

to_global(self)

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.loads.static_loads.Load2(sid, node, mag, g1, g2, g3, g4, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

common class for FORCE2, MOMENT2

Creates a FORCE2/MOMENT2 card

Parameters:

sid : int

load id

node : int

the node to apply the load to

mag : float

the load’s magnitude

g1 / g2 / g3 / g4 : int / int / int / int

defines the load direction n = (g2 - g1) x (g4 - g3)

comment : str; default=’‘

a comment for the card

G1(self)

G2(self)

G3(self)

G4(self)

classmethod _init_from_empty()

_properties = ['node_id', 'node_ids']

classmethod add_card(card, comment='')

Adds a FORCE2/MOMENT2 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

get_loads(self)

node_id

node_ids

raw_fields(self)

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, safe_coord, debug=True)

Todo

cross reference and fix repr function

scaled_vector

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.loads.static_loads.MOMENT(sid, node, mag, xyz, cid=0, comment='')

Bases: pyNastran.bdf.cards.loads.static_loads.Load0

Defines a static concentrated moment at a grid point by specifying a scale factor and a vector that determines the direction.

1	2	3	4	5	6	7	8
MOMENT	SID	G	CID	M	N1	N2	N3
MOMENT	2	5	6	2.9	0.0	1.0	0.0

Creates a MOMENT card

Parameters:

sid : int

load id

node : int

the node to apply the load to

mag : float

the load’s magnitude

xyz : (3, ) float ndarray

the load direction in the cid frame

cid : int; default=0

the coordinate system for the load

comment : str; default=’‘

a comment for the card

node_id

node_ids

all the nodes referenced by the load

raw_fields(self)

repr_fields(self)

Gets the fields in their simplified form

Returns:

fields : List[varies]

the fields that define the card

type = 'MOMENT'

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.loads.static_loads.MOMENT1(sid, node, mag, g1, g2, comment='')

Bases: pyNastran.bdf.cards.loads.static_loads.Load1

Defines a static concentrated moment at a grid point by specifying a magnitude and two grid points that determine the direction.

1	2	3	4	5	6
MOMENT1	SID	G	M	G1	G2
MOMENT1	6	13	-2.93	16	13

Creates a MOMENT1 card

Parameters:

sid : int

load id

node : int

the node to apply the load to

mag : float

the load’s magnitude

n1 / n2 : int / int

defines the load direction n = n2 - n1

comment : str; default=’‘

a comment for the card

type = 'MOMENT1'

class pyNastran.bdf.cards.loads.static_loads.MOMENT2(sid, node, mag, g1, g2, g3, g4, comment='')

Bases: pyNastran.bdf.cards.loads.static_loads.Load2

Defines a static concentrated moment at a grid point by specification of a magnitude and four grid points that determine the direction.

1	2	3	4	5	6	7	8
MOMENT2	SID	G	M	G1	G2	G3	G4

_properties = ['scaled_vector', 'node_id', 'node_ids']

type = 'MOMENT2'

class pyNastran.bdf.cards.loads.static_loads.PLOAD(sid, pressure, nodes, comment='')

Bases: pyNastran.bdf.cards.loads.loads.Load

Static Pressure Load

Defines a uniform static pressure load on a triangular or quadrilateral surface comprised of surface elements and/or the faces of solid elements.

1	2	3	4	5	6	7
PLOAD	SID	P	G1	G2	G3	G4
PLOAD	1	-4.0	16	32	11

Creates a PLOAD card, which defines a uniform pressure load on a shell/solid face or arbitrarily defined quad/tri face.

Parameters:

sid : int

load id

pressure : float

the pressure to apply

nodes : List[int]

The nodes that are used to define the normal are defined using the same method as the CTRIA3/CQUAD4 normal. n = 3 or 4

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

_properties = ['node_ids']

classmethod add_card(card, comment='')

Adds a PLOAD 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

get_loads(self)

raw_fields(self)

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, safe_coord)

type = 'PLOAD'

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.loads.static_loads.PLOAD1(sid, eid, load_type, scale, x1, p1, x2=None, p2=None, comment='')

Bases: pyNastran.bdf.cards.loads.loads.Load

Applied Load on CBAR, CBEAM or CBEND Elements

Defines concentrated, uniformly distributed, or linearly distributed applied loads to the CBAR or CBEAM elements at user-chosen points along the axis. For the CBEND element, only distributed loads over an entire length may be defined.

1	2	3	4	5	6	7	8	9
PLOAD1	SID	EID	TYPE	SCALE	X1	P1	X2	P2
PLOAD1	25	1065	MY	FRPR	0.2	2.5E3	0.8	3.5E3

Creates a PLOAD1 card, which may be applied to a CBAR/CBEAM

Parameters:

sid : int

load id

eid : int

element to apply the load to

load_type : str

type of load that’s applied valid_types = {FX, FY, FZ, FXE, FYE, FZE,

MX, MY, MZ, MXE, MYE, MZE}

scale : str

Determines scale factor for X1, X2. {LE, FR, LEPR, FRPR}

x1 / x2 : float / float

the starting/end position for the load application the default for x2 is x1

p1 / p2 : float / float

the magnitude of the load at x1 and x2 the default for p2 is p1

comment : str; default=’‘

a comment for the card

Point Load : x1 == x2

Distributed Load : x1 != x2

Eid(self)

Type

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds a PLOAD1 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

get_loads(self)

raw_fields(self)

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, safe_coord)

type = 'PLOAD1'

uncross_reference(self)

Removes cross-reference links

valid_scales = ['LE', 'FR', 'LEPR', 'FRPR']

valid_types = ['FX', 'FY', 'FZ', 'FXE', 'FYE', 'FZE', 'MX', 'MY', 'MZ', 'MXE', 'MYE', 'MZE']

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.loads.static_loads.PLOAD2(sid, pressure, eids, comment='')

Bases: pyNastran.bdf.cards.loads.loads.Load

1	2	3	4	5	6 | 7		8	9
PLOAD2	SID	P	EID1	EID2	EID3 | EID4		EID5	EID6
PLOAD2	21	-3.6	4	16	2
PLOAD2	SID	P	EID1	THRU	EID2

Creates a PLOAD2 card, which defines an applied load normal to the quad/tri face

Parameters:

sid : int

load id

pressure : float

the pressure to apply to the elements

eids : List[int]

the elements to apply pressure to n < 6 or a continouus monotonic list of elements (e.g., [1, 2, …, 1000])

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

_properties = ['element_ids']

classmethod add_card(card, comment='')

Adds a PLOAD2 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

element_ids

get_loads(self)

raw_fields(self)

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, safe_coord)

type = 'PLOAD2'

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.loads.static_loads.PLOAD4(sid, eids, pressures, g1, g34, cid=0, nvector=None, surf_or_line='SURF', line_load_dir='NORM', comment='')

Bases: pyNastran.bdf.cards.loads.loads.Load

Solid Format

Defines a pressure load on a face of a CHEXA, CPENTA, or CTETRA element.

1	2	3	4	5	6	7	8	9
PLOAD4	SID	EID	P1	P2	P3	P4	G1	G3/G4
	CID	N1	N2	N3	SORL	LDIR

Shell Format

Defines a pressure load on a face of a CTRIA3, CTRIA6, CTRIAR, CQUAD4, CQUAD8, or CQUADR element.

1	2	3	4	5	6	7	8	9
PLOAD4	SID	EID	P1	P2	P3	P4	THRU	EID2
	CID	N1	N2	N3	SORL	LDIR

Warning

NX does not support SORL and LDIR, MSC does

Creates a PLOAD4 card

Parameters:

sid : int

the load id

eids : List[int, …]

shells : the range of element ids; must be sequential solids : must be length 1

pressures : List[float, float, float, float] / float

float : turned into a list of length 4 List[float] :

tri : must be length 4 (the last value should be the same as the 0th value) quad : must be length 4

g1 : int/None

only used for solid elements

g34 : int / None

only used for solid elements

cid : int; default=0

the coordinate system for nvector

nvector : (3, ) float ndarray

blank : load acts normal to the face float : the local pressure vector

surf_or_line : str; default=’SURF’

SURF : surface load LINE : line load (only defined for QUADR, TRIAR) not supported

line_load_dir : str; default=’NORM’

direction of the line load (see surf_or_line); {X, Y, Z, TANG, NORM} not supported

comment : str; default=’‘

a comment for the card

TODO: fix the way “pressures” works

Cid(self)

gets the coordinate system object

G1(self)

G34(self)

classmethod _init_from_empty()

_properties = ['node_ids', 'element_ids']

classmethod add_card(card, comment='')

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

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cid = None

Coordinate system identification number. See Remark 2. (Integer >= 0;Default=0)

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

element_ids

g1 = None

used for solid element only

g34 = None

g3/g4 - different depending on CHEXA/CPENTA or CTETRA

get_element_ids(self, eid=None)

get_loads(self)

node_ids

get the node ids

raw_fields(self)

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, debug=True)

type = 'PLOAD4'

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.loads.static_loads.PLOADX1(sid, eid, pa, nids, pb=None, theta=0.0, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Pressure Load on Axisymmetric Element

Defines surface traction to be used with the CQUADX, CTRIAX, and CTRIAX6 axisymmetric element.

1	2	3	4	5	6	7	8
PLOADX1	SID	EID	PA	PB	GA	GB	THETA

Creates a PLOADX1 card, which defines surface traction for axisymmetric elements.

Parameters:

sid : int

load id

eid : int

element id (CQUADX, CTRIAX, or CTRIAX6)

nids : List[int, int]

Corner grid points. GA and GB are any two adjacent corner grid points of the element

pa / pb : float / None

Surface traction at grid point GA or GB pb : default is None -> pa

theta : float; default=0.0

Angle between surface traction and inward normal to the line segment.

comment : str; default=’‘

a comment for the card

Eid(self)

Ga(self)

Gb(self)

classmethod _init_from_empty()

_properties = ['node_ids', 'nodes']

classmethod add_card(card, comment='')

Adds a PLOADX1 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

get_loads(self)

node_ids

nodes

nodes_ref

raw_fields(self)

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, safe_coord)

type = 'PLOADX1'

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)

pyNastran.bdf.cards.loads.static_loads.normalize(self, msg='')

adjust the vector to a unit length scale up the magnitude of the vector

pyNastran.bdf.cards.loads.static_loads.update_pload4_vector(pload4, normal, cid)

helper method