loads Module

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

• LSEQ
• DAREA
• SLOAD
• RFORCE
• RANDPS

class pyNastran.bdf.cards.loads.loads.DAREA(sid, nodes, components, scales, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines scale (area) factors for static and dynamic loads. In dynamic analysis, DAREA is used in conjunction with ACSRCE, RLOADi and TLOADi entries.

RLOAD1 -> DAREA by SID

1	2	3	4	5	6	7	8
DAREA	SID	P1	C1	A1	P2	C2	A2
DAREA	3	6	2	8.2	15	1	10.1

Creates a DAREA card

Parameters:

sid : int

darea id

nodes : List[int]

GRID, EPOINT, SPOINT id

components : List[int]

Component number. (0-6; 0-EPOINT/SPOINT; 1-6 GRID)

scales : List[float]

Scale (area) factor

comment : str; default=’‘

a comment for the card

classmethod _init_from_empty()

_properties = ['node_ids']

add(self, darea)

classmethod add_card(card, icard=0, comment='')

cross_reference(self, model)

Cross links the card so referenced cards can be extracted directly

Parameters:

model : BDF()

the BDF object

node_ids

raw_fields(self)

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

type = 'DAREA'

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.loads.DEFORM(sid, eid, deformation, comment='')

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

Defines an enforced displacement value for static analysis.

1	2	3	5	6	8	6	8
DEFORM	SID	E1	D1	E2	D2	E3	D3
DEFORM	100	32	-2.6	5	.9	6	.9

Creates an DEFORM card, which defines applied deformation on a 1D elemment. Links to the DEFORM card in the case control deck.

Parameters:

sid : int

load id

eid : int

CTUBE/CROD/CONROD/CBAR/CBEAM element id

deformation : float

the applied deformation

comment : str; default=’‘

a comment for the card

Eid(self)

classmethod _init_from_empty()

classmethod add_card(card, icard=0, comment='')

Adds a DEFORM 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)

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

type = 'DEFORM'

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.loads.DynamicLoad

Bases: pyNastran.bdf.cards.base_card.BaseCard

class pyNastran.bdf.cards.loads.loads.LOADCYN(sid, scale, segment_id, scales, load_ids, segment_type=None, comment='')

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

classmethod _init_from_empty()

classmethod add_card(card, comment='')

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

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

