bdfInterface Package

addCard Module

class pyNastran.bdf.bdfInterface.addCard.AddMethods

Bases: object

add_AEFACT(aefact, allowOverwrites=False)

add_AELINK(aelink)

add_AELIST(aelist)

add_AEPARM(aeparam)

add_AERO(aero)

add_AEROS(aero)

add_AESTAT(aestat)

add_AESURF(aesurf)

add_ASET(set_obj)

add_BCRPARA(card, allowOverwrites=False)

add_BCTADD(card, allowOverwrites=False)

add_BCTPARA(card, allowOverwrites=False)

add_BCTSET(card, allowOverwrites=False)

add_BSET(set_obj)

add_BSURF(card, allowOverwrites=False)

add_BSURFS(card, allowOverwrites=False)

add_CAERO(caero)

add_CSET(set_obj)

add_DAREA(darea, allowOverwrites=False)

add_DCONSTR(dconstr)

add_DDVAL(ddval)

add_DEQATN(deqatn, allowOverwrites=False)

add_DESVAR(desvar)

add_DLINK(dlink)

add_DMI(dmi, allowOverwrites=False)

add_DMIG(dmig, allowOverwrites=False)

add_DMIJ(dmij, allowOverwrites=False)

add_DMIJI(dmiji, allowOverwrites=False)

add_DMIK(dmik, allowOverwrites=False)

add_DRESP(dresp)

add_DVMREL(dvmrel)

add_DVPREL(dvprel)

add_FLFACT(flfact)

add_FLUTTER(flutter)

add_FREQ(freq)

add_GUST(gust)

add_LSEQ(load)

add_MKAERO(mkaero)

add_NLPARM(nlparm)

add_NLPCI(nlpci)

add_PAERO(paero)

add_PARAM(param, allowOverwrites=False)

add_PBUSHT(prop, allowOverwrites=False)

add_PDAMPT(prop, allowOverwrites=False)

add_PELAST(prop, allowOverwrites=False)

add_PHBDY(prop)

add_QSET(set_obj)

add_SESET(set_obj)

add_SET(set_obj)

add_SPLINE(spline)

add_SPOINT(spoint)

add_TRIM(trim, allowOverwrites=False)

add_TSTEP(tstep, allowOverwrites=False)

add_TSTEPNL(tstepnl, allowOverwrites=False)

add_cmethod(cMethod, allowOverwrites=False)

add_constraint(constraint)

add_constraint_MPC(constraint)

add_constraint_MPCADD(constraint)

add_constraint_SPC(constraint)

add_constraint_SPCADD(constraint)

add_convection_property(prop)

add_coord(coord, allowOverwrites=False)

add_creep_material(material, allowOverwrites=False)

Note

May be removed in the future. Are CREEP cards materials? They have an MID, but reference structural materials.

add_damper(elem, allowOverwrites=False)

Warning

can dampers have the same ID as a standard element?

add_dload(dload)

add_dload_entry(dload)

add_element(elem, allowOverwrites=False)

add_hyperelastic_material(material, allowOverwrites=False)

add_load(load)

add_mass(mass, allowOverwrites=False)

add_material_dependence(material, allowOverwrites=False)

add_method(method, allowOverwrites=False)

add_node(node, allowOverwrites=False)

add_property(prop, allowOverwrites=False)

add_property_mass(prop, allowOverwrites=False)

add_random_table(table)

add_rigid_element(elem, allowOverwrites=False)

add_structural_material(material, allowOverwrites=False)

add_suport(suport)

add_table(table)

add_thermal_BC(bc, key)

add_thermal_element(elem)

same as add_element at the moment...

add_thermal_load(load)

add_thermal_material(material, allowOverwrites=False)

assign_type Module

pyNastran.bdf.bdfInterface.assign_type._get_dtype(value)

Get the type of the input value in a form that is clear.

Parameters:value – the value to get the type of

pyNastran.bdf.bdfInterface.assign_type.blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

pyNastran.bdf.bdfInterface.assign_type.components(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field

pyNastran.bdf.bdfInterface.assign_type.components_or_blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

pyNastran.bdf.bdfInterface.assign_type.double(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field

pyNastran.bdf.bdfInterface.assign_type.double_or_blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

pyNastran.bdf.bdfInterface.assign_type.double_or_string(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field

pyNastran.bdf.bdfInterface.assign_type.double_string_or_blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

Returns value:

a double, string, or default value

Raises SyntaxError:  

if there is an invalid type

pyNastran.bdf.bdfInterface.assign_type.field(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field

pyNastran.bdf.bdfInterface.assign_type.fields(f, card, fieldname, i, j=None)

Todo

improve fieldname

pyNastran.bdf.bdfInterface.assign_type.integer(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field

pyNastran.bdf.bdfInterface.assign_type.integer_double_or_blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

pyNastran.bdf.bdfInterface.assign_type.integer_double_or_string(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field

pyNastran.bdf.bdfInterface.assign_type.integer_double_string_or_blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

pyNastran.bdf.bdfInterface.assign_type.integer_or_blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

pyNastran.bdf.bdfInterface.assign_type.integer_or_double(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field

Returns value:

the value with the proper type

Raises SyntaxError:  

if there’s an invalid type

pyNastran.bdf.bdfInterface.assign_type.integer_or_string(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

pyNastran.bdf.bdfInterface.assign_type.integer_string_or_blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

pyNastran.bdf.bdfInterface.assign_type.interpret_value(value_raw, card='')

Converts a value from nastran format into python format.

pyNastran.bdf.bdfInterface.assign_type.string(card, ifield, fieldname)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field

pyNastran.bdf.bdfInterface.assign_type.string_or_blank(card, ifield, fieldname, default=None)

Parameters:

• card – BDF card as a list
• ifield – field number
• fieldname – name of field
• default – the default value for the field (default=None)

BDF_Card Module

class pyNastran.bdf.bdfInterface.BDF_Card.BDFCard(card=None, debug=False)

Bases: object

field(i, default=None)

Gets the ith field on the card

Parameters:

• self – the object pointer
• i (integer) – the ith field on the card (following list notation)
• default – the default value for the field

Returns value:

the value on the ith field

fields(i=0, j=None, defaults=None)

Gets multiple fields on the card

Parameters:

• self – the object pointer
• i (integer >= 0) – the ith field on the card (following list notation)
• j (integer or None (default=end of card)) – the jth field on the card (None means till the end of the card)
• defaults – the default value for the field (as a list) len(defaults)=i-j-1

Returns value:

the values on the ith-jth fields

index(i)

nFields()

Gets how many fields are on the card

Parameters:self – the object pointer Returns nfields:  the number of fields on the card

pop()

Pops the last value off

bdf_writeMesh Module

This file defines:

• WriteMesh

class pyNastran.bdf.bdfInterface.bdf_writeMesh.WriteMesh

Bases: object

Major methods:

• model.write_bdf(...)
• model.echo_bdf(...)
• model.auto_reject_bdf(...)

_output_helper(out_filename, interspersed, size, is_double)

Performs type checking on the write_bdf inputs

_write_aero(outfile, size=8, is_double=False)

Writes the aero cards

_write_aero_control(outfile, size=8, is_double=False)

Writes the aero control surface cards

_write_case_control_deck(outfile)

Writes the Case Control Deck.

Parameters:self – the BDF object

_write_common(outfile, size=8, is_double=False)

Write the common outputs so none get missed...

Parameters:self – the BDF object Returns msg:part of the bdf

_write_constraints(outfile, size=8, is_double=False)

Writes the constraint cards sorted by ID

_write_contact(outfile, size=8, is_double=False)

Writes the contact cards sorted by ID

_write_coords(outfile, size=8, is_double=False)

Writes the coordinate cards in a sorted order

_write_dmigs(outfile, size=8, is_double=False)

Writes the DMIG cards

Parameters:

• self – the BDF object
• size – large field (16) or small field (8)

Returns msg:

string representation of the DMIGs

_write_dynamic(outfile, size=8, is_double=False)

Writes the dynamic cards sorted by ID

_write_elements(outfile, size=8, is_double=False)

Writes the elements in a sorted order

Parameters:self – the BDF object

_write_elements_properties(outfile, size=8, is_double=False)

Writes the elements and properties in and interspersed order

_write_executive_control_deck(outfile)

Writes the executive control deck.

Parameters:self – the BDF object

_write_flutter(outfile, size=8, is_double=False)

Writes the flutter cards

_write_header(outfile)

Writes the executive and case control decks.

Parameters:self – the BDF object

_write_loads(outfile, size=8, is_double=False)

Writes the load cards sorted by ID

_write_masses(outfile, size=8, is_double=False)

_write_materials(outfile, size=8, is_double=False)

Writes the materials in a sorted order

_write_nodes(outfile, size=8, is_double=False)

Writes the NODE-type cards

Parameters:self – the BDF object

_write_optimization(outfile, size=8, is_double=False)

Writes the optimization cards sorted by ID

_write_params(outfile, size=8, is_double=False)

Writes the PARAM cards

Parameters:self – the BDF object

_write_properties(outfile, size=8, is_double=False)

Writes the properties in a sorted order

_write_rejects(outfile, size=8, is_double=False)

Writes the rejected (processed) cards and the rejected unprocessed cardLines

_write_rigid_elements(outfile, size=8, is_double=False)

Writes the rigid elements in a sorted order

_write_sets(outfile, size=8, is_double=False)

Writes the SETx cards sorted by ID

_write_tables(outfile, size=8, is_double=False)

Writes the TABLEx cards sorted by ID

_write_thermal(outfile, size=8, is_double=False)

Writes the thermal cards

_write_thermal_materials(outfile, size=8, is_double=False)

Writes the thermal materials in a sorted order

auto_reject_bdf(infile_name)

This method parses supported cards, but does not group them into nodes, elements, properties, etc.

Todo

maybe add the write method

echo_bdf(infile_name)

This method removes all comment lines from the bdf A write method is stil required.

Todo

maybe add the write method

write_bdf(out_filename=None, size=8, is_double=False, interspersed=True, enddata=None)

Writes the BDF.

Parameters:

• self – the BDF object
• out_filename – the name to call the output bdf (default=None; pops a dialog)
• size – the field size (8 is recommended)
• is_double – small field (False) or large field (True); default=False
• interspersed – Writes a bdf with properties & elements interspersed like how Patran writes the bdf. This takes slightly longer than if interspersed=False, but makes it much easier to compare to a Patran-formatted bdf and is more clear. (default=True)
• enddata – Flag to enable/disable writing ENDDATA (default=None -> depends on input BDF)

crossReference Module

Links up the various cards in the BDF.

For example, with cross referencing...

>>> model = BDF()
>>> model.read_bdf(bdf_filename, xref=True)

>>> nid1 = 1
>>> node1 = model.nodes[nid1]
>>> node.nid
1

>>> node.xyz
[1., 2., 3.]

>>> node.Cid()
3

>>> node.cid
CORD2S, 3, 1, 0., 0., 0., 0., 0., 1.,
        1., 0., 0.
# get the position in the global frame
>>> node.Position()
[4., 5., 6.]

# get the position with respect to another frame
>>> node.PositionWRT(model, cid=2)
[4., 5., 6.]

Without cross referencing...

>>> model = BDF()
>>> model.read_bdf(bdf_filename, xref=True)

>>> nid1 = 1
>>> node1 = model.nodes[nid1]
>>> node.nid
1

>>> node.xyz
[1., 2., 3.]

>>> node.Cid()
3

>>> node.cid
3

# get the position in the global frame
>>> node.Position()
Error!

Cross-referencing allows you to easily jump across cards and also helps with calculating things like position, area, and mass. The BDF is designed around the idea of cross-referencing, so it’s recommended that you use it.

class pyNastran.bdf.bdfInterface.crossReference.XrefMesh

Bases: object

Links up the various cards in the BDF.

The main BDF class defines all the parameters that are used.

_cross_reference_aero()

Links up all the aero cards

_cross_reference_constraints()

Links the SPCADD, SPC, SPCAX, SPCD, MPCADD, MPC cards.

_cross_reference_coordinates()

Links up all the coordinate cards to other coordinate cards and nodes

_cross_reference_elements()

Links the elements to nodes, properties (and materials depending on the card).

_cross_reference_loads()

Links the loads to nodes, coordinate systems, and other loads.

_cross_reference_masses()

Links the mass to nodes, properties (and materials depending on the card).

_cross_reference_materials()

Links the materials to materials (e.g. MAT1, CREEP) often this is a pass statement

_cross_reference_nodes()

Links the nodes to coordinate systems

_cross_reference_properties()

Links the properties to materials

cross_reference(xref=True, xref_elements=True, xref_properties=True, xref_materials=True, xref_loads=True, xref_constraints=True, xref_aero=True)

Links up all the cards to the cards they reference

Parameters:

• xref – cross references the model (default=True)
• xref_element – set cross referencing of elements (default=True)
• xref_properties – set cross referencing of properties (default=True)
• xref_materials – set cross referencing of materials (default=True)
• xref_loads – set cross referencing of loads (default=True)
• xref_constraints – set cross referencing of constraints (default=True)
• xref_aero – set cross referencing of CAERO/SPLINEs (default=True)

To only cross-reference nodes:

model = BDF()
model.read_bdf(bdf_filename, xref=False)
model.cross_reference(xref=True, xref_loads=False, xref_constraints=False,
                                 xref_materials=False, xref_properties=False,
                                 xref_aero=False, xref_masses=False)

Warning

be careful if you call this method

getCard Module

class pyNastran.bdf.bdfInterface.getCard.GetMethods

Bases: pyNastran.bdf.deprecated.GetMethodsDeprecated

AEFact(aefact, msg=u'')

AELink(linkID, msg=u'')

AEList(aelist, msg=u'')

AEParam(aid, msg=u'')

AEStat(aid, msg=u'')

Aero(acsid, msg=u'')

Aeros(acsid, msg=u'')

CAero(eid, msg=u'')

CMethod(sid, msg=u'')

Coord(cid, msg=u'')

DConstr(oid, msg=u'')

DDVal(oid, msg=u'')

DLoad(sid, msg=u'')

DMIG(dname, msg=u'')

Desvar(oid, msg=u'')

Element(eid, msg=u'')

Elements(eids, msg=u'')

FLFACT(sid, msg=u'')

Flutter(fid, msg=u'')

Gust(sid, msg=u'')

HyperelasticMaterial(mid, msg=u'')

Load(sid, msg=u'')

Mass(eid, msg=u'')

Material(mid, msg=u'')

Materials(mids, msg=u'')

Method(sid, msg=u'')

NLParm(nid, msg=u'')

Node(nid, allowEmptyNodes=False, msg=u'')

Nodes(nids, allowEmptyNodes=False, msg=u'')

Returns a series of node objects given a list of node IDs

PAero(pid, msg=u'')

Phbdy(pid, msg=u'')

Properties(pids, msg=u'')

Property(pid, msg=u'')

PropertyMass(pid, msg=u'')

RandomTable(tid, msg=u'')

RigidElement(eid, msg=u'')

SPC(conid, msg=u'')

Set(sid, msg=u'')

SetSuper(seid, msg=u'')

Spline(eid, msg=u'')

StructuralMaterial(mid, msg=u'')

Table(tid, msg=u'')

ThermalMaterial(mid, msg=u'')

_GetMethods__test_method()

get_dload_entries(sid, msg=u'')

get_element_ids_dict_with_pids(pids)

Gets all the element IDs with a specific property ID.

Parameters:

• self – the BDF object
• pids – list of property ID

Returns element_ids:  

as a dictionary of lists by property

For example, we want all the elements with pids=[4, 5, 6], but we want them in separate groups

model = BDF()
model.read_bdf(bdf_filename)
pids = [4, 5, 6]
eids_dict = model.get_element_ids_with_pids(pids, mode='dict')

get_element_ids_list_with_pids(pids)

Gets all the element IDs with a specific property ID.

Parameters:

• self – the BDF object
• pids – list of property ID

Returns element_ids:  

as a list

For example, we want to get all the element ids with pids=[1, 2, 3]

model = BDF()
model.read_bdf(bdf_filename)
pids = [1, 2, 3]
eids_list = model.get_element_ids_with_pids(pids, mode='list')

get_material_id_to_property_ids_map()

Returns a dictionary that maps a material ID to a list of properties

Returns mid_to_pids_map:  the mapping

>>> mid_to_pid_map = get_material_id_to_property_ids_map()
>>> mid = 1
>>> pids = get_material_id_to_property_ids_map[mid]
>>> pids
[1, 2, 3]

Note

all properties require an mid to be counted (except for PCOMP, which has multiple mids)

get_material_ids()

get_node_id_to_element_ids_map()

Returns a dictionary that maps a node ID to a list of elemnents

Todo

support 0d or 1d elements

Todo

support elements with missing nodes (e.g. CQUAD8 with missing nodes)

get_node_ids_with_element(eid, msg=u'')

get_node_ids_with_elements(eids, msg=u'')

Get the node IDs associated with a list of element IDs

Parameters:

• self – the BDF object
• eids – list of element ID
• msg – a additional message to print out if an element is not found

Returns node_ids:  

set of node IDs

For example

>>> eids = [1, 2, 3]  # list of elements with pid=1
>>> msg = ' which are required for pid=1'
>>> node_ids = bdf.get_node_ids_with_elements(eids, msg=msg)

get_property_id_to_element_ids_map()

Returns a dictionary that maps a property ID to a list of elemnents

get_structural_material_ids()

get_thermal_material_ids()

get_x_associated_with_y(xdict, xkeys, ykeys, stop_on_failure=True)

Get the range of sub-properties of a card.

Note

Assumes you’re taking a single path through the cards. You could probably explicitly code these queries faster, but this method has a lot of flexibility with very little user code.

Parameters:

• self – the BDF object
• xdict – the BDF attribute that should be querried (e.g. self.elements)
• xkeys – the list of object keys that should be stepped through associated with xdict (e.g. eids=[1, 2, 3])
• ykeys – the list of response keys that should be stepped through (e.g. [‘pid’, ‘mid’, ‘mid’])
• stop_on_failure – Should an error be raised if there is an invalid key? For example, get all material used by elements, but don’t crash on CONRODs.

Returns results:  

The set of all values used

# Get nodes associated with eid=[1, 2, 3]
nodes = self.get_x_associated_with_y(
    self.elements, [1, 2, 3], ['nodes'])

# Get node IDs associated with eid=[1, 2, 3]
nodesIDs = self.get_x_associated_with_y(
    self.elements, [1, 2, 3], ['nodes', 'nid'])

# Get coord IDs associated with eid=[1, 2, 3]
coordIDs = self.get_x_associated_with_y(
    self.elements, [1, 2, 3], ['nodes', 'cp', 'cid'])

# Get properties associated with eid=[1, 2, 3]
properties = self.get_x_associated_with_y(
    self.elements, [1, 2, 3], ['pid'])

# Get materials associated with eid=[1, 2, 3]
materials = self.get_x_associated_with_y(
    self.elements, [1, 2, 3], ['pid', 'mid'])

# Get material IDs associated with eid=[1, 2, 3]
materialIDs = self.get_x_associated_with_y(
    self.elements, [1, 2, 3], ['pid', 'mid', 'mid'])

# Get the values for Young's Modulus
E = self.get_x_associated_with_y(
    self.elements, None, ['pid', 'mid', 'e'])

pyNastran.bdf.bdfInterface.getCard._getattr(out_set, xi, xkeys, nlevels_left=0, stop_on_failure=True)

Recursive method to help get_x_associated_with_y get the value of xkeys for the given variable xi

Parameters:

• out_set (SET) – the SET of all outputs that will be filled and implicitly returned
• xi (BDF BaseCard) – the current variable being iterated over
• xkeys (LIST of STRINGS) – the variables left to iterate over
• nlevels_left (INT >= 0) – the number of levels still to iterate over
• stop_on_failure (bool) – should the code crash if a certain xkey cannot be found