cross_reference(self, model)

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

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.loads.LSEQ(sid, excite_id, lid, tid=None, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Defines a sequence of static load sets

Todo

how does this work…

1	2	3	4	5
LSEQ	SID	EXCITEID	LID	TID

ACSRCE : If there is no LOADSET Case Control command, then EXCITEID

may reference DAREA and SLOAD entries. If there is a LOADSET Case Control command, then EXCITEID may reference DAREA entries as well as SLOAD entries specified by the LID field in the selected LSEQ entry corresponding to EXCITEID.

DAREA : Refer to RLOAD1, RLOAD2, TLOAD1, TLOAD2, or ACSRCE entries

for the formulas that define the scale factor Ai in dynamic analysis.

DPHASE :

SLOAD : In the static solution sequences, the load set ID (SID) is

selected by the Case Control command LOAD. In the dynamic solution sequences, SID must be referenced in the LID field of an LSEQ entry, which in turn must be selected by the Case Control command LOADSET.

LSEQ LID : Load set identification number of a set of static load

entries such as those referenced by the LOAD Case Control command.

LSEQ, SID, EXCITEID, LID, TID

#————————————————————– # F:Program FilesSiemensNXNastrannxn10p1nxn10p1nasttplcube_iter.dat

DLOAD 1001 1.0 1.0 55212 sid = 1001 load_id = [55212] -> RLOAD2.SID

RLOAD2, SID, EXCITEID, DELAYID, DPHASEID, TB, TP, TYPE RLOAD2 55212 55120 55122 55123 55124 EXCITEID = 55120 -> DAREA.SID DPHASEID = 55122 -> DPHASE.SID

DARA SID NID COMP SCALE DAREA 55120 913 3 9.9E+9 SID = 55120 -> RLOAD2.SID

DPHASE SID POINTID C1 TH1 DPHASE 55122 913 3 -90.0 SID = 55122 POINTID = 913 -> GRID.NID

GRID NID X Y Z GRID 913 50. 0.19 -39.9

Creates a LSEQ card

Parameters:

sid : int

loadset id; LOADSET points to this

excite_id : int

set id assigned to this static load vector

lid : int

load set id of a set of static load entries; LOAD in the Case Control

tid : int; default=None

temperature set id of a set of thermal load entries; TEMP(LOAD) in the Case Control

comment : str; default=’‘

a comment for the card

Lid(self)

LoadID(self, lid)

Tid(self)

classmethod _init_from_empty()

classmethod add_card(card, comment='')

Adds a LSEQ 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 = 'LSEQ'

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.loads.Load

Bases: pyNastran.bdf.cards.base_card.BaseCard

defines the DefaultLoad class

node_ids

get the node ids

type = 'DefLoad'

class pyNastran.bdf.cards.loads.loads.LoadCombination(sid, scale, scale_factors, load_ids, comment='')

Bases: pyNastran.bdf.cards.base_card.BaseCard

Common method for LOAD, DLOAD

Common method for LOAD, DLOAD

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

LoadID(self, lid)

classmethod add_card(card, comment='')

get_load_ids(self)

xref/non-xref way to get the load ids

get_loads(self)

Note

requires a cross referenced load

scale = None

overall scale factor

sid = None

load ID

validate(self)

card checking method that should be overwritten

class pyNastran.bdf.cards.loads.loads.RFORCE(sid, nid, scale, r123, cid=0, method=1, racc=0.0, mb=0, idrf=0, comment='')

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

idrf doesn’t exist in MSC 2005r2; exists in MSC 2016

Parameters:

sid : int

load set id

nid : int

grid point through which the rotation vector acts

scale : float

scale factor of the angular velocity in revolutions/time

r123 : List[float, float, float] / (3, ) float ndarray

rectangular components of the rotation vector R that passes through point G (R1**2+R2**2+R3**2 > 0 unless A and RACC are both zero).

cid : int; default=0

Coordinate system defining the components of the rotation vector.

method : int; default=1

Method used to compute centrifugal forces due to angular velocity.

racc : int; default=0.0

Scale factor of the angular acceleration in revolutions per unit time squared.

mb : int; default=0

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.

idrf : int; default=0

ID indicating to which portion of the structure this particular RFORCE entry applies. It is possible to have multiple RFORCE entries in the same subcase for SOL 600 to represent different portions of the structure with different rotational accelerations. IDRF corresponds to a SET3 entry specifying the elements with this acceleration. A BRKSQL entry may also be specified with a matching IDRF entry.

comment : str; default=’‘

a comment for the card

Cid(self)

Nid(self)

classmethod _init_from_empty()

_properties = ['node_id']

classmethod add_card(card, comment='')

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

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

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.loads.RFORCE1(sid, nid, scale, group_id, cid=0, r123=None, racc=0.0, mb=0, method=2, comment='')

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

NX Nastran specific card

1	2	3	4	5	6	7	8	9
RFORCE1	SID	G	CID	A	R1	R2	R3	METHOD
	RACC	MB	GROUPID

Creates an RFORCE1 card

Parameters:

sid : int

load set id

nid : int

grid point through which the rotation vector acts

scale : float

scale factor of the angular velocity in revolutions/time

r123 : List[float, float, float] / (3, ) float ndarray

rectangular components of the rotation vector R that passes through point G (R1**2+R2**2+R3**2 > 0 unless A and RACC are both zero).

racc : int; default=0.0

Scale factor of the angular acceleration in revolutions per unit time squared.

mb : int; default=0

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.

group_id : int

Group identification number. The GROUP entry referenced in the GROUPID field selects the grid points to which the load is applied.

cid : int; default=0

Coordinate system defining the components of the rotation vector.

method : int; default=2

Method used to compute centrifugal forces due to angular velocity.

comment : str; default=’‘

a comment for the card

Cid(self)

Nid(self)

classmethod _init_from_empty()

_properties = ['node_id']

classmethod add_card(card, comment='')

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

raw_fields(self)

safe_cross_reference(self, model, xref_errors)

type = 'RFORCE1'

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.loads.SLOAD(sid, nodes, mags, comment='')

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

Static Scalar Load Defines concentrated static loads on scalar or grid points.

1	2	3	4	5	6	7	8
SLOAD	SID	S1	F1	S2	F2	S3	F3
SLOAD	16	2	5.9	17	-6.3	14	-2.93

Note

Can be used in statics OR dynamics.

If Si refers to a grid point, the load is applied to component T1 of the displacement coordinate system (see the CD field on the GRID entry).

Creates an SLOAD (GRID/SPOINT load)

Parameters:

sid : int

load id

nodes : int; List[int]

the GRID/SPOINT ids

mags : float; List[float]

the load magnitude

comment : str; default=’‘

a comment for the card

Nid(self, node)

classmethod _init_from_empty()

_properties = ['node_ids']

classmethod add_card(card, comment='')

Adds a SLOAD 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)

Todo

not done

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)

sid = None

load ID

type = 'SLOAD'

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.loads.SPCD(sid, nodes, components, enforced, comment='')

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

Defines an enforced displacement value for static analysis and an enforced motion value (displacement, velocity or acceleration) in dynamic analysis.

1	2	3	4	5	6	7	8
SPCD	SID	G1	C1	D1	G2	C2	D2
SPCD	100	32	436	-2.6	5	2	.9

Creates an SPCD card, which defines the degree of freedoms to be set during enforced motion

Parameters:

conid : int

constraint id

nodes : List[int]

GRID/SPOINT ids

components : List[str]

the degree of freedoms to constrain (e.g., ‘1’, ‘123’)

enforced : List[float]

the constrained value for the given node (typically 0.0)

comment : str; default=’‘

a comment for the card

.. note:: len(nodes) == len(components) == len(enforced)

.. warning:: Non-zero enforced deflection requires an SPC/SPC1 as well.

Yes, you really want to constrain the deflection to 0.0 with an SPC1 card and then reset the deflection using an SPCD card.

classmethod _init_from_empty()

_properties = ['node_ids']

classmethod add_card(card, comment='')

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

Parameters:

card : BDFCard()

a BDFCard object

comment : str; default=’‘

a comment for the card

constraints

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

get the node ids

raw_fields(self)

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

type = 'SPCD'

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