cards Package

• base_card Package
  • base_card Module
    • BaseCard
      • BaseCard._is_same_fields_long()
      • BaseCard.add_card()
      • BaseCard.comment
      • BaseCard.get_field()
      • BaseCard.get_stats()
      • BaseCard.object_attributes()
      • BaseCard.object_methods()
      • BaseCard.print_card()
      • BaseCard.raw_fields()
      • BaseCard.repr_fields()
      • BaseCard.rstrip()
      • BaseCard.type
      • BaseCard.update_field()
      • BaseCard.validate()
      • BaseCard.write_card()
      • BaseCard.write_card_16()
    • Element
      • Element.Pid()
      • Element._verify_unique_node_ids()
      • Element.get_node_positions()
      • Element.get_node_positions_no_xref()
      • Element.pid
      • Element.prepare_node_ids()
      • Element.validate_node_ids()
      • Element.verify_unique_node_ids()
    • Material
      • Material.Mid()
      • Material.TRef
      • Material.cross_reference()
      • Material.safe_cross_reference()
    • Property
      • Property.Mid()
      • Property.Pid()
      • Property.write_card_16()
      • Property.write_card_8()
    • break_word_by_trailing_integer()
    • break_word_by_trailing_parentheses_integer_ab()
    • read_ids_thru()
    • write_card()
• bdf_sets Module
  • ABCQSet
    • ABCQSet._finalize_hdf5()
    • ABCQSet.add_card()
    • ABCQSet.cross_reference()
    • ABCQSet.node_ids
    • ABCQSet.raw_fields()
    • ABCQSet.type
    • ABCQSet.uncross_reference()
    • ABCQSet.validate()
  • ABCQSet1
    • ABCQSet1._finalize_hdf5()
    • ABCQSet1.add_card()
    • ABCQSet1.components
    • ABCQSet1.cross_reference()
    • ABCQSet1.ids
    • ABCQSet1.node_ids
    • ABCQSet1.raw_fields()
    • ABCQSet1.type
    • ABCQSet1.uncross_reference()
  • ASET
    • ASET._init_from_empty()
    • ASET._properties
    • ASET.type
  • ASET1
    • ASET1._init_from_empty()
    • ASET1._properties
    • ASET1.type
  • BSET
    • BSET._init_from_empty()
    • BSET._properties
    • BSET.type
  • BSET1
    • BSET1._init_from_empty()
    • BSET1._properties
    • BSET1.type
  • CSET
    • CSET._init_from_empty()
    • CSET._properties
    • CSET.type
  • CSET1
    • CSET1._init_from_empty()
    • CSET1._properties
    • CSET1.add_card()
    • CSET1.ids
    • CSET1.raw_fields()
    • CSET1.type
  • OMIT
    • OMIT._init_from_empty()
    • OMIT._properties
    • OMIT.type
  • OMIT1
    • OMIT1._init_from_empty()
    • OMIT1._properties
    • OMIT1.type
  • QSET
    • QSET._init_from_empty()
    • QSET._properties
    • QSET.type
  • QSET1
    • QSET1._init_from_empty()
    • QSET1._properties
    • QSET1.type
  • RADSET
    • RADSET._finalize_hdf5()
    • RADSET._init_from_empty()
    • RADSET.add_card()
    • RADSET.raw_fields()
    • RADSET.type
  • SEBSET
    • SEBSET._init_from_empty()
    • SEBSET._properties
    • SEBSET.type
  • SEBSET1
    • SEBSET1._init_from_empty()
    • SEBSET1._properties
    • SEBSET1.type
  • SECSET
    • SECSET._init_from_empty()
    • SECSET._properties
    • SECSET.type
  • SECSET1
    • SECSET1._init_from_empty()
    • SECSET1._properties
    • SECSET1.type
  • SEQSEP
    • SEQSEP.add_card()
    • SEQSEP.get_ids()
    • SEQSEP.ids
    • SEQSEP.psid
    • SEQSEP.raw_fields()
    • SEQSEP.ssid
    • SEQSEP.type
  • SEQSET
    • SEQSET._init_from_empty()
    • SEQSET._properties
    • SEQSET.type
  • SEQSET1
    • SEQSET1._init_from_empty()
    • SEQSET1._properties
    • SEQSET1.type
  • SESET
    • SESET._init_from_empty()
    • SESET.add_card()
    • SESET.add_seset()
    • SESET.cross_reference()
    • SESET.ids
    • SESET.raw_fields()
    • SESET.type
    • SESET.uncross_reference()
  • SET1
    • SET1._init_from_empty()
    • SET1.add_card()
    • SET1.add_set()
    • SET1.cross_reference_set()
    • SET1.get_ids()
    • SET1.ids
    • SET1.raw_fields()
    • SET1.safe_cross_reference()
    • SET1.sid
    • SET1.symmetric_difference()
    • SET1.type
    • SET1.uncross_reference()
    • SET1.write_card()
  • SET2
    • SET2._init_from_empty()
    • SET2.add_card()
    • SET2.cross_reference_set()
    • SET2.get_ids()
    • SET2.macro
    • SET2.raw_fields()
    • SET2.safe_cross_reference()
    • SET2.sid
    • SET2.sp1
    • SET2.type
    • SET2.uncross_reference()
    • SET2.zmax
  • SET3
    • SET3.SetIDs()
    • SET3._init_from_empty()
    • SET3.add_card()
    • SET3.add_set()
    • SET3.cross_reference_set()
    • SET3.get_ids()
    • SET3.is_element()
    • SET3.is_grid()
    • SET3.is_point()
    • SET3.is_property()
    • SET3.raw_fields()
    • SET3.sid
    • SET3.symmetric_difference()
    • SET3.type
    • SET3.union()
    • SET3.valid_descs
    • SET3.validate()
    • SET3.write_card()
  • Set
    • Set.clean_ids()
    • Set.ids
    • Set.repr_fields()
    • Set.write_card()
  • SetSuper
    • SetSuper.ids
    • SetSuper.seid
  • SuperABCQSet
    • SuperABCQSet._finalize_hdf5()
    • SuperABCQSet.add_card()
    • SuperABCQSet.cross_reference()
    • SuperABCQSet.ids
    • SuperABCQSet.node_ids
    • SuperABCQSet.raw_fields()
    • SuperABCQSet.type
    • SuperABCQSet.uncross_reference()
    • SuperABCQSet.validate()
  • SuperABCQSet1
    • SuperABCQSet1._finalize_hdf5()
    • SuperABCQSet1.add_card()
    • SuperABCQSet1.components
    • SuperABCQSet1.cross_reference()
    • SuperABCQSet1.ids
    • SuperABCQSet1.node_ids
    • SuperABCQSet1.raw_fields()
    • SuperABCQSet1.type
    • SuperABCQSet1.uncross_reference()
    • SuperABCQSet1.validate()
  • USET
    • USET._init_from_empty()
    • USET._properties
    • USET.add_card()
    • USET.components
    • USET.cross_reference()
    • USET.node_ids
    • USET.raw_fields()
    • USET.sid
    • USET.type
    • USET.uncross_reference()
  • USET1
    • USET1._init_from_empty()
    • USET1._properties
    • USET1.add_card()
    • USET1.cross_reference()
    • USET1.node_ids
    • USET1.raw_fields()
    • USET1.type
    • USET1.uncross_reference()
• bdf_tables Module
  • DTABLE
    • DTABLE._finalize_hdf5()
    • DTABLE._init_from_empty()
    • DTABLE.add_card()
    • DTABLE.raw_fields()
    • DTABLE.type
    • DTABLE.write_card()
  • TABDMP1
    • TABDMP1._init_from_empty()
    • TABDMP1.add_card()
    • TABDMP1.add_card_lax()
    • TABDMP1.interpolate()
    • TABDMP1.interpolate_array()
    • TABDMP1.raw_fields()
    • TABDMP1.repr_fields()
    • TABDMP1.type
  • TABLED1
    • TABLED1._init_from_empty()
    • TABLED1.add_card()
    • TABLED1.add_card_lax()
    • TABLED1.interpolate()
    • TABLED1.raw_fields()
    • TABLED1.repr_fields()
    • TABLED1.type
  • TABLED2
    • TABLED2._init_from_empty()
    • TABLED2.add_card()
    • TABLED2.add_card_lax()
    • TABLED2.interpolate()
    • TABLED2.raw_fields()
    • TABLED2.repr_fields()
    • TABLED2.type
  • TABLED3
    • TABLED3._init_from_empty()
    • TABLED3.add_card()
    • TABLED3.add_card_lax()
    • TABLED3.raw_fields()
    • TABLED3.repr_fields()
    • TABLED3.type
  • TABLED4
    • TABLED4._init_from_empty()
    • TABLED4.add_card()
    • TABLED4.interpolate()
    • TABLED4.raw_fields()
    • TABLED4.repr_fields()
    • TABLED4.type
  • TABLED5
    • TABLED5.add_card()
    • TABLED5.raw_fields()
    • TABLED5.repr_fields()
    • TABLED5.type
  • TABLEH1
    • TABLEH1._init_from_empty()
    • TABLEH1.add_card()
    • TABLEH1.add_card_lax()
    • TABLEH1.raw_fields()
    • TABLEH1.repr_fields()
    • TABLEH1.type
  • TABLEHT
    • TABLEHT._init_from_empty()
    • TABLEHT.add_card()
    • TABLEHT.raw_fields()
    • TABLEHT.repr_fields()
    • TABLEHT.type
  • TABLEM1
    • TABLEM1._init_from_empty()
    • TABLEM1.add_card()
    • TABLEM1.add_card_lax()
    • TABLEM1.raw_fields()
    • TABLEM1.repr_fields()
    • TABLEM1.type
  • TABLEM2
    • TABLEM2._init_from_empty()
    • TABLEM2.add_card()
    • TABLEM2.add_card_lax()
    • TABLEM2.raw_fields()
    • TABLEM2.repr_fields()
    • TABLEM2.type
  • TABLEM3
    • TABLEM3._init_from_empty()
    • TABLEM3.add_card()
    • TABLEM3.add_card_lax()
    • TABLEM3.raw_fields()
    • TABLEM3.repr_fields()
    • TABLEM3.type
  • TABLEM4
    • TABLEM4._init_from_empty()
    • TABLEM4.add_card()
    • TABLEM4.raw_fields()
    • TABLEM4.repr_fields()
    • TABLEM4.type
  • TABLES1
    • TABLES1._init_from_empty()
    • TABLES1.add_card()
    • TABLES1.add_card_lax()
    • TABLES1.raw_fields()
    • TABLES1.repr_fields()
    • TABLES1.type
  • TABLEST
    • TABLEST.add_card()
    • TABLEST.add_card_lax()
    • TABLEST.cross_reference()
    • TABLEST.raw_fields()
    • TABLEST.repr_fields()
    • TABLEST.type
  • TABRND1
    • TABRND1._init_from_empty()
    • TABRND1.add_card()
    • TABRND1.add_card_lax()
    • TABRND1.raw_fields()
    • TABRND1.repr_fields()
    • TABRND1.type
  • TABRNDG
    • TABRNDG.LU
    • TABRNDG.WG
    • TABRNDG._init_from_empty()
    • TABRNDG.add_card()
    • TABRNDG.psd_type
    • TABRNDG.raw_fields()
    • TABRNDG.repr_fields()
    • TABRNDG.tid
    • TABRNDG.type
  • Table
    • Table._write_header_fields()
    • Table.plot()
    • Table.write_card()
    • Table.write_card_8()
  • _map_axis()
  • make_xy()
  • read_table()
  • read_table_float_int()
  • read_table_lax()
  • read_tablest()
• collpase_card Module
  • _check_sort_fields()
  • build_thru()
  • build_thru_float()
  • build_thru_packs()
  • collapse_colon_packs()
  • collapse_thru()
  • collapse_thru_by()
  • collapse_thru_by_float()
  • collapse_thru_ipacks()
  • collapse_thru_packs()
  • condense()
  • condensei()
• constraints Module
  • Constraint
  • ConstraintAdd
  • GMSPC
    • GMSPC._init_from_empty()
    • GMSPC.add_card()
    • GMSPC.cross_reference()
    • GMSPC.raw_fields()
    • GMSPC.safe_cross_reference()
    • GMSPC.type
    • GMSPC.uncross_reference()
    • GMSPC.write_card()
  • MPC
    • MPC._init_from_empty()
    • MPC._properties
    • MPC.add_card()
    • MPC.coefficients
    • MPC.components
    • MPC.conid
    • MPC.cross_reference()
    • MPC.dependent_dofs
    • MPC.dependent_nodes
    • MPC.independent_dofs
    • MPC.independent_nodes
    • MPC.node_ids
    • MPC.nodes
    • MPC.raw_fields()
    • MPC.safe_cross_reference()
    • MPC.type
    • MPC.uncross_reference()
    • MPC.validate()
    • MPC.write_card()
    • MPC.write_card_16()
    • MPC.write_card_8()
  • MPCADD
    • MPCADD._init_from_empty()
    • MPCADD._properties
    • MPCADD.add_card()
    • MPCADD.cross_reference()
    • MPCADD.ids
    • MPCADD.mpc_ids
    • MPCADD.raw_fields()
    • MPCADD.safe_cross_reference()
    • MPCADD.type
    • MPCADD.uncross_reference()
    • MPCADD.write_card()
    • MPCADD.write_card_16()
  • SESUP
    • SESUP._init_from_empty()
    • SESUP.type
  • SPC
    • SPC._init_from_empty()
    • SPC._properties
    • SPC.add_card()
    • SPC.constraints
    • SPC.cross_reference()
    • SPC.node_ids
    • SPC.raw_fields()
    • SPC.safe_cross_reference()
    • SPC.type
    • SPC.uncross_reference()
    • SPC.validate()
    • SPC.write_card()
  • SPC1
    • SPC1._init_from_empty()
    • SPC1._properties
    • SPC1.add_card()
    • SPC1.cross_reference()
    • SPC1.node_ids
    • SPC1.raw_fields()
    • SPC1.safe_cross_reference()
    • SPC1.type
    • SPC1.uncross_reference()
    • SPC1.validate()
    • SPC1.write_card()
  • SPCADD
    • SPCADD._init_from_empty()
    • SPCADD._properties
    • SPCADD.add_card()
    • SPCADD.cross_reference()
    • SPCADD.ids
    • SPCADD.raw_fields()
    • SPCADD.safe_cross_reference()
    • SPCADD.spc_ids
    • SPCADD.type
    • SPCADD.uncross_reference()
    • SPCADD.write_card()
    • SPCADD.write_card_16()
  • SPCAX
    • SPCAX._init_from_empty()
    • SPCAX.add_card()
    • SPCAX.component
    • SPCAX.conid
    • SPCAX.cross_reference()
    • SPCAX.enforced
    • SPCAX.hid
    • SPCAX.raw_fields()
    • SPCAX.ringax
    • SPCAX.safe_cross_reference()
    • SPCAX.type
    • SPCAX.uncross_reference()
    • SPCAX.write_card()
  • SPCOFF
    • SPCOFF._init_from_empty()
    • SPCOFF.add_card()
    • SPCOFF.constraints
    • SPCOFF.cross_reference()
    • SPCOFF.node_ids
    • SPCOFF.raw_fields()
    • SPCOFF.safe_cross_reference()
    • SPCOFF.type
    • SPCOFF.uncross_reference()
    • SPCOFF.validate()
    • SPCOFF.write_card()
  • SPCOFF1
    • SPCOFF1._init_from_empty()
    • SPCOFF1.add_card()
    • SPCOFF1.constraints
    • SPCOFF1.cross_reference()
    • SPCOFF1.node_ids
    • SPCOFF1.raw_fields()
    • SPCOFF1.safe_cross_reference()
    • SPCOFF1.type
    • SPCOFF1.uncross_reference()
    • SPCOFF1.validate()
    • SPCOFF1.write_card()
    • SPCOFF1.write_card_16()
  • SUPORT
    • SUPORT._init_from_empty()
    • SUPORT._properties
    • SUPORT.add_card()
    • SUPORT.cross_reference()
    • SUPORT.node_ids
    • SUPORT.raw_fields()
    • SUPORT.safe_cross_reference()
    • SUPORT.type
    • SUPORT.uncross_reference()
    • SUPORT.validate()
    • SUPORT.write_card()
  • SUPORT1
    • SUPORT1._init_from_empty()
    • SUPORT1._properties
    • SUPORT1.add_card()
    • SUPORT1.add_suport1_to_set()
    • SUPORT1.cross_reference()
    • SUPORT1.node_ids
    • SUPORT1.raw_fields()
    • SUPORT1.safe_cross_reference()
    • SUPORT1.type
    • SUPORT1.uncross_reference()
    • SUPORT1.write_card()
• contact Module
  • BCBODY
    • BCBODY._init_from_empty()
    • BCBODY.add_card()
    • BCBODY.cross_reference()
    • BCBODY.raw_fields()
    • BCBODY.type
    • BCBODY.write_card()
  • BCONP
    • BCONP.Cid()
    • BCONP.FrictionId()
    • BCONP.Master()
    • BCONP.Slave()
    • BCONP._init_from_empty()
    • BCONP.add_card()
    • BCONP.cross_reference()
    • BCONP.raw_fields()
    • BCONP.type
    • BCONP.uncross_reference()
    • BCONP.write_card()
  • BCPARA
    • BCPARA._finalize_hdf5()
    • BCPARA._init_from_empty()
    • BCPARA.add_card()
    • BCPARA.csid
    • BCPARA.raw_fields()
    • BCPARA.type
    • BCPARA.write_card()
  • BCRPARA
    • BCRPARA.Type
    • BCRPARA._init_from_empty()
    • BCRPARA.add_card()
    • BCRPARA.crid
    • BCRPARA.grid_point
    • BCRPARA.offset
    • BCRPARA.raw_fields()
    • BCRPARA.surf
    • BCRPARA.type
    • BCRPARA.write_card()
  • BCTADD
    • BCTADD._init_from_empty()
    • BCTADD.add_card()
    • BCTADD.contact_sets
    • BCTADD.csid
    • BCTADD.raw_fields()
    • BCTADD.type
    • BCTADD.write_card()
  • BCTPARA
    • BCTPARA._finalize_hdf5()
    • BCTPARA._get_param_value_from_card()
    • BCTPARA._init_from_empty()
    • BCTPARA.add_card()
    • BCTPARA.csid
    • BCTPARA.raw_fields()
    • BCTPARA.type
    • BCTPARA.write_card()
  • BCTPARM
    • BCTPARM._finalize_hdf5()
    • BCTPARM._get_param_value_from_card()
    • BCTPARM._init_from_empty()
    • BCTPARM.add_card()
    • BCTPARM.csid
    • BCTPARM.raw_fields()
    • BCTPARM.type
    • BCTPARM.write_card()
  • BCTSET
    • BCTSET._init_from_empty()
    • BCTSET.add_card()
    • BCTSET.csid
    • BCTSET.frictions
    • BCTSET.max_distances
    • BCTSET.min_distances
    • BCTSET.raw_fields()
    • BCTSET.sids
    • BCTSET.tids
    • BCTSET.type
    • BCTSET.write_card()
  • BFRIC
    • BFRIC._init_from_empty()
    • BFRIC.add_card()
    • BFRIC.raw_fields()
    • BFRIC.type
    • BFRIC.write_card()
  • BGADD
    • BGADD._init_from_empty()
    • BGADD.add_card()
    • BGADD.contact_sets
    • BGADD.glue_id
    • BGADD.raw_fields()
    • BGADD.type
    • BGADD.write_card()
  • BGSET
    • BGSET._init_from_empty()
    • BGSET.add_card()
    • BGSET.exts
    • BGSET.glue_id
    • BGSET.raw_fields()
    • BGSET.sdists
    • BGSET.sids
    • BGSET.tids
    • BGSET.type
    • BGSET.write_card()
  • BLSEG
    • BLSEG._init_from_empty()
    • BLSEG.add_card()
    • BLSEG.cross_reference()
    • BLSEG.node_ids
    • BLSEG.raw_fields()
    • BLSEG.type
    • BLSEG.uncross_reference()
    • BLSEG.write_card()
  • BSURF
    • BSURF._init_from_empty()
    • BSURF.add_card()
    • BSURF.eids
    • BSURF.raw_fields()
    • BSURF.sid
    • BSURF.type
    • BSURF.write_card()
  • BSURFS
    • BSURFS._init_from_empty()
    • BSURFS.add_card()
    • BSURFS.eids
    • BSURFS.g1s
    • BSURFS.id
    • BSURFS.raw_fields()
    • BSURFS.type
    • BSURFS.write_card()
  • _get_bcbody_section_values()
  • get_table3d()
  • params_listify()
  • read_param_dict()
• coordinate_systems Module
  • CORD1C
    • CORD1C.Type
    • CORD1C.raw_fields()
    • CORD1C.type
  • CORD1R
    • CORD1R.Type
    • CORD1R.int_type
    • CORD1R.raw_fields()
    • CORD1R.type
  • CORD1S
    • CORD1S.Type
    • CORD1S.raw_fields()
    • CORD1S.type
  • CORD2C
    • CORD2C.Type
    • CORD2C.raw_fields()
    • CORD2C.type
  • CORD2R
    • CORD2R.Type
    • CORD2R.raw_fields()
    • CORD2R.type
  • CORD2S
    • CORD2S.Type
    • CORD2S.raw_fields()
    • CORD2S.type
  • CORD3G
    • CORD3G.Rid()
    • CORD3G.add_card()
    • CORD3G.coord3g_transform_to_global()
    • CORD3G.cross_reference()
    • CORD3G.raw_fields()
    • CORD3G.rotation_x()
    • CORD3G.rotation_y()
    • CORD3G.rotation_z()
    • CORD3G.type
    • CORD3G.uncross_reference()
  • CoordBase
    • CoordBase.Cid()
    • CoordBase.beta()
    • CoordBase.beta_n()
    • CoordBase.global_to_local
    • CoordBase.is_resolved
    • CoordBase.local_to_global
    • CoordBase.move_origin()
    • CoordBase.repr_fields()
    • CoordBase.resolve()
    • CoordBase.setup()
    • CoordBase.setup_global_cord2x()
    • CoordBase.setup_no_xref()
    • CoordBase.transform_matrix_to_global()
    • CoordBase.transform_matrix_to_global_from_element_coord()
    • CoordBase.type
  • Cord1x
    • Cord1x.G1()
    • Cord1x.G2()
    • Cord1x.G3()
    • Cord1x.Rid()
    • Cord1x.add_card()
    • Cord1x.cid
    • Cord1x.cross_reference()
    • Cord1x.export_to_hdf5()
    • Cord1x.g1
    • Cord1x.g2
    • Cord1x.g3
    • Cord1x.node_ids
    • Cord1x.rid
    • Cord1x.safe_cross_reference()
    • Cord1x.setup()
    • Cord1x.to_cord2x()
    • Cord1x.uncross_reference()
    • Cord1x.validate()
    • Cord1x.write_card()
    • Cord1x.write_card_16()
  • Cord2x
    • Cord2x.Rid()
    • Cord2x._add()
    • Cord2x._finish_setup()
    • Cord2x.add_axes()
    • Cord2x.add_card()
    • Cord2x.add_card_lax()
    • Cord2x.add_ijk()
    • Cord2x.cross_reference()
    • Cord2x.export_to_hdf5()
    • Cord2x.init_from_empty()
    • Cord2x.safe_cross_reference()
    • Cord2x.translate()
    • Cord2x.uncross_reference()
    • Cord2x.update()
    • Cord2x.update_e123()
    • Cord2x.write_card()
    • Cord2x.write_card_16()
  • CylindricalCoord
    • CylindricalCoord.coord_to_cylindrical()
    • CylindricalCoord.coord_to_spherical()
    • CylindricalCoord.coord_to_xyz()
    • CylindricalCoord.coord_to_xyz_array()
    • CylindricalCoord.global_to_basic()
    • CylindricalCoord.xyz_to_coord()
    • CylindricalCoord.xyz_to_coord_array()
  • MATCID
    • MATCID.Cid()
    • MATCID.add_card()
    • MATCID.raw_fields()
    • MATCID.repr_fields()
    • MATCID.type
    • MATCID.write_card()
    • MATCID.write_card_16()
  • RectangularCoord
    • RectangularCoord.coord_to_xyz()
    • RectangularCoord.coord_to_xyz_array()
    • RectangularCoord.global_to_basic()
    • RectangularCoord.xyz_to_coord()
    • RectangularCoord.xyz_to_coord_array()
  • SphericalCoord
    • SphericalCoord.coord_to_cylindrical()
    • SphericalCoord.coord_to_spherical()
    • SphericalCoord.coord_to_xyz()
    • SphericalCoord.coord_to_xyz_array()
    • SphericalCoord.global_to_basic()
    • SphericalCoord.xyz_to_coord()
    • SphericalCoord.xyz_to_coord_array()
  • _check_square()
  • _coord_to_xyz()
  • _fix_xyz_shape()
  • _primary_axes()
  • create_coords_along_line()
  • define_coord_e123()
  • define_coord_ijk()
  • define_spherical_cutting_plane()
  • get_nodes_along_axis_in_coords()
  • global_to_basic_cylindrical()
  • global_to_basic_rectangular()
  • global_to_basic_spherical()
  • normalize()
  • setup_add_axes()
  • setup_add_ijk()
  • transform_coords_vectorized()
  • transform_cylindrical_to_rectangular()
  • transform_spherical_to_rectangular()
• dmig Module
  • DMI
    • DMI._get_complex_fields()
    • DMI._get_real_fields()
    • DMI._init_from_empty()
    • DMI._properties
    • DMI._read_complex()
    • DMI._read_real()
    • DMI._write_card()
    • DMI.add_card()
    • DMI.export_to_hdf5()
    • DMI.finalize()
    • DMI.from_array()
    • DMI.get_matrix()
    • DMI.ifo
    • DMI.is_complex
    • DMI.is_polar
    • DMI.is_real
    • DMI.matrix_type
    • DMI.raw_fields()
    • DMI.shape
    • DMI.type
    • DMI.write_card()
    • DMI.write_card_16()
    • DMI.write_card_8()
    • DMI.write_card_double()
  • DMIAX
    • DMIAX._write_card()
    • DMIAX.add_card()
    • DMIAX.export_to_hdf5()
    • DMIAX.finalize()
    • DMIAX.is_complex
    • DMIAX.is_polar
    • DMIAX.is_real
    • DMIAX.matrix_form
    • DMIAX.matrix_type
    • DMIAX.raw_fields()
    • DMIAX.tin_dtype
    • DMIAX.tout
    • DMIAX.tout_dtype
    • DMIAX.type
    • DMIAX.write_card()
    • DMIAX.write_card_16()
    • DMIAX.write_card_8()
    • DMIAX.write_card_double()
  • DMIG
    • DMIG._properties
    • DMIG.export_to_hdf5()
    • DMIG.type
  • DMIG_UACCEL
    • DMIG_UACCEL._write_card()
    • DMIG_UACCEL.add_card()
    • DMIG_UACCEL.export_to_hdf5()
    • DMIG_UACCEL.finalize()
    • DMIG_UACCEL.name
    • DMIG_UACCEL.raw_fields()
    • DMIG_UACCEL.type
    • DMIG_UACCEL.write_card()
    • DMIG_UACCEL.write_card_16()
    • DMIG_UACCEL.write_card_8()
  • DMIJ
    • DMIJ._init_from_empty()
    • DMIJ._properties
    • DMIJ.export_to_hdf5()
    • DMIJ.type
  • DMIJI
    • DMIJI._properties
    • DMIJI.export_to_hdf5()
    • DMIJI.type
  • DMIK
    • DMIK._properties
    • DMIK.export_to_hdf5()
    • DMIK.type
  • DTI
    • DTI._finalize_hdf5()
    • DTI._init_from_empty()
    • DTI.add_card()
    • DTI.export_to_hdf5()
    • DTI.raw_fields()
    • DTI.type
    • DTI.write_card()
  • DTI_UNITS
    • DTI_UNITS._finalize_hdf5()
    • DTI_UNITS._init_from_empty()
    • DTI_UNITS.add_card()
    • DTI_UNITS.export_to_hdf5()
    • DTI_UNITS.raw_fields()
    • DTI_UNITS.type
    • DTI_UNITS.write_card()
  • NastranMatrix
    • NastranMatrix._finalize_hdf5()
    • NastranMatrix.add_card()
    • NastranMatrix.fill_in_default_components()
    • NastranMatrix.finalize()
    • NastranMatrix.from_array()
    • NastranMatrix.get_matrix()
    • NastranMatrix.is_complex
    • NastranMatrix.is_polar
    • NastranMatrix.is_real
    • NastranMatrix.matrix_form
    • NastranMatrix.matrix_form_str
    • NastranMatrix.matrix_type
    • NastranMatrix.plot_matrix()
    • NastranMatrix.polar
    • NastranMatrix.shape
    • NastranMatrix.tin_dtype
    • NastranMatrix.tout
    • NastranMatrix.tout_dtype
    • NastranMatrix.write_card()
    • NastranMatrix.write_csv()
  • _build_gc_map()
  • _determine_size_double_from_tin()
  • _dmi_get_complex_matrix_columns()
  • _dmi_get_real_matrix_columns()
  • _dmi_write_complex_columns_8()
  • _dmi_write_real_columns_8()
  • _export_dmiax_to_hdf5()
  • _export_dmig_to_hdf5()
  • _fill_dense_column_matrix()
  • _fill_dense_column_matrix_complex()
  • _fill_dense_column_matrix_real()
  • _fill_dense_rectangular_matrix()
  • _fill_dense_rectangular_matrix_complex()
  • _fill_dense_rectangular_matrix_real()
  • _fill_sparse_matrix()
  • _get_diagonal_symmetric()
  • _get_gcj_gci_data()
  • _get_real_dtype()
  • _get_row_col_map_1d()
  • _get_row_col_map_2d()
  • _set_matrix()
  • _set_polar()
  • dtype_to_tin_tout_str()
  • gc_to_index()
  • get_dmi_matrix()
  • get_matrix()
  • get_row_col_map()
  • map_form()
  • matrix_form_str_to_int()
  • tin_str_to_int()
  • tout_str_to_int()
• dynamic Module
  • DELAY
    • DELAY._init_from_empty()
    • DELAY._properties
    • DELAY.add()
    • DELAY.add_card()
    • DELAY.components
    • DELAY.cross_reference()
    • DELAY.delays
    • DELAY.get_delay_at_freq()
    • DELAY.node_id1
    • DELAY.node_id2
    • DELAY.node_ids
    • DELAY.nodes
    • DELAY.raw_fields()
    • DELAY.sid
    • DELAY.type
    • DELAY.uncross_reference()
    • DELAY.write_card()
  • DPHASE
    • DPHASE._init_from_empty()
    • DPHASE._properties
    • DPHASE.add()
    • DPHASE.add_card()
    • DPHASE.cross_reference()
    • DPHASE.get_dphase_at_freq()
    • DPHASE.node_id1
    • DPHASE.node_id2
    • DPHASE.node_ids
    • DPHASE.raw_fields()
    • DPHASE.safe_cross_reference()
    • DPHASE.type
    • DPHASE.uncross_reference()
    • DPHASE.write_card()
  • FREQ
    • FREQ._init_from_empty()
    • FREQ.add_card()
    • FREQ.add_frequencies()
    • FREQ.add_frequency_object()
    • FREQ.get_freqs()
    • FREQ.raw_fields()
    • FREQ.type
    • FREQ.write_card()
  • FREQ1
    • FREQ1._init_from_empty()
    • FREQ1.add_card()
    • FREQ1.add_card_lax()
    • FREQ1.raw_fields()
    • FREQ1.type
    • FREQ1.write_card()
  • FREQ2
    • FREQ2._init_from_empty()
    • FREQ2.add_card()
    • FREQ2.raw_fields()
    • FREQ2.type
    • FREQ2.write_card()
  • FREQ3
    • FREQ3._init_from_empty()
    • FREQ3.add_card()
    • FREQ3.get_frequencies()
    • FREQ3.raw_fields()
    • FREQ3.type
    • FREQ3.validate()
    • FREQ3.write_card()
  • FREQ4
    • FREQ4._init_from_empty()
    • FREQ4.add_card()
    • FREQ4.get_frequencies()
    • FREQ4.raw_fields()
    • FREQ4.repr_fields()
    • FREQ4.type
    • FREQ4.write_card()
  • FREQ5
    • FREQ5._init_from_empty()
    • FREQ5.add_card()
    • FREQ5.get_frequencies()
    • FREQ5.raw_fields()
    • FREQ5.type
    • FREQ5.validate()
    • FREQ5.write_card()
  • NLPARM
    • NLPARM._init_from_empty()
    • NLPARM._properties
    • NLPARM.add_card()
    • NLPARM.raw_fields()
    • NLPARM.repr_fields()
    • NLPARM.type
    • NLPARM.validate()
    • NLPARM.write_card()
  • NLPCI
    • NLPCI._init_from_empty()
    • NLPCI._properties
    • NLPCI.add_card()
    • NLPCI.raw_fields()
    • NLPCI.repr_fields()
    • NLPCI.type
    • NLPCI.write_card()
  • ROTORD
    • ROTORD._init_from_empty()
    • ROTORD.add_card()
    • ROTORD.cross_reference()
    • ROTORD.raw_fields()
    • ROTORD.type
    • ROTORD.validate()
    • ROTORD.write_card()
  • ROTORG
    • ROTORG._init_from_empty()
    • ROTORG.add_card()
    • ROTORG.cross_reference()
    • ROTORG.raw_fields()
    • ROTORG.type
    • ROTORG.uncross_reference()
    • ROTORG.validate()
    • ROTORG.write_card()
  • TF
    • TF._init_from_empty()
    • TF.add_card()
    • TF.cross_reference()
    • TF.raw_fields()
    • TF.type
    • TF.validate()
    • TF.write_card()
  • TIC
    • TIC._init_from_empty()
    • TIC._properties
    • TIC.add()
    • TIC.add_card()
    • TIC.cross_reference()
    • TIC.node_ids
    • TIC.raw_fields()
    • TIC.safe_cross_reference()
    • TIC.type
    • TIC.uncross_reference()
    • TIC.validate()
    • TIC.write_card()
  • TSTEP
    • TSTEP.DT
    • TSTEP.N
    • TSTEP.NO
    • TSTEP._init_from_empty()
    • TSTEP.add_card()
    • TSTEP.raw_fields()
    • TSTEP.repr_fields()
    • TSTEP.type
    • TSTEP.validate()
    • TSTEP.write_card()
  • TSTEP1
    • TSTEP1._init_from_empty()
    • TSTEP1.add_card()
    • TSTEP1.raw_fields()
    • TSTEP1.repr_fields()
    • TSTEP1.type
    • TSTEP1.write_card()
  • TSTEPNL
    • TSTEPNL._init_from_empty()
    • TSTEPNL.add_card()
    • TSTEPNL.allowed_methods
    • TSTEPNL.raw_fields()
    • TSTEPNL.repr_fields()
    • TSTEPNL.type
    • TSTEPNL.validate()
    • TSTEPNL.write_card()
• expand_card Module
  • expand_thru()
  • expand_thru_by()
  • remove_blanks_capitalize()
  • set_list_print()
• materials Module
  • AnisotropicMaterial
  • CREEP
    • CREEP.Mid()
    • CREEP._init_from_empty()
    • CREEP.add_card()
    • CREEP.cross_reference()
    • CREEP.raw_fields()
    • CREEP.repr_fields()
    • CREEP.type
    • CREEP.uncross_reference()
    • CREEP.write_card()
  • EQUIV
    • EQUIV.add_card()
    • EQUIV.mid
    • EQUIV.raw_fields()
    • EQUIV.type
  • HyperelasticMaterial
  • IsotropicMaterial
  • MAT1
    • MAT1.D()
    • MAT1.E()
    • MAT1.E_stress()
    • MAT1.E_temperature()
    • MAT1.G()
    • MAT1.Mats1()
    • MAT1.Matt1()
    • MAT1.Nu()
    • MAT1.Rho()
    • MAT1._properties
    • MAT1.add_card()
    • MAT1.add_card_lax()
    • MAT1.compliance()
    • MAT1.cross_reference()
    • MAT1.export_to_hdf5()
    • MAT1.get_density()
    • MAT1.mp_name_map
    • MAT1.raw_fields()
    • MAT1.repr_fields()
    • MAT1.type
    • MAT1.uncross_reference()
    • MAT1.write_card()
  • MAT10
    • MAT10.Rho()
    • MAT10._init_from_empty()
    • MAT10.add_card()
    • MAT10.add_card_lax()
    • MAT10.cross_reference()
    • MAT10.get_density()
    • MAT10.mp_name_map
    • MAT10.raw_fields()
    • MAT10.repr_fields()
    • MAT10.type
    • MAT10.uncross_reference()
    • MAT10.validate()
    • MAT10.write_card()
  • MAT11
    • MAT11._init_from_empty()
    • MAT11._properties
    • MAT11._validate_input()
    • MAT11.add_card()
    • MAT11.add_card_lax()
    • MAT11.get_density()
    • MAT11.mp_name_map
    • MAT11.raw_fields()
    • MAT11.repr_fields()
    • MAT11.type
    • MAT11.uncross_reference()
    • MAT11.write_card()
  • MAT2
    • MAT2.Dplate()
    • MAT2.Dsolid()
    • MAT2.Rho()
    • MAT2._properties
    • MAT2.add_card()
    • MAT2.add_card_lax()
    • MAT2.cross_reference()
    • MAT2.export_to_hdf5()
    • MAT2.get_density()
    • MAT2.mp_name_map
    • MAT2.raw_fields()
    • MAT2.repr_fields()
    • MAT2.type
    • MAT2.uncross_reference()
    • MAT2.write_card()
  • MAT3
    • MAT3.Rho()
    • MAT3.add_card()
    • MAT3.add_card_lax()
    • MAT3.cross_reference()
    • MAT3.export_to_hdf5()
    • MAT3.get_density()
    • MAT3.raw_fields()
    • MAT3.repr_fields()
    • MAT3.type
    • MAT3.uncross_reference()
    • MAT3.write_card()
  • MAT3D
    • MAT3D._init_from_empty()
    • MAT3D._validate_input()
    • MAT3D.add_card()
    • MAT3D.raw_fields()
    • MAT3D.repr_fields()
    • MAT3D.type
    • MAT3D.uncross_reference()
    • MAT3D.write_card()
  • MAT4
    • MAT4.Rho()
    • MAT4._init_from_empty()
    • MAT4.add_card()
    • MAT4.add_card_lax()
    • MAT4.cross_reference()
    • MAT4.get_density()
    • MAT4.raw_fields()
    • MAT4.repr_fields()
    • MAT4.type
    • MAT4.write_card()
  • MAT5
    • MAT5.K()
    • MAT5.Matt5()
    • MAT5.Rho()
    • MAT5._init_from_empty()
    • MAT5.add_card()
    • MAT5.add_card_lax()
    • MAT5.cross_reference()
    • MAT5.get_density()
    • MAT5.mid
    • MAT5.raw_fields()
    • MAT5.repr_fields()
    • MAT5.type
    • MAT5.uncross_reference()
    • MAT5.write_card()
  • MAT8
    • MAT8.D()
    • MAT8.E11()
    • MAT8.E22()
    • MAT8.G12()
    • MAT8.Matt8()
    • MAT8.Nu12()
    • MAT8.Rho()
    • MAT8._properties
    • MAT8.add_card()
    • MAT8.add_card_lax()
    • MAT8.cross_reference()
    • MAT8.export_to_hdf5()
    • MAT8.get_density()
    • MAT8.mp_name_map
    • MAT8.raw_fields()
    • MAT8.repr_fields()
    • MAT8.type
    • MAT8.uncross_reference()
    • MAT8.write_card()
  • MAT9
    • MAT9.D()
    • MAT9.Rho()
    • MAT9._properties
    • MAT9.add_card()
    • MAT9.add_card_lax()
    • MAT9.cross_reference()
    • MAT9.export_to_hdf5()
    • MAT9.mid
    • MAT9.mp_name_map
    • MAT9.raw_fields()
    • MAT9.repr_fields()
    • MAT9.type
    • MAT9.uncross_reference()
    • MAT9.write_card()
  • MATEV
    • MATEV.Rho()
    • MATEV._properties
    • MATEV.add_card()
    • MATEV.cross_reference()
    • MATEV.get_density()
    • MATEV.mp_name_map
    • MATEV.raw_fields()
    • MATEV.repr_fields()
    • MATEV.type
    • MATEV.uncross_reference()
    • MATEV.write_card()
  • MATG
    • MATG._init_from_empty()
    • MATG.add_card()
    • MATG.add_card_lax()
    • MATG.raw_fields()
    • MATG.repr_fields()
    • MATG.type
    • MATG.uncross_reference()
    • MATG.validate()
    • MATG.write_card()
  • MATHE
    • MATHE._init_from_empty()
    • MATHE.add_card()
    • MATHE.raw_fields()
    • MATHE.repr_fields()
    • MATHE.type
    • MATHE.validate()
    • MATHE.write_card()
  • MATHP
    • MATHP.Rho()
    • MATHP._init_from_empty()
    • MATHP.add_card()
    • MATHP.raw_fields()
    • MATHP.repr_fields()
    • MATHP.type
    • MATHP.write_card()
  • NXSTRAT
    • NXSTRAT._finalize_hdf5()
    • NXSTRAT._init_from_empty()
    • NXSTRAT.add_card()
    • NXSTRAT.raw_fields()
    • NXSTRAT.repr_fields()
    • NXSTRAT.type
    • NXSTRAT.write_card()
  • OrthotropicMaterial
  • ThermalMaterial
  • ViscoelasticMaterial
  • _mat10_get_bulk_rho_c()
  • get_G_default()
  • get_mat_props_S()
  • mat1_E_G_nu()
• material_deps Module
  • MATDMG
    • MATDMG.add_card()
    • MATDMG.raw_fields()
    • MATDMG.repr_fields()
    • MATDMG.type
    • MATDMG.write_card()
  • MATS1
    • MATS1.E()
    • MATS1.Hf()
    • MATS1.Tid()
    • MATS1.Yf()
    • MATS1._init_from_empty()
    • MATS1.add_card()
    • MATS1.cross_reference()
    • MATS1.h
    • MATS1.hr
    • MATS1.limit1
    • MATS1.limit2
    • MATS1.mid
    • MATS1.raw_fields()
    • MATS1.repr_fields()
    • MATS1.safe_cross_reference()
    • MATS1.strmeas
    • MATS1.type
    • MATS1.uncross_reference()
    • MATS1.validate()
    • MATS1.write_card()
    • MATS1.yf
  • MATT1
    • MATT1.A_table()
    • MATT1.E()
    • MATT1.E_table()
    • MATT1.G_table()
    • MATT1.Ge_table()
    • MATT1.Nu_table()
    • MATT1.Rho_table()
    • MATT1.Sc_table()
    • MATT1.Ss_table()
    • MATT1.St_table()
    • MATT1._init_from_empty()
    • MATT1.add_card()
    • MATT1.cross_reference()
    • MATT1.raw_fields()
    • MATT1.repr_fields()
    • MATT1.safe_cross_reference()
    • MATT1.type
    • MATT1.uncross_reference()
    • MATT1.write_card()
  • MATT11
    • MATT11._init_from_empty()
    • MATT11.add_card()
    • MATT11.cross_reference()
    • MATT11.raw_fields()
    • MATT11.safe_cross_reference()
    • MATT11.type
    • MATT11.uncross_reference()
    • MATT11.write_card()
  • MATT2
    • MATT2.A1_table()
    • MATT2.A2_table()
    • MATT2.A3_table()
    • MATT2.G11_table()
    • MATT2.G12_table()
    • MATT2.G13_table()
    • MATT2.G22_table()
    • MATT2.G23_table()
    • MATT2.G33_table()
    • MATT2.Ge_table()
    • MATT2.Rho_table()
    • MATT2.Sc_table()
    • MATT2.Ss_table()
    • MATT2.St_table()
    • MATT2._init_from_empty()
    • MATT2.add_card()
    • MATT2.cross_reference()
    • MATT2.raw_fields()
    • MATT2.repr_fields()
    • MATT2.safe_cross_reference()
    • MATT2.type
    • MATT2.uncross_reference()
    • MATT2.validate()
    • MATT2.write_card()
  • MATT3
    • MATT3.Ath_table()
    • MATT3.Ax_table()
    • MATT3.Az_table()
    • MATT3.Eth_table()
    • MATT3.Ex_table()
    • MATT3.Ez_table()
    • MATT3.Ge_table()
    • MATT3.Gzx_table()
    • MATT3.Nuth_table()
    • MATT3.Nuxz_table()
    • MATT3.Rho_table()
    • MATT3._init_from_empty()
    • MATT3.add_card()
    • MATT3.cross_reference()
    • MATT3.raw_fields()
    • MATT3.repr_fields()
    • MATT3.safe_cross_reference()
    • MATT3.type
    • MATT3.uncross_reference()
    • MATT3.validate()
    • MATT3.write_card()
  • MATT4
    • MATT4.Cp_table()
    • MATT4.H_table()
    • MATT4.Hgen_table()
    • MATT4.K_table()
    • MATT4.Mu_table()
    • MATT4._init_from_empty()
    • MATT4.add_card()
    • MATT4.cross_reference()
    • MATT4.raw_fields()
    • MATT4.repr_fields()
    • MATT4.safe_cross_reference()
    • MATT4.type
    • MATT4.uncross_reference()
    • MATT4.write_card()
  • MATT5
    • MATT5.Cp_table()
    • MATT5.Hgen_table()
    • MATT5.Kxx_table()
    • MATT5.Kxy_table()
    • MATT5.Kxz_table()
    • MATT5.Kyy_table()
    • MATT5.Kyz_table()
    • MATT5.Kzz_table()
    • MATT5._init_from_empty()
    • MATT5.add_card()
    • MATT5.cross_reference()
    • MATT5.raw_fields()
    • MATT5.repr_fields()
    • MATT5.safe_cross_reference()
    • MATT5.type
    • MATT5.uncross_reference()
    • MATT5.write_card()
  • MATT8
    • MATT8.A1_table()
    • MATT8.A2_table()
    • MATT8.E1_table()
    • MATT8.E2_table()
    • MATT8.F12_table()
    • MATT8.G12_table()
    • MATT8.G1z_table()
    • MATT8.G2z_table()
    • MATT8.Ge_table()
    • MATT8.Nu12_table()
    • MATT8.Rho_table()
    • MATT8.S_table()
    • MATT8.Xc_table()
    • MATT8.Xt_table()
    • MATT8.Yc_table()
    • MATT8.Yt_table()
    • MATT8._init_from_empty()
    • MATT8.add_card()
    • MATT8.cross_reference()
    • MATT8.raw_fields()
    • MATT8.safe_cross_reference()
    • MATT8.type
    • MATT8.uncross_reference()
    • MATT8.write_card()
  • MATT9
    • MATT9._init_from_empty()
    • MATT9.add_card()
    • MATT9.cross_reference()
    • MATT9.raw_fields()
    • MATT9.safe_cross_reference()
    • MATT9.type
    • MATT9.uncross_reference()
    • MATT9.write_card()
  • MaterialDependence
    • MaterialDependence.Mid()
    • MaterialDependence._get_table()
  • MaterialDependenceThermal
  • _safe_xref_table()
  • _xref_table()
• methods Module
  • EIGB
    • EIGB.L1
    • EIGB._init_from_empty()
    • EIGB.add_card()
    • EIGB.cross_reference()
    • EIGB.method
    • EIGB.ndp
    • EIGB.nep
    • EIGB.norm
    • EIGB.raw_fields()
    • EIGB.repr_fields()
    • EIGB.sid
    • EIGB.type
    • EIGB.write_card()
  • EIGC
    • EIGC.C
    • EIGC.G
    • EIGC._init_from_empty()
    • EIGC.add_card()
    • EIGC.cross_reference()
    • EIGC.epsilon
    • EIGC.method
    • EIGC.norm
    • EIGC.raw_fields()
    • EIGC.raw_method()
    • EIGC.repr_fields()
    • EIGC.repr_method()
    • EIGC.sid
    • EIGC.type
    • EIGC.validate()
    • EIGC.write_card()
  • EIGP
    • EIGP._init_from_empty()
    • EIGP.add_card()
    • EIGP.alpha1
    • EIGP.alpha2
    • EIGP.cross_reference()
    • EIGP.m1
    • EIGP.m2
    • EIGP.omega1
    • EIGP.omega2
    • EIGP.raw_fields()
    • EIGP.repr_fields()
    • EIGP.sid
    • EIGP.type
    • EIGP.write_card()
  • EIGR
    • EIGR.C
    • EIGR.G
    • EIGR._init_from_empty()
    • EIGR.add_card()
    • EIGR.allowed_methods
    • EIGR.crit
    • EIGR.cross_reference()
    • EIGR.f1
    • EIGR.method
    • EIGR.nd
    • EIGR.ne
    • EIGR.norm
    • EIGR.raw_fields()
    • EIGR.repr_fields()
    • EIGR.sid
    • EIGR.type
    • EIGR.write_card()
  • EIGRL
    • EIGRL._init_from_empty()
    • EIGRL.add_card()
    • EIGRL.cross_reference()
    • EIGRL.maxset
    • EIGRL.msglvl
    • EIGRL.nd
    • EIGRL.norm
    • EIGRL.raw_fields()
    • EIGRL.repr_fields()
    • EIGRL.shfscl
    • EIGRL.sid
    • EIGRL.type
    • EIGRL.v1
    • EIGRL.validate()
    • EIGRL.write_card()
  • MODTRAK
    • MODTRAK._init_from_empty()
    • MODTRAK.add_card()
    • MODTRAK.raw_fields()
    • MODTRAK.type
    • MODTRAK.write_card()
  • Method
  • _load_clan()
  • _load_hess_inv()
  • _load_isrr()
• msgmesh Module
• nodes Module
  • EPOINT
    • EPOINT.type
  • EPOINTs
    • EPOINTs.create_epointi()
    • EPOINTs.type
  • GRDSET
    • GRDSET.Cd()
    • GRDSET.Cp()
    • GRDSET.Ps()
    • GRDSET.SEid()
    • GRDSET._init_from_empty()
    • GRDSET.add_card()
    • GRDSET.cd
    • GRDSET.cp
    • GRDSET.cross_reference()
    • GRDSET.ps
    • GRDSET.raw_fields()
    • GRDSET.repr_fields()
    • GRDSET.seid
    • GRDSET.type
    • GRDSET.uncross_reference()
    • GRDSET.write_card()
  • GRID
    • GRID.Cd()
    • GRID.Cp()
    • GRID.Nid()
    • GRID.Ps()
    • GRID.SEid()
    • GRID.add_card()
    • GRID.add_card_lax()
    • GRID.cd_ref
    • GRID.cp_ref
    • GRID.cross_reference()
    • GRID.elements_ref
    • GRID.export_to_hdf5()
    • GRID.get_position()
    • GRID.get_position_assuming_rectangular()
    • GRID.get_position_no_xref()
    • GRID.get_position_wrt()
    • GRID.get_position_wrt_coord_ref()
    • GRID.get_position_wrt_no_xref()
    • GRID.raw_fields()
    • GRID.repr_fields()
    • GRID.safe_cross_reference()
    • GRID.set_position()
    • GRID.type
    • GRID.uncross_reference()
    • GRID.validate()
    • GRID.write_card()
    • GRID.write_card_16()
    • GRID.write_card_8()
  • POINT
    • POINT.Cp()
    • POINT._init_from_empty()
    • POINT.add_card()
    • POINT.cp
    • POINT.cross_reference()
    • POINT.get_position()
    • POINT.get_position_wrt()
    • POINT.nid
    • POINT.raw_fields()
    • POINT.repr_fields()
    • POINT.set_position()
    • POINT.type
    • POINT.uncross_reference()
    • POINT.validate()
    • POINT.write_card()
    • POINT.xyz
  • SEQGP
    • SEQGP._init_from_empty()
    • SEQGP.add_card()
    • SEQGP.append()
    • SEQGP.cross_reference()
    • SEQGP.raw_fields()
    • SEQGP.type
    • SEQGP.write_card()
  • SPOINT
    • SPOINT.get_position()
    • SPOINT.type
  • SPOINTs
    • SPOINTs.create_spointi()
    • SPOINTs.type
  • XPoint
    • XPoint._export_to_hdf5()
    • XPoint._init_from_empty()
    • XPoint.cross_reference()
    • XPoint.raw_fields()
    • XPoint.type
    • XPoint.write_card()
  • XPoints
    • XPoints._init_from_empty()
    • XPoints.add_card()
    • XPoints.add_points()
    • XPoints.cross_reference()
    • XPoints.raw_fields()
    • XPoints.type
    • XPoints.write_card()
  • compress_xpoints()
  • write_xpoints()
• optimization Module
  • DCONADD
    • DCONADD._init_from_empty()
    • DCONADD.add_card()
    • DCONADD.cross_reference()
    • DCONADD.dconstr_ids
    • DCONADD.export_to_hdf5()
    • DCONADD.raw_fields()
    • DCONADD.type
    • DCONADD.uncross_reference()
    • DCONADD.write_card()
  • DCONSTR
    • DCONSTR.DRespID()
    • DCONSTR.Lid()
    • DCONSTR.Rid()
    • DCONSTR.Uid()
    • DCONSTR.add_card()
    • DCONSTR.cross_reference()
    • DCONSTR.export_to_hdf5()
    • DCONSTR.raw_fields()
    • DCONSTR.repr_fields()
    • DCONSTR.type
    • DCONSTR.uncross_reference()
    • DCONSTR.write_card()
  • DDVAL
    • DDVAL._init_from_empty()
    • DDVAL.add_card()
    • DDVAL.raw_fields()
    • DDVAL.type
    • DDVAL.validate()
    • DDVAL.write_card()
  • DESVAR
    • DESVAR.DDVal()
    • DESVAR._properties
    • DESVAR.add_card()
    • DESVAR.add_card_lax()
    • DESVAR.cross_reference()
    • DESVAR.export_to_hdf5()
    • DESVAR.label
    • DESVAR.raw_fields()
    • DESVAR.repr_fields()
    • DESVAR.safe_cross_reference()
    • DESVAR.type
    • DESVAR.uncross_reference()
    • DESVAR.value
    • DESVAR.write_card()
  • DLINK
    • DLINK._init_from_empty()
    • DLINK.add_card()
    • DLINK.raw_fields()
    • DLINK.repr_fields()
    • DLINK.type
    • DLINK.write_card()
  • DOPTPRM
    • DOPTPRM._finalize_hdf5()
    • DOPTPRM._init_from_empty()
    • DOPTPRM.add_card()
    • DOPTPRM.defaults
    • DOPTPRM.raw_fields()
    • DOPTPRM.type
    • DOPTPRM.write_card()
  • DRESP1
    • DRESP1.Atta()
    • DRESP1.DRespID()
    • DRESP1.OptID()
    • DRESP1._elements()
    • DRESP1._nodes()
    • DRESP1._properties()
    • DRESP1.add_card()
    • DRESP1.atti_values()
    • DRESP1.calculate()
    • DRESP1.cross_reference()
    • DRESP1.export_to_hdf5()
    • DRESP1.raw_fields()
    • DRESP1.repr_fields()
    • DRESP1.safe_cross_reference()
    • DRESP1.type
    • DRESP1.uncross_reference()
    • DRESP1.write_card()
  • DRESP2
    • DRESP2.DEquation()
    • DRESP2.DRespID()
    • DRESP2.OptID()
    • DRESP2._pack()
    • DRESP2._pack_params()
    • DRESP2._validate()
    • DRESP2.add_card()
    • DRESP2.calculate()
    • DRESP2.cross_reference()
    • DRESP2.export_to_hdf5()
    • DRESP2.raw_fields()
    • DRESP2.repr_fields()
    • DRESP2.safe_cross_reference()
    • DRESP2.type
    • DRESP2.uncross_reference()
    • DRESP2.write_card()
  • DRESP3
    • DRESP3._pack()
    • DRESP3._pack_params()
    • DRESP3._validate()
    • DRESP3.add_card()
    • DRESP3.cross_reference()
    • DRESP3.export_to_hdf5()
    • DRESP3.raw_fields()
    • DRESP3.repr_fields()
    • DRESP3.safe_cross_reference()
    • DRESP3.type
    • DRESP3.uncross_reference()
    • DRESP3.write_card()
  • DSCREEN
    • DSCREEN._init_from_empty()
    • DSCREEN.add_card()
    • DSCREEN.nstr
    • DSCREEN.raw_fields()
    • DSCREEN.repr_fields()
    • DSCREEN.rtype
    • DSCREEN.trs
    • DSCREEN.type
    • DSCREEN.write_card()
  • DVCREL1
    • DVCREL1.Eid()
    • DVCREL1.OptID()
    • DVCREL1.Type
    • DVCREL1._get_element()
    • DVCREL1._init_from_empty()
    • DVCREL1._properties
    • DVCREL1._update_by_dvcrel()
    • DVCREL1.add_card()
    • DVCREL1.calculate()
    • DVCREL1.cross_reference()
    • DVCREL1.object_attributes()
    • DVCREL1.raw_fields()
    • DVCREL1.repr_fields()
    • DVCREL1.type
    • DVCREL1.uncross_reference()
    • DVCREL1.update_model()
    • DVCREL1.write_card()
  • DVCREL2
    • DVCREL2.DEquation()
    • DVCREL2.Eid()
    • DVCREL2.OptID()
    • DVCREL2.Type
    • DVCREL2._get_element()
    • DVCREL2._init_from_empty()
    • DVCREL2._properties
    • DVCREL2._update_by_dvcrel()
    • DVCREL2.add_card()
    • DVCREL2.allowed_elements
    • DVCREL2.calculate()
    • DVCREL2.cp_max
    • DVCREL2.cp_min
    • DVCREL2.cp_name
    • DVCREL2.cross_reference()
    • DVCREL2.eid
    • DVCREL2.element_type
    • DVCREL2.object_attributes()
    • DVCREL2.raw_fields()
    • DVCREL2.repr_fields()
    • DVCREL2.type
    • DVCREL2.uncross_reference()
    • DVCREL2.update_model()
    • DVCREL2.write_card()
  • DVGRID
    • DVGRID._init_from_empty()
    • DVGRID._properties
    • DVGRID.add_card()
    • DVGRID.coord_id
    • DVGRID.cross_reference()
    • DVGRID.desvar_id
    • DVGRID.node_id
    • DVGRID.raw_fields()
    • DVGRID.type
    • DVGRID.uncross_reference()
    • DVGRID.validate()
    • DVGRID.write_card()
  • DVMREL1
    • DVMREL1.Mid()
    • DVMREL1.OptID()
    • DVMREL1._init_from_empty()
    • DVMREL1._properties
    • DVMREL1._update_by_dvmrel()
    • DVMREL1.add_card()
    • DVMREL1.cross_reference()
    • DVMREL1.object_attributes()
    • DVMREL1.raw_fields()
    • DVMREL1.repr_fields()
    • DVMREL1.type
    • DVMREL1.uncross_reference()
    • DVMREL1.update_model()
    • DVMREL1.write_card()
  • DVMREL2
    • DVMREL2.DEquation()
    • DVMREL2.Mid()
    • DVMREL2.OptID()
    • DVMREL2._get_material()
    • DVMREL2._init_from_empty()
    • DVMREL2._properties
    • DVMREL2._update_by_dvmrel()
    • DVMREL2.add_card()
    • DVMREL2.allowed_materials
    • DVMREL2.calculate()
    • DVMREL2.cross_reference()
    • DVMREL2.mat_type
    • DVMREL2.mid
    • DVMREL2.mp_max
    • DVMREL2.mp_min
    • DVMREL2.mp_name
    • DVMREL2.object_attributes()
    • DVMREL2.raw_fields()
    • DVMREL2.repr_fields()
    • DVMREL2.safe_cross_reference()
    • DVMREL2.type
    • DVMREL2.uncross_reference()
    • DVMREL2.update_model()
    • DVMREL2.write_card()
  • DVPREL1
    • DVPREL1.OptID()
    • DVPREL1.Pid()
    • DVPREL1._get_property()
    • DVPREL1._init_from_empty()
    • DVPREL1._properties
    • DVPREL1._update_by_dvprel()
    • DVPREL1.add_card()
    • DVPREL1.allowed_elements
    • DVPREL1.allowed_masses
    • DVPREL1.allowed_properties
    • DVPREL1.allowed_properties_mass
    • DVPREL1.calculate()
    • DVPREL1.cross_reference()
    • DVPREL1.get_xinit_lower_upper_bound()
    • DVPREL1.raw_fields()
    • DVPREL1.repr_fields()
    • DVPREL1.safe_cross_reference()
    • DVPREL1.type
    • DVPREL1.uncross_reference()
    • DVPREL1.update_model()
    • DVPREL1.validate()
    • DVPREL1.write_card()
  • DVPREL2
    • DVPREL2.DEquation()
    • DVPREL2.OptID()
    • DVPREL2.Pid()
    • DVPREL2._get_property()
    • DVPREL2._init_from_empty()
    • DVPREL2._properties
    • DVPREL2._update_by_dvprel()
    • DVPREL2.add_card()
    • DVPREL2.allowed_elements
    • DVPREL2.allowed_masses
    • DVPREL2.allowed_properties
    • DVPREL2.allowed_properties_mass
    • DVPREL2.calculate()
    • DVPREL2.cross_reference()
    • DVPREL2.get_xinit_lower_upper_bound()
    • DVPREL2.p_max
    • DVPREL2.p_min
    • DVPREL2.pid
    • DVPREL2.pname_fid
    • DVPREL2.prop_type
    • DVPREL2.raw_fields()
    • DVPREL2.repr_fields()
    • DVPREL2.type
    • DVPREL2.uncross_reference()
    • DVPREL2.update_model()
    • DVPREL2.validate()
    • DVPREL2.write_card()
  • DVXREL1
    • DVXREL1.desvar_ids
    • DVXREL1.validate()
  • DVXREL2
    • DVXREL2._check_args()
    • DVXREL2.dequation
    • DVXREL2.desvar_ids
    • DVXREL2.oid
    • DVXREL2.validate()
  • OptConstraint
  • TOPVAR
    • TOPVAR.Pid()
    • TOPVAR.add_card()
    • TOPVAR.cross_reference()
    • TOPVAR.raw_fields()
    • TOPVAR.repr_fields()
    • TOPVAR.safe_cross_reference()
    • TOPVAR.type
    • TOPVAR.uncross_reference()
    • TOPVAR.write_card()
  • _blank_or_mode()
  • _check_dvcrel_options()
  • _check_dvmrel_options()
  • _check_dvprel_options()
  • _check_pbeam_pbeaml_allowable_attas()
  • _dresp_verify_eids()
  • _dresp_verify_prop()
  • _export_dresps_to_hdf5()
  • _get_desvar()
  • _get_dresp23_table_values()
  • _get_dtable_value()
  • _validate_dresp1_force()
  • _validate_dresp1_stress_strain()
  • _validate_dresp_property_none()
  • ddval_id()
  • get_deqatn_args()
  • get_deqatn_value()
  • get_dvprel_key()
  • get_dvxrel1_coeffs()
  • none_max()
  • none_min()
  • parse_table_fields()
  • table_int_float()
  • validate_dresp1()
  • validate_dvcrel()
  • validate_dvmrel()
  • validate_dvprel()
• params Module
  • MDLPRM
    • MDLPRM._init_from_empty()
    • MDLPRM.add_card()
    • MDLPRM.export_to_hdf5()
    • MDLPRM.load_hdf5_file()
    • MDLPRM.raw_fields()
    • MDLPRM.repr_fields()
    • MDLPRM.type
    • MDLPRM.write_card()
  • PARAM
    • PARAM._init_from_empty()
    • PARAM.add_card()
    • PARAM.raw_fields()
    • PARAM.repr_fields()
    • PARAM.type
    • PARAM.update_values()
    • PARAM.write_card()
  • PARAM_MYSTRAN
    • PARAM_MYSTRAN._init_from_empty()
    • PARAM_MYSTRAN.add_card()
    • PARAM_MYSTRAN.raw_fields()
    • PARAM_MYSTRAN.repr_fields()
    • PARAM_MYSTRAN.type
    • PARAM_MYSTRAN.write_card()
• superelements Module
  • CSUPER
    • CSUPER.add_card()
    • CSUPER.cross_reference()
    • CSUPER.node_ids
    • CSUPER.nodes
    • CSUPER.raw_fields()
    • CSUPER.safe_cross_reference()
    • CSUPER.type
    • CSUPER.uncross_reference()
    • CSUPER.write_card()
  • CSUPEXT
    • CSUPEXT.add_card()
    • CSUPEXT.cross_reference()
    • CSUPEXT.node_ids
    • CSUPEXT.nodes
    • CSUPEXT.raw_fields()
    • CSUPEXT.safe_cross_reference()
    • CSUPEXT.type
    • CSUPEXT.uncross_reference()
    • CSUPEXT.write_card()
  • RELEASE
    • RELEASE.add_card()
    • RELEASE.cross_reference()
    • RELEASE.nids
    • RELEASE.raw_fields()
    • RELEASE.safe_cross_reference()
    • RELEASE.type
    • RELEASE.uncross_reference()
    • RELEASE.write_card()
  • SEBNDRY
    • SEBNDRY.add_card()
    • SEBNDRY.cross_reference()
    • SEBNDRY.ids
    • SEBNDRY.raw_fields()
    • SEBNDRY.safe_cross_reference()
    • SEBNDRY.type
    • SEBNDRY.uncross_reference()
    • SEBNDRY.write_card()
  • SEBULK
    • SEBULK.add_card()
    • SEBULK.cross_reference()
    • SEBULK.raw_fields()
    • SEBULK.safe_cross_reference()
    • SEBULK.type
    • SEBULK.uncross_reference()
    • SEBULK.validate()
    • SEBULK.write_card()
  • SECONCT
    • SECONCT.add_card()
    • SECONCT.cross_reference()
    • SECONCT.node_ids_a
    • SECONCT.node_ids_b
    • SECONCT.raw_fields()
    • SECONCT.safe_cross_reference()
    • SECONCT.type
    • SECONCT.uncross_reference()
    • SECONCT.write_card()
  • SEELT
    • SEELT.add_card()
    • SEELT.cross_reference()
    • SEELT.eids
    • SEELT.raw_fields()
    • SEELT.safe_cross_reference()
    • SEELT.type
    • SEELT.uncross_reference()
    • SEELT.write_card()
  • SEEXCLD
    • SEEXCLD.add_card()
    • SEEXCLD.cross_reference()
    • SEEXCLD.node_ids
    • SEEXCLD.nodes
    • SEEXCLD.raw_fields()
    • SEEXCLD.safe_cross_reference()
    • SEEXCLD.type
    • SEEXCLD.uncross_reference()
    • SEEXCLD.write_card()
  • SELABEL
    • SELABEL.add_card()
    • SELABEL.cross_reference()
    • SELABEL.raw_fields()
    • SELABEL.repr_fields()
    • SELABEL.safe_cross_reference()
    • SELABEL.type
    • SELABEL.uncross_reference()
    • SELABEL.validate()
    • SELABEL.write_card()
  • SELOAD
    • SELOAD.add_card()
    • SELOAD.cross_reference()
    • SELOAD.raw_fields()
    • SELOAD.safe_cross_reference()
    • SELOAD.type
    • SELOAD.uncross_reference()
    • SELOAD.write_card()
  • SELOC
    • SELOC.add_card()
    • SELOC.cross_reference()
    • SELOC.nodes_0
    • SELOC.nodes_0_ids
    • SELOC.nodes_seid_ids
    • SELOC.raw_fields()
    • SELOC.safe_cross_reference()
    • SELOC.transform()
    • SELOC.type
    • SELOC.uncross_reference()
    • SELOC.write_card()
  • SEMPLN
    • SEMPLN.add_card()
    • SEMPLN.cross_reference()
    • SEMPLN.node_ids
    • SEMPLN.raw_fields()
    • SEMPLN.safe_cross_reference()
    • SEMPLN.type
    • SEMPLN.uncross_reference()
    • SEMPLN.write_card()
  • SENQSET
    • SENQSET.add_card()
    • SENQSET.raw_fields()
    • SENQSET.type
    • SENQSET.write_card()
  • SETREE
    • SETREE.add_card()
    • SETREE.cross_reference()
    • SETREE.raw_fields()
    • SETREE.safe_cross_reference()
    • SETREE.superelements
    • SETREE.type
    • SETREE.uncross_reference()
    • SETREE.write_card()
• utils Module
  • build_table_lines()
  • wipe_empty_fields()
  • wipe_empty_fields_str()
• deqatn Module
  • DEQATN
    • DEQATN._init_from_empty()
    • DEQATN._properties
    • DEQATN._setup_equation()
    • DEQATN.add_card()
    • DEQATN.cross_reference()
    • DEQATN.evaluate()
    • DEQATN.raw_fields()
    • DEQATN.repr_fields()
    • DEQATN.safe_cross_reference()
    • DEQATN.type
    • DEQATN.uncross_reference()
    • DEQATN.write_card()
  • _get_ta()
  • _join_wrapped_equation_lines()
  • _setup_deqatn()
  • _split_equation()
  • _split_equations_by_semicolon()
  • _write_comment()
  • _write_function_line()
  • _write_variables()
  • atan2h()
  • avg()
  • db()
  • dba()
  • dim()
  • fortran_to_python()
  • fortran_to_python_short()
  • invdb()
  • invdba()
  • lines_to_eqs()
  • logx()
  • pi()
  • rss()
  • split_deqatn_line0()
  • split_equations()
  • split_to_equations()
  • ssq()
  • write_deqatn()
  • write_function_header()

aero Package

• aero Module
  • AECOMP
    • AECOMP._init_from_empty()
    • AECOMP.add_card()
    • AECOMP.allowed_list_types
    • AECOMP.cross_reference()
    • AECOMP.get_lists()
    • AECOMP.raw_fields()
    • AECOMP.safe_cross_reference()
    • AECOMP.type
    • AECOMP.uncross_reference()
    • AECOMP.validate()
    • AECOMP.write_card()
  • AECOMPL
    • AECOMPL._init_from_empty()
    • AECOMPL.add_card()
    • AECOMPL.cross_reference()
    • AECOMPL.raw_fields()
    • AECOMPL.safe_cross_reference()
    • AECOMPL.type
    • AECOMPL.uncross_reference()
    • AECOMPL.write_card()
  • AEFACT
    • AEFACT._init_from_empty()
    • AEFACT.add_card()
    • AEFACT.fractions
    • AEFACT.raw_fields()
    • AEFACT.sid
    • AEFACT.type
    • AEFACT.write_card()
  • AELINK
    • AELINK._init_from_empty()
    • AELINK.add_card()
    • AELINK.aelink_id
    • AELINK.cross_reference()
    • AELINK.dependent_label
    • AELINK.independent_labels
    • AELINK.label
    • AELINK.linking_coefficients
    • AELINK.raw_fields()
    • AELINK.type
    • AELINK.validate()
    • AELINK.write_card()
  • AELIST
    • AELIST._init_from_empty()
    • AELIST.add_card()
    • AELIST.clean_ids()
    • AELIST.cross_reference()
    • AELIST.elements
    • AELIST.raw_fields()
    • AELIST.safe_cross_reference()
    • AELIST.sid
    • AELIST.type
    • AELIST.uncross_reference()
    • AELIST.write_card()
  • AEPARM
    • AEPARM._init_from_empty()
    • AEPARM.add_card()
    • AEPARM.cross_reference()
    • AEPARM.raw_fields()
    • AEPARM.safe_cross_reference()
    • AEPARM.type
    • AEPARM.uncross_reference()
    • AEPARM.write_card()
  • AESURF
    • AESURF.Aelist_id1()
    • AESURF.Aelist_id2()
    • AESURF.Cid1()
    • AESURF.Cid2()
    • AESURF._init_from_empty()
    • AESURF.add_card()
    • AESURF.aelist_id1
    • AESURF.aesurf_id
    • AESURF.cid1
    • AESURF.crefc
    • AESURF.crefs
    • AESURF.cross_reference()
    • AESURF.eff
    • AESURF.hmllim
    • AESURF.label
    • AESURF.ldw
    • AESURF.pllim
    • AESURF.raw_fields()
    • AESURF.repr_fields()
    • AESURF.safe_cross_reference()
    • AESURF.tqllim
    • AESURF.type
    • AESURF.uncross_reference()
    • AESURF.update()
    • AESURF.write_card()
  • AESURFS
    • AESURFS.Label()
    • AESURFS.List1()
    • AESURFS.List2()
    • AESURFS._init_from_empty()
    • AESURFS.add_card()
    • AESURFS.cross_reference()
    • AESURFS.raw_fields()
    • AESURFS.safe_cross_reference()
    • AESURFS.type
    • AESURFS.uncross_reference()
    • AESURFS.write_card()
  • AeroPaneling
    • AeroPaneling._asdict()
    • AeroPaneling._field_defaults
    • AeroPaneling._fields
    • AeroPaneling._make()
    • AeroPaneling._replace()
    • AeroPaneling.box_id_to_caero_element_map
    • AeroPaneling.caero_points
    • AeroPaneling.cs_box_ids
    • AeroPaneling.has_caero
    • AeroPaneling.has_control_surface
    • AeroPaneling.ncaero_sub_points
    • AeroPaneling.ncaeros
    • AeroPaneling.ncaeros_cs
    • AeroPaneling.ncaeros_points
    • AeroPaneling.ncaeros_sub
  • CAERO1
    • CAERO1.Cp()
    • CAERO1.Pid()
    • CAERO1._box_id_error()
    • CAERO1._finalize_hdf5()
    • CAERO1._get_box_x_chord_center()
    • CAERO1._init_from_empty()
    • CAERO1._init_ids()
    • CAERO1._properties
    • CAERO1.add_card()
    • CAERO1.add_quad()
    • CAERO1.aefact_ids
    • CAERO1.area()
    • CAERO1.cp
    • CAERO1.cross_reference()
    • CAERO1.eid
    • CAERO1.flip_normal()
    • CAERO1.generic_split()
    • CAERO1.get_LChord()
    • CAERO1.get_LSpan()
    • CAERO1.get_box_index()
    • CAERO1.get_box_mid_chord_center()
    • CAERO1.get_box_quarter_chord_center()
    • CAERO1.get_dlm_box_properties()
    • CAERO1.get_leading_edge_points()
    • CAERO1.get_panel_npoints_nelements()
    • CAERO1.get_points()
    • CAERO1.min_max_eid
    • CAERO1.npanels
    • CAERO1.panel_integration_point()
    • CAERO1.panel_points_elements()
    • CAERO1.pid
    • CAERO1.plot()
    • CAERO1.raw_fields()
    • CAERO1.repr_fields()
    • CAERO1.safe_cross_reference()
    • CAERO1.set_points()
    • CAERO1.shape
    • CAERO1.shift()
    • CAERO1.span_chord_split()
    • CAERO1.span_split()
    • CAERO1.type
    • CAERO1.uncross_reference()
    • CAERO1.update()
    • CAERO1.validate()
    • CAERO1.write_card()
    • CAERO1.xy
  • CAERO2
    • CAERO2.Cp()
    • CAERO2.Lint()
    • CAERO2.Lsb()
    • CAERO2.Pid()
    • CAERO2._init_from_empty()
    • CAERO2._init_ids()
    • CAERO2._properties
    • CAERO2.add_card()
    • CAERO2.aefact_ids
    • CAERO2.cp
    • CAERO2.cross_reference()
    • CAERO2.eid
    • CAERO2.get_leading_edge_points()
    • CAERO2.get_panel_npoints_nelements()
    • CAERO2.get_points()
    • CAERO2.get_points_elements_3d()
    • CAERO2.get_station()
    • CAERO2.igroup
    • CAERO2.lint
    • CAERO2.lsb
    • CAERO2.nboxes
    • CAERO2.nint
    • CAERO2.nsb
    • CAERO2.p1
    • CAERO2.pid
    • CAERO2.raw_fields()
    • CAERO2.repr_fields()
    • CAERO2.safe_cross_reference()
    • CAERO2.set_points()
    • CAERO2.shift()
    • CAERO2.type
    • CAERO2.uncross_reference()
    • CAERO2.validate()
    • CAERO2.write_card()
    • CAERO2.x12
  • CAERO3
    • CAERO3.Cp()
    • CAERO3.List_c1()
    • CAERO3.List_c2()
    • CAERO3.List_w()
    • CAERO3.Pid()
    • CAERO3._init_from_empty()
    • CAERO3._init_ids()
    • CAERO3._properties
    • CAERO3.add_card()
    • CAERO3.area()
    • CAERO3.cp
    • CAERO3.cross_reference()
    • CAERO3.eid
    • CAERO3.get_panel_npoints_nelements()
    • CAERO3.get_points()
    • CAERO3.panel_points_elements()
    • CAERO3.pid
    • CAERO3.plot()
    • CAERO3.raw_fields()
    • CAERO3.repr_fields()
    • CAERO3.safe_cross_reference()
    • CAERO3.shape
    • CAERO3.type
    • CAERO3.uncross_reference()
    • CAERO3.validate()
    • CAERO3.write_card()
    • CAERO3.xy
  • CAERO4
    • CAERO4.Cp()
    • CAERO4.Pid()
    • CAERO4._init_from_empty()
    • CAERO4._init_ids()
    • CAERO4._properties
    • CAERO4.add_card()
    • CAERO4.cp
    • CAERO4.cross_reference()
    • CAERO4.eid
    • CAERO4.get_LSpan()
    • CAERO4.get_panel_npoints_nelements()
    • CAERO4.get_points()
    • CAERO4.panel_points_elements()
    • CAERO4.pid
    • CAERO4.plot()
    • CAERO4.raw_fields()
    • CAERO4.repr_fields()
    • CAERO4.safe_cross_reference()
    • CAERO4.shape
    • CAERO4.type
    • CAERO4.uncross_reference()
    • CAERO4.validate()
    • CAERO4.write_card()
    • CAERO4.xy
  • CAERO5
    • CAERO5.Cp()
    • CAERO5.LSpan()
    • CAERO5.Pid()
    • CAERO5._init_from_empty()
    • CAERO5._init_ids()
    • CAERO5.add_card()
    • CAERO5.c1_c2()
    • CAERO5.cp
    • CAERO5.cross_reference()
    • CAERO5.eid
    • CAERO5.get_panel_npoints_nelements()
    • CAERO5.get_points()
    • CAERO5.nboxes
    • CAERO5.panel_points_elements()
    • CAERO5.pid
    • CAERO5.plot()
    • CAERO5.raw_fields()
    • CAERO5.repr_fields()
    • CAERO5.safe_cross_reference()
    • CAERO5.type
    • CAERO5.uncross_reference()
    • CAERO5.validate()
    • CAERO5.write_card()
  • MONDSP1
    • MONDSP1.Cd()
    • MONDSP1.Cp()
    • MONDSP1._init_from_empty()
    • MONDSP1.add_card()
    • MONDSP1.cross_reference()
    • MONDSP1.raw_fields()
    • MONDSP1.safe_cross_reference()
    • MONDSP1.type
    • MONDSP1.uncross_reference()
    • MONDSP1.write_card()
  • MONPNT1
    • MONPNT1.Cd()
    • MONPNT1.Cp()
    • MONPNT1._init_from_empty()
    • MONPNT1.add_card()
    • MONPNT1.cross_reference()
    • MONPNT1.raw_fields()
    • MONPNT1.safe_cross_reference()
    • MONPNT1.type
    • MONPNT1.uncross_reference()
    • MONPNT1.write_card()
  • MONPNT2
    • MONPNT2._init_from_empty()
    • MONPNT2.add_card()
    • MONPNT2.cross_reference()
    • MONPNT2.raw_fields()
    • MONPNT2.safe_cross_reference()
    • MONPNT2.type
    • MONPNT2.uncross_reference()
    • MONPNT2.validate()
    • MONPNT2.write_card()
  • MONPNT3
    • MONPNT3.Cd()
    • MONPNT3.Cp()
    • MONPNT3._init_from_empty()
    • MONPNT3.add_card()
    • MONPNT3.cross_reference()
    • MONPNT3.get_elem_set_group()
    • MONPNT3.get_node_set_group()
    • MONPNT3.raw_fields()
    • MONPNT3.safe_cross_reference()
    • MONPNT3.type
    • MONPNT3.uncross_reference()
    • MONPNT3.write_card()
  • PAERO1
    • PAERO1._init_from_empty()
    • PAERO1._properties
    • PAERO1.add_card()
    • PAERO1.cross_reference()
    • PAERO1.get_caero_body_ids()
    • PAERO1.raw_fields()
    • PAERO1.safe_cross_reference()
    • PAERO1.type
    • PAERO1.uncross_reference()
    • PAERO1.write_card()
  • PAERO2
    • PAERO2.AR
    • PAERO2.Lrib()
    • PAERO2.Lrsb()
    • PAERO2._init_from_empty()
    • PAERO2._properties
    • PAERO2.add_card()
    • PAERO2.cross_reference()
    • PAERO2.lrib
    • PAERO2.lrsb
    • PAERO2.lth1
    • PAERO2.lth2
    • PAERO2.orient
    • PAERO2.pid
    • PAERO2.raw_fields()
    • PAERO2.safe_cross_reference()
    • PAERO2.type
    • PAERO2.uncross_reference()
    • PAERO2.validate()
    • PAERO2.width
    • PAERO2.write_card()
  • PAERO3
    • PAERO3._init_from_empty()
    • PAERO3._properties
    • PAERO3.add_card()
    • PAERO3.cross_reference()
    • PAERO3.npoints
    • PAERO3.pid
    • PAERO3.raw_fields()
    • PAERO3.safe_cross_reference()
    • PAERO3.type
    • PAERO3.uncross_reference()
    • PAERO3.validate()
    • PAERO3.write_card()
  • PAERO4
    • PAERO4._init_from_empty()
    • PAERO4.add_card()
    • PAERO4.cross_reference()
    • PAERO4.pid
    • PAERO4.raw_fields()
    • PAERO4.safe_cross_reference()
    • PAERO4.type
    • PAERO4.uncross_reference()
    • PAERO4.write_card()
  • PAERO5
    • PAERO5._init_from_empty()
    • PAERO5._properties
    • PAERO5.add_card()
    • PAERO5.cross_reference()
    • PAERO5.ltaus_id
    • PAERO5.lxis_id
    • PAERO5.raw_fields()
    • PAERO5.repr_fields()
    • PAERO5.safe_cross_reference()
    • PAERO5.type
    • PAERO5.uncross_reference()
    • PAERO5.write_card()
  • SPLINE1
    • SPLINE1.CAero()
    • SPLINE1.Set()
    • SPLINE1._init_from_empty()
    • SPLINE1._properties
    • SPLINE1.add_card()
    • SPLINE1.aero_element_ids
    • SPLINE1.cross_reference()
    • SPLINE1.raw_fields()
    • SPLINE1.repr_fields()
    • SPLINE1.safe_cross_reference()
    • SPLINE1.type
    • SPLINE1.uncross_reference()
    • SPLINE1.validate()
    • SPLINE1.write_card()
  • SPLINE2
    • SPLINE2.CAero()
    • SPLINE2.Cid()
    • SPLINE2.Set()
    • SPLINE2._init_from_empty()
    • SPLINE2._properties
    • SPLINE2.add_card()
    • SPLINE2.aero_element_ids
    • SPLINE2.cross_reference()
    • SPLINE2.raw_fields()
    • SPLINE2.repr_fields()
    • SPLINE2.safe_cross_reference()
    • SPLINE2.type
    • SPLINE2.uncross_reference()
    • SPLINE2.validate()
    • SPLINE2.write_card()
  • SPLINE3
    • SPLINE3.CAero()
    • SPLINE3._init_from_empty()
    • SPLINE3._properties
    • SPLINE3.add_card()
    • SPLINE3.cross_reference()
    • SPLINE3.node_ids
    • SPLINE3.raw_fields()
    • SPLINE3.safe_cross_reference()
    • SPLINE3.type
    • SPLINE3.uncross_reference()
    • SPLINE3.validate()
    • SPLINE3.write_card()
  • SPLINE4
    • SPLINE4.AEList()
    • SPLINE4.CAero()
    • SPLINE4.Set()
    • SPLINE4._init_from_empty()
    • SPLINE4._properties
    • SPLINE4.add_card()
    • SPLINE4.aero_element_ids
    • SPLINE4.cross_reference()
    • SPLINE4.raw_fields()
    • SPLINE4.repr_fields()
    • SPLINE4.safe_cross_reference()
    • SPLINE4.type
    • SPLINE4.uncross_reference()
    • SPLINE4.validate()
    • SPLINE4.write_card()
  • SPLINE5
    • SPLINE5.AEList()
    • SPLINE5.CAero()
    • SPLINE5.Cid()
    • SPLINE5.Set()
    • SPLINE5._init_from_empty()
    • SPLINE5._properties
    • SPLINE5.add_card()
    • SPLINE5.aero_element_ids
    • SPLINE5.cross_reference()
    • SPLINE5.raw_fields()
    • SPLINE5.repr_fields()
    • SPLINE5.safe_cross_reference()
    • SPLINE5.type
    • SPLINE5.uncross_reference()
    • SPLINE5.validate()
    • SPLINE5.write_card()
  • Spline
  • build_caero_paneling()
  • get_caero_box_grid()
  • get_caero_count()
  • get_caero_points()
  • safe_xref_set_group()
  • xref_set_group()
• static_loads Module
  • AEDW
    • AEDW._init_from_empty()
    • AEDW.add_card()
    • AEDW.cross_reference()
    • AEDW.raw_fields()
    • AEDW.type
    • AEDW.write_card()
  • AEFORCE
    • AEFORCE._init_from_empty()
    • AEFORCE.add_card()
    • AEFORCE.cross_reference()
    • AEFORCE.raw_fields()
    • AEFORCE.type
    • AEFORCE.write_card()
  • AEPRESS
    • AEPRESS._init_from_empty()
    • AEPRESS.add_card()
    • AEPRESS.cross_reference()
    • AEPRESS.raw_fields()
    • AEPRESS.type
    • AEPRESS.write_card()
  • AEROS
    • AEROS.Acsid()
    • AEROS.Rcsid()
    • AEROS._init_from_empty()
    • AEROS._properties
    • AEROS.acsid
    • AEROS.add_card()
    • AEROS.bref
    • AEROS.cref
    • AEROS.cross_reference()
    • AEROS.raw_fields()
    • AEROS.rcsid
    • AEROS.repr_fields()
    • AEROS.safe_cross_reference()
    • AEROS.sref
    • AEROS.sym_xy
    • AEROS.sym_xz
    • AEROS.type
    • AEROS.uncross_reference()
    • AEROS.update()
    • AEROS.validate()
    • AEROS.write_card()
  • AESTAT
    • AESTAT._init_from_empty()
    • AESTAT.add_card()
    • AESTAT.raw_fields()
    • AESTAT.type
    • AESTAT.write_card()
  • CSSCHD
    • CSSCHD.AESurf()
    • CSSCHD.LAlpha()
    • CSSCHD.LMach()
    • CSSCHD.LSchd()
    • CSSCHD._init_from_empty()
    • CSSCHD._properties
    • CSSCHD.add_card()
    • CSSCHD.cross_reference()
    • CSSCHD.raw_fields()
    • CSSCHD.safe_cross_reference()
    • CSSCHD.type
    • CSSCHD.uncross_reference()
    • CSSCHD.validate()
    • CSSCHD.write_card()
  • DIVERG
    • DIVERG._init_from_empty()
    • DIVERG.add_card()
    • DIVERG.raw_fields()
    • DIVERG.type
    • DIVERG.write_card()
  • TRIM
    • TRIM._init_from_empty()
    • TRIM.add_card()
    • TRIM.aeqr
    • TRIM.cross_reference()
    • TRIM.labels
    • TRIM.mach
    • TRIM.q
    • TRIM.raw_fields()
    • TRIM.repr_fields()
    • TRIM.safe_cross_reference()
    • TRIM.sid
    • TRIM.type
    • TRIM.uncross_reference()
    • TRIM.uxs
    • TRIM.validate()
    • TRIM.verify_trim()
    • TRIM.write_card()
  • TRIM2
    • TRIM2._init_from_empty()
    • TRIM2.add_card()
    • TRIM2.raw_fields()
    • TRIM2.repr_fields()
    • TRIM2.type
  • UXVEC
    • UXVEC._init_from_empty()
    • UXVEC.add_card()
    • UXVEC.raw_fields()
    • UXVEC.type
    • UXVEC.write_card()
  • _fill_label_list()
  • check_aestats_suport_dofs()
  • get_suport1_dofs()
  • get_suport_dofs()
• dynamic_loads Module
  • AERO
    • AERO._init_from_empty()
    • AERO._properties
    • AERO.add_card()
    • AERO.cref
    • AERO.cross_reference()
    • AERO.raw_fields()
    • AERO.repr_fields()
    • AERO.rho_ref
    • AERO.safe_cross_reference()
    • AERO.sym_xy
    • AERO.sym_xz
    • AERO.type
    • AERO.uncross_reference()
    • AERO.update()
    • AERO.validate()
    • AERO.velocity
    • AERO.write_card()
  • Aero
    • Aero.Acsid()
    • Aero.is_anti_symmetric_xy
    • Aero.is_anti_symmetric_xz
    • Aero.is_symmetric_xy
    • Aero.is_symmetric_xz
    • Aero.set_ground_effect()
  • FLFACT
    • FLFACT._init_from_empty()
    • FLFACT.add_card()
    • FLFACT.max()
    • FLFACT.min()
    • FLFACT.raw_fields()
    • FLFACT.type
    • FLFACT.validate()
    • FLFACT.write_card()
  • FLUTTER
    • FLUTTER._get_raw_nvalue_omax()
    • FLUTTER._get_repr_nvalue_omax()
    • FLUTTER._init_from_empty()
    • FLUTTER._properties
    • FLUTTER.add_card()
    • FLUTTER.cross_reference()
    • FLUTTER.get_density()
    • FLUTTER.get_mach()
    • FLUTTER.get_rfreq_vel()
    • FLUTTER.headers
    • FLUTTER.make_flfacts_alt_sweep_constant_mach()
    • FLUTTER.make_flfacts_alt_sweep_constant_tas()
    • FLUTTER.make_flfacts_eas_sweep_constant_alt()
    • FLUTTER.make_flfacts_eas_sweep_constant_mach()
    • FLUTTER.make_flfacts_mach_sweep_constant_alt()
    • FLUTTER.make_flfacts_tas_sweep_constant_alt()
    • FLUTTER.raw_fields()
    • FLUTTER.repr_fields()
    • FLUTTER.safe_cross_reference()
    • FLUTTER.type
    • FLUTTER.uncross_reference()
    • FLUTTER.validate()
    • FLUTTER.write_card()
  • GUST
    • GUST._init_from_empty()
    • GUST.add_card()
    • GUST.get_dryden_psd()
    • GUST.get_von_karman_psd()
    • GUST.raw_fields()
    • GUST.type
    • GUST.write_card()
  • MKAERO1
    • MKAERO1._init_from_empty()
    • MKAERO1.add_card()
    • MKAERO1.mklist()
    • MKAERO1.raw_fields()
    • MKAERO1.type
    • MKAERO1.validate()
    • MKAERO1.write_card()
  • MKAERO2
    • MKAERO2._init_from_empty()
    • MKAERO2.add_card()
    • MKAERO2.mklist()
    • MKAERO2.raw_fields()
    • MKAERO2.type
    • MKAERO2.validate()
    • MKAERO2.write_card()
  • dryden_psd()
  • gust_function()
  • von_karman_psd()
• utils Module
  • build_trim_load_cases()
  • create_axisymmetric_body()
  • create_ellipse()
  • elements_from_quad()
  • make_monpnt1s_from_cids()
  • points_elements_from_quad_points()
  • tri_cap()
• zona Module

elements Package

• axisymmetric Module
• axisymmetric_shells Module
  • CQUADX
    • CQUADX.Thickness()
    • CQUADX.add_card()
    • CQUADX.cross_reference()
    • CQUADX.eid
    • CQUADX.export_to_hdf5()
    • CQUADX.flip_normal()
    • CQUADX.node_ids
    • CQUADX.raw_fields()
    • CQUADX.repr_fields()
    • CQUADX.safe_cross_reference()
    • CQUADX.type
    • CQUADX.uncross_reference()
    • CQUADX.write_card()
  • CQUADX4
    • CQUADX4.add_card()
    • CQUADX4.cross_reference()
    • CQUADX4.eid
    • CQUADX4.export_to_hdf5()
    • CQUADX4.flip_normal()
    • CQUADX4.node_ids
    • CQUADX4.raw_fields()
    • CQUADX4.repr_fields()
    • CQUADX4.safe_cross_reference()
    • CQUADX4.type
    • CQUADX4.uncross_reference()
    • CQUADX4.write_card()
  • CQUADX8
    • CQUADX8.Mass()
    • CQUADX8.Normal()
    • CQUADX8.add_card()
    • CQUADX8.cross_reference()
    • CQUADX8.eid
    • CQUADX8.export_to_hdf5()
    • CQUADX8.flip_normal()
    • CQUADX8.node_ids
    • CQUADX8.raw_fields()
    • CQUADX8.repr_fields()
    • CQUADX8.safe_cross_reference()
    • CQUADX8.type
    • CQUADX8.uncross_reference()
    • CQUADX8.write_card()
  • CTRAX3
    • CTRAX3.Area()
    • CTRAX3.AreaCentroidNormal()
    • CTRAX3.Mass()
    • CTRAX3.add_card()
    • CTRAX3.cross_reference()
    • CTRAX3.eid
    • CTRAX3.export_to_hdf5()
    • CTRAX3.flip_normal()
    • CTRAX3.node_ids
    • CTRAX3.raw_fields()
    • CTRAX3.repr_fields()
    • CTRAX3.safe_cross_reference()
    • CTRAX3.type
    • CTRAX3.uncross_reference()
    • CTRAX3.write_card()
  • CTRAX6
    • CTRAX6.Area()
    • CTRAX6.AreaCentroidNormal()
    • CTRAX6.add_card()
    • CTRAX6.cross_reference()
    • CTRAX6.eid
    • CTRAX6.export_to_hdf5()
    • CTRAX6.flip_normal()
    • CTRAX6.node_ids
    • CTRAX6.raw_fields()
    • CTRAX6.repr_fields()
    • CTRAX6.safe_cross_reference()
    • CTRAX6.type
    • CTRAX6.uncross_reference()
    • CTRAX6.write_card()
  • CTRIAX
    • CTRIAX.Area()
    • CTRIAX.AreaCentroidNormal()
    • CTRIAX.add_card()
    • CTRIAX.cross_reference()
    • CTRIAX.eid
    • CTRIAX.export_to_hdf5()
    • CTRIAX.flip_normal()
    • CTRIAX.node_ids
    • CTRIAX.raw_fields()
    • CTRIAX.repr_fields()
    • CTRIAX.safe_cross_reference()
    • CTRIAX.type
    • CTRIAX.uncross_reference()
    • CTRIAX.write_card()
  • CTRIAX6
    • CTRIAX6.Area()
    • CTRIAX6.AreaCentroidNormal()
    • CTRIAX6.Centroid()
    • CTRIAX6.Mass()
    • CTRIAX6.MassPerArea()
    • CTRIAX6.Mid()
    • CTRIAX6.Normal()
    • CTRIAX6.Nsm()
    • CTRIAX6.Pid()
    • CTRIAX6.add_card()
    • CTRIAX6.cross_reference()
    • CTRIAX6.eid
    • CTRIAX6.export_to_hdf5()
    • CTRIAX6.flip_normal()
    • CTRIAX6.get_edge_ids()
    • CTRIAX6.node_ids
    • CTRIAX6.pid
    • CTRIAX6.raw_fields()
    • CTRIAX6.repr_fields()
    • CTRIAX6.safe_cross_reference()
    • CTRIAX6.theta
    • CTRIAX6.type
    • CTRIAX6.uncross_reference()
    • CTRIAX6.write_card()
• bars Module
  • BAROR
    • BAROR._init_from_empty()
    • BAROR.add_card()
    • BAROR.raw_fields()
    • BAROR.type
    • BAROR.write_card()
  • CBAR
    • CBAR.Area()
    • CBAR.Centroid()
    • CBAR.G0()
    • CBAR.Ga()
    • CBAR.Gb()
    • CBAR.I1()
    • CBAR.I2()
    • CBAR.J()
    • CBAR.Length()
    • CBAR.Mid()
    • CBAR.Nsm()
    • CBAR.add_card()
    • CBAR.center_of_mass()
    • CBAR.cross_reference()
    • CBAR.export_to_hdf5()
    • CBAR.get_axes()
    • CBAR.get_axes_by_nodes()
    • CBAR.get_edge_ids()
    • CBAR.get_orientation_vector()
    • CBAR.get_x_g0_defaults()
    • CBAR.node_ids
    • CBAR.nodes
    • CBAR.nodes_ref
    • CBAR.raw_fields()
    • CBAR.repr_fields()
    • CBAR.safe_cross_reference()
    • CBAR.type
    • CBAR.uncross_reference()
    • CBAR.update_by_cp_name()
    • CBAR.validate()
    • CBAR.write_card()
    • CBAR.write_card_16()
  • CBARAO
    • CBARAO._init_from_empty()
    • CBARAO.add_card()
    • CBARAO.raw_fields()
    • CBARAO.repr_fields()
    • CBARAO.type
    • CBARAO.write_card()
  • CBEAM3
    • CBEAM3.Area()
    • CBEAM3.Centroid()
    • CBEAM3.G0()
    • CBEAM3.Ga()
    • CBEAM3.Gb()
    • CBEAM3.Gc()
    • CBEAM3.Length()
    • CBEAM3.MassPerLength()
    • CBEAM3.Nsm()
    • CBEAM3.Volume()
    • CBEAM3._init_from_empty()
    • CBEAM3._integrate()
    • CBEAM3._properties
    • CBEAM3.add_card()
    • CBEAM3.center_of_mass()
    • CBEAM3.cross_reference()
    • CBEAM3.get_edge_ids()
    • CBEAM3.get_x_g0_defaults()
    • CBEAM3.node_ids
    • CBEAM3.nodes
    • CBEAM3.raw_fields()
    • CBEAM3.repr_fields()
    • CBEAM3.safe_cross_reference()
    • CBEAM3.type
    • CBEAM3.uncross_reference()
    • CBEAM3.write_card()
  • CBEND
    • CBEND.Area()
    • CBEND.Centroid()
    • CBEND.Ga()
    • CBEND.Gb()
    • CBEND.Length()
    • CBEND._init_from_empty()
    • CBEND._properties
    • CBEND.add_card()
    • CBEND.center_of_mass()
    • CBEND.cross_reference()
    • CBEND.get_x_g0_defaults()
    • CBEND.make_circle()
    • CBEND.make_circle2()
    • CBEND.node_ids
    • CBEND.nodes
    • CBEND.nodes_ref
    • CBEND.plot()
    • CBEND.raw_fields()
    • CBEND.repr_fields()
    • CBEND.safe_cross_reference()
    • CBEND.type
    • CBEND.uncross_reference()
    • CBEND.validate()
    • CBEND.write_card()
  • LineElement
    • LineElement.Area()
    • LineElement.C()
    • LineElement.E()
    • LineElement.G()
    • LineElement.I11()
    • LineElement.I12()
    • LineElement.I22()
    • LineElement.J()
    • LineElement.Length()
    • LineElement.Mass()
    • LineElement.MassPerLength()
    • LineElement.Nsm()
    • LineElement.Nu()
    • LineElement.Rho()
    • LineElement.get_edge_ids()
    • LineElement.pid_ref
    • LineElement.uncross_reference()
  • check_offt()
  • get_bar_vector()
  • get_bar_yz_transform()
  • init_x_g0()
  • init_x_g0_cbeam3()
  • rotate_v_wa_wb()
• beam Module
  • BEAMOR
    • BEAMOR._init_from_empty()
    • BEAMOR.add_card()
    • BEAMOR.raw_fields()
    • BEAMOR.type
    • BEAMOR.write_card()
  • CBEAM
    • CBEAM.Area()
    • CBEAM.Centroid()
    • CBEAM.G0()
    • CBEAM.Ga()
    • CBEAM.Gb()
    • CBEAM.Mid()
    • CBEAM.Nodes()
    • CBEAM.Nsm()
    • CBEAM.add_card()
    • CBEAM.center_of_mass()
    • CBEAM.center_of_mass_xform()
    • CBEAM.cross_reference()
    • CBEAM.export_to_hdf5()
    • CBEAM.ga
    • CBEAM.ga_ref
    • CBEAM.gb
    • CBEAM.gb_ref
    • CBEAM.get_axes()
    • CBEAM.get_axes_by_nodes()
    • CBEAM.get_edge_ids()
    • CBEAM.get_offt_bit_defaults()
    • CBEAM.get_orientation_vector()
    • CBEAM.get_x_g0_defaults()
    • CBEAM.is_bit
    • CBEAM.is_offt
    • CBEAM.node_ids
    • CBEAM.raw_fields()
    • CBEAM.repr_fields()
    • CBEAM.safe_cross_reference()
    • CBEAM.type
    • CBEAM.uncross_reference()
    • CBEAM.validate()
    • CBEAM.write_card()
    • CBEAM.write_card_16()
  • _init_offt_bit()
• beam_connectivity Module
  • bar_faces()
  • bar_setup()
  • box_faces()
  • box_setup()
  • chan1_faces()
  • chan1_setup()
  • chan_faces()
  • chan_setup()
  • h_faces()
  • h_setup()
  • hat_faces()
  • hat_setup()
  • hexa_faces()
  • hexa_setup()
  • i1_faces()
  • i1_setup()
  • i_faces()
  • i_setup()
  • l_faces()
  • l_setup()
  • rod_faces()
  • rod_setup()
  • t1_faces()
  • t1_setup()
  • t2_faces()
  • t2_setup()
  • t_faces()
  • t_setup()
  • tube_faces()
  • tube_setup()
  • z_faces()
  • z_setup()
• beam_line_connectivity Module
  • bar_lines()
  • box_lines()
  • chan1_lines()
  • chan_faces()
  • h_lines()
  • hat_lines()
  • hexa_lines()
  • i1_lines()
  • i_lines()
  • l_lines()
  • rod_faces()
  • t1_lines()
  • t2_lines()
  • t_lines()
  • tube_faces()
  • z_lines()
• bush Module
  • BushElement
    • BushElement.Cid()
    • BushElement.Mass()
    • BushElement.get_edge_ids()
  • CBUSH
    • CBUSH.Centroid()
    • CBUSH.Cid()
    • CBUSH.G0()
    • CBUSH.Ga()
    • CBUSH.Gb()
    • CBUSH.Length()
    • CBUSH.OCid()
    • CBUSH._get_x_g0()
    • CBUSH._properties
    • CBUSH.add_card()
    • CBUSH.cross_reference()
    • CBUSH.element_coordinate_system()
    • CBUSH.export_to_hdf5()
    • CBUSH.node_ids
    • CBUSH.orientation_vector()
    • CBUSH.raw_fields()
    • CBUSH.repr_fields()
    • CBUSH.safe_cross_reference()
    • CBUSH.type
    • CBUSH.uncross_reference()
    • CBUSH.update_by_cp_name()
    • CBUSH.write_card()
  • CBUSH1D
    • CBUSH1D.Ga()
    • CBUSH1D.Gb()
    • CBUSH1D.add_card()
    • CBUSH1D.cross_reference()
    • CBUSH1D.element_coordinate_system()
    • CBUSH1D.export_to_hdf5()
    • CBUSH1D.node_ids
    • CBUSH1D.raw_fields()
    • CBUSH1D.safe_cross_reference()
    • CBUSH1D.type
    • CBUSH1D.uncross_reference()
    • CBUSH1D.write_card()
  • CBUSH2D
    • CBUSH2D.Ga()
    • CBUSH2D.Gb()
    • CBUSH2D.add_card()
    • CBUSH2D.cross_reference()
    • CBUSH2D.export_to_hdf5()
    • CBUSH2D.ga
    • CBUSH2D.gb
    • CBUSH2D.node_ids
    • CBUSH2D.raw_fields()
    • CBUSH2D.safe_cross_reference()
    • CBUSH2D.type
    • CBUSH2D.uncross_reference()
    • CBUSH2D.write_card()
• damper Module
  • CDAMP1
    • CDAMP1.B()
    • CDAMP1.add_card()
    • CDAMP1.cross_reference()
    • CDAMP1.export_to_hdf5()
    • CDAMP1.get_edge_ids()
    • CDAMP1.node_ids
    • CDAMP1.raw_fields()
    • CDAMP1.safe_cross_reference()
    • CDAMP1.type
    • CDAMP1.uncross_reference()
    • CDAMP1.validate()
    • CDAMP1.write_card()
  • CDAMP2
    • CDAMP2.B()
    • CDAMP2.add_card()
    • CDAMP2.b
    • CDAMP2.c1
    • CDAMP2.cp_name_map
    • CDAMP2.cross_reference()
    • CDAMP2.export_to_hdf5()
    • CDAMP2.get_edge_ids()
    • CDAMP2.node_ids
    • CDAMP2.raw_fields()
    • CDAMP2.safe_cross_reference()
    • CDAMP2.type
    • CDAMP2.uncross_reference()
    • CDAMP2.validate()
    • CDAMP2.write_card()
  • CDAMP3
    • CDAMP3.B()
    • CDAMP3.add_card()
    • CDAMP3.cross_reference()
    • CDAMP3.export_to_hdf5()
    • CDAMP3.node_ids
    • CDAMP3.raw_fields()
    • CDAMP3.safe_cross_reference()
    • CDAMP3.type
    • CDAMP3.uncross_reference()
    • CDAMP3.write_card()
  • CDAMP4
    • CDAMP4.B()
    • CDAMP4.add_card()
    • CDAMP4.cross_reference()
    • CDAMP4.export_to_hdf5()
    • CDAMP4.node_ids
    • CDAMP4.raw_fields()
    • CDAMP4.safe_cross_reference()
    • CDAMP4.type
    • CDAMP4.uncross_reference()
    • CDAMP4.write_card()
  • CDAMP5
    • CDAMP5.B()
    • CDAMP5.add_card()
    • CDAMP5.cross_reference()
    • CDAMP5.export_to_hdf5()
    • CDAMP5.node_ids
    • CDAMP5.raw_fields()
    • CDAMP5.safe_cross_reference()
    • CDAMP5.type
    • CDAMP5.uncross_reference()
    • CDAMP5.write_card()
  • CVISC
    • CVISC.B()
    • CVISC.add_card()
    • CVISC.cross_reference()
    • CVISC.export_to_hdf5()
    • CVISC.get_edge_ids()
    • CVISC.node_ids
    • CVISC.raw_fields()
    • CVISC.repr_fields()
    • CVISC.safe_cross_reference()
    • CVISC.type
    • CVISC.uncross_reference()
    • CVISC.write_card()
  • DamperElement
  • LineDamper
• elements Module
  • CFAST
    • CFAST.Ga()
    • CFAST.Gb()
    • CFAST.Gs()
    • CFAST._gs_xyz()
    • CFAST._init_from_empty()
    • CFAST._properties
    • CFAST.add_card()
    • CFAST.cp_name_map
    • CFAST.cross_reference()
    • CFAST.get_edge_ids()
    • CFAST.node_ids
    • CFAST.nodes
    • CFAST.raw_fields()
    • CFAST.repr_fields()
    • CFAST.safe_cross_reference()
    • CFAST.type
    • CFAST.uncross_reference()
    • CFAST.validate()
    • CFAST.write_card()
  • CGAP
    • CGAP.Cid()
    • CGAP.G0()
    • CGAP.Ga()
    • CGAP.Gb()
    • CGAP.add_card()
    • CGAP.cross_reference()
    • CGAP.export_to_hdf5()
    • CGAP.get_edge_ids()
    • CGAP.node_ids
    • CGAP.nodes
    • CGAP.raw_fields()
    • CGAP.safe_cross_reference()
    • CGAP.type
    • CGAP.uncross_reference()
    • CGAP.update_by_cp_name()
    • CGAP.write_card()
  • CRAC2D
    • CRAC2D._finalize_hdf5()
    • CRAC2D._init_from_empty()
    • CRAC2D._properties
    • CRAC2D.add_card()
    • CRAC2D.get_edge_ids()
    • CRAC2D.node_ids
    • CRAC2D.raw_fields()
    • CRAC2D.type
    • CRAC2D.write_card()
  • CRAC3D
    • CRAC3D._finalize_hdf5()
    • CRAC3D._init_from_empty()
    • CRAC3D._properties
    • CRAC3D.add_card()
    • CRAC3D.get_edge_ids()
    • CRAC3D.node_ids
    • CRAC3D.raw_fields()
    • CRAC3D.type
    • CRAC3D.write_card()
  • CWELD
    • CWELD.Ga()
    • CWELD.Gb()
    • CWELD.Gs()
    • CWELD.Mcid()
    • CWELD._get_gs()
    • CWELD._init_from_empty()
    • CWELD._properties
    • CWELD.add_card()
    • CWELD.cp_name_map
    • CWELD.cross_reference()
    • CWELD.node_ids
    • CWELD.raw_fields()
    • CWELD.type
    • CWELD.uncross_reference()
    • CWELD.validate()
    • CWELD.write_card()
  • CrackElement
    • CrackElement.cross_reference()
    • CrackElement.nodes
    • CrackElement.safe_cross_reference()
    • CrackElement.type
    • CrackElement.uncross_reference()
  • GENEL
    • GENEL._finalize_hdf5()
    • GENEL._init_from_empty()
    • GENEL._properties
    • GENEL.add_card()
    • GENEL.cross_reference()
    • GENEL.node_ids
    • GENEL.nodes
    • GENEL.raw_fields()
    • GENEL.safe_cross_reference()
    • GENEL.type
    • GENEL.ud_nodes
    • GENEL.ul_nodes
    • GENEL.uncross_reference()
    • GENEL.write_card()
  • _get_genel_offset()
  • _read_genel_fields_until_char_blank()
• mass Module
  • CMASS1
    • CMASS1.Centroid()
    • CMASS1.G1()
    • CMASS1.G2()
    • CMASS1.Mass()
    • CMASS1.Pid()
    • CMASS1._init_from_empty()
    • CMASS1._properties
    • CMASS1.add_card()
    • CMASS1.center_of_mass()
    • CMASS1.cross_reference()
    • CMASS1.grid_component()
    • CMASS1.node_ids
    • CMASS1.raw_fields()
    • CMASS1.safe_cross_reference()
    • CMASS1.type
    • CMASS1.uncross_reference()
    • CMASS1.write_card()
  • CMASS2
    • CMASS2.Centroid()
    • CMASS2.G1()
    • CMASS2.G2()
    • CMASS2.Mass()
    • CMASS2._init_from_empty()
    • CMASS2._properties
    • CMASS2.add_card()
    • CMASS2.center_of_mass()
    • CMASS2.cp_name_map
    • CMASS2.cross_reference()
    • CMASS2.export_to_hdf5()
    • CMASS2.grid_component()
    • CMASS2.node_ids
    • CMASS2.raw_fields()
    • CMASS2.repr_fields()
    • CMASS2.safe_cross_reference()
    • CMASS2.type
    • CMASS2.uncross_reference()
    • CMASS2.validate()
    • CMASS2.write_card()
  • CMASS3
    • CMASS3.Centroid()
    • CMASS3.Mass()
    • CMASS3.S1()
    • CMASS3.S2()
    • CMASS3._init_from_empty()
    • CMASS3._properties
    • CMASS3.add_card()
    • CMASS3.center_of_mass()
    • CMASS3.cross_reference()
    • CMASS3.grid_component()
    • CMASS3.node_ids
    • CMASS3.raw_fields()
    • CMASS3.safe_cross_reference()
    • CMASS3.type
    • CMASS3.uncross_reference()
    • CMASS3.write_card()
  • CMASS4
    • CMASS4.Centroid()
    • CMASS4.Mass()
    • CMASS4.S1()
    • CMASS4.S2()
    • CMASS4._init_from_empty()
    • CMASS4._properties
    • CMASS4.add_card()
    • CMASS4.center_of_mass()
    • CMASS4.cp_name_map
    • CMASS4.cross_reference()
    • CMASS4.grid_component()
    • CMASS4.node_ids
    • CMASS4.raw_fields()
    • CMASS4.safe_cross_reference()
    • CMASS4.type
    • CMASS4.uncross_reference()
    • CMASS4.write_card()
  • CONM1
    • CONM1.Centroid()
    • CONM1.Cid()
    • CONM1.Mass()
    • CONM1.MassMatrix()
    • CONM1.Nid()
    • CONM1._finalize_hdf5()
    • CONM1._init_from_empty()
    • CONM1._properties
    • CONM1.add_card()
    • CONM1.center_of_mass()
    • CONM1.cross_reference()
    • CONM1.node_ids
    • CONM1.raw_fields()
    • CONM1.repr_fields()
    • CONM1.safe_cross_reference()
    • CONM1.type
    • CONM1.uncross_reference()
    • CONM1.update_by_cp_name()
    • CONM1.write_card()
  • CONM2
    • CONM2.Centroid()
    • CONM2.Centroid_no_xref()
    • CONM2.Cid()
    • CONM2.I
    • CONM2.Inertia()
    • CONM2.Mass()
    • CONM2.Nid()
    • CONM2.X
    • CONM2.add_card()
    • CONM2.add_card_lax()
    • CONM2.center_of_mass()
    • CONM2.centroid_mass_inertia()
    • CONM2.cid
    • CONM2.cross_reference()
    • CONM2.eid
    • CONM2.export_to_hdf5()
    • CONM2.mass
    • CONM2.mass_matrix()
    • CONM2.nid
    • CONM2.node_ids
    • CONM2.offset()
    • CONM2.raw_fields()
    • CONM2.repr_fields()
    • CONM2.safe_cross_reference()
    • CONM2.type
    • CONM2.uncross_reference()
    • CONM2.update_by_cp_name()
    • CONM2.validate()
    • CONM2.write_card()
    • CONM2.write_card_16()
  • PointMassElement
    • PointMassElement.repr_fields()
    • PointMassElement.write_card()
    • PointMassElement.write_card_16()
  • is_positive_semi_definite()
  • safe_xref_cmass_nodes()
  • xref_cmass_nodes()
• rigid Module
  • RBAR
    • RBAR.Ga()
    • RBAR.Gb()
    • RBAR._init_from_empty()
    • RBAR._properties
    • RBAR.add_card()
    • RBAR.cross_reference()
    • RBAR.dependent_nodes
    • RBAR.independent_nodes
    • RBAR.nodes
    • RBAR.raw_fields()
    • RBAR.repr_fields()
    • RBAR.safe_cross_reference()
    • RBAR.type
    • RBAR.uncross_reference()
    • RBAR.validate()
    • RBAR.write_card()
  • RBAR1
    • RBAR1.Ga()
    • RBAR1.Gb()
    • RBAR1._init_from_empty()
    • RBAR1._properties
    • RBAR1.add_card()
    • RBAR1.cross_reference()
    • RBAR1.dependent_nodes
    • RBAR1.independent_nodes
    • RBAR1.raw_fields()
    • RBAR1.repr_fields()
    • RBAR1.safe_cross_reference()
    • RBAR1.type
    • RBAR1.uncross_reference()
    • RBAR1.write_card()
  • RBE1
    • RBE1.Gmi_node_ids
    • RBE1.Gni_node_ids
    • RBE1._init_from_empty()
    • RBE1._properties
    • RBE1.add_card()
    • RBE1.cross_reference()
    • RBE1.dependent_nodes
    • RBE1.independent_nodes
    • RBE1.nodes
    • RBE1.raw_fields()
    • RBE1.repr_fields()
    • RBE1.safe_cross_reference()
    • RBE1.type
    • RBE1.uncross_reference()
    • RBE1.write_card()
  • RBE2
    • RBE2.Gmi_node_ids
    • RBE2.Gn()
    • RBE2._init_from_empty()
    • RBE2._properties
    • RBE2.add_card()
    • RBE2.cm
    • RBE2.convert_to_mpc()
    • RBE2.cross_reference()
    • RBE2.dependent_nodes
    • RBE2.eid
    • RBE2.gn
    • RBE2.independent_nodes
    • RBE2.nodes
    • RBE2.raw_fields()
    • RBE2.repr_fields()
    • RBE2.safe_cross_reference()
    • RBE2.type
    • RBE2.uncross_reference()
    • RBE2.update()
    • RBE2.validate()
    • RBE2.write_card()
    • RBE2.write_card_16()
  • RBE3
    • RBE3.Gijs_node_ids
    • RBE3.Gmi_node_ids
    • RBE3._init_from_empty()
    • RBE3._properties
    • RBE3.add_card()
    • RBE3.cross_reference()
    • RBE3.dependent_nodes
    • RBE3.independent_nodes
    • RBE3.nodes
    • RBE3.raw_fields()
    • RBE3.ref_grid_id
    • RBE3.repr_fields()
    • RBE3.safe_cross_reference()
    • RBE3.type
    • RBE3.uncross_reference()
    • RBE3.validate()
    • RBE3.write_card()
    • RBE3.wt_cg_groups
  • RROD
    • RROD.Ga()
    • RROD.Gb()
    • RROD._init_from_empty()
    • RROD._properties
    • RROD.add_card()
    • RROD.cross_reference()
    • RROD.dependent_nodes
    • RROD.independent_nodes
    • RROD.raw_fields()
    • RROD.repr_fields()
    • RROD.safe_cross_reference()
    • RROD.type
    • RROD.uncross_reference()
    • RROD.validate()
    • RROD.write_card()
  • RSPLINE
    • RSPLINE._init_from_empty()
    • RSPLINE._properties
    • RSPLINE.add_card()
    • RSPLINE.cross_reference()
    • RSPLINE.dependent_nodes
    • RSPLINE.independent_nodes
    • RSPLINE.raw_fields()
    • RSPLINE.repr_fields()
    • RSPLINE.safe_cross_reference()
    • RSPLINE.type
    • RSPLINE.uncross_reference()
    • RSPLINE.validate()
    • RSPLINE.write_card()
  • RSSCON
    • RSSCON.EidShell()
    • RSSCON.EidSolid()
    • RSSCON._init_from_empty()
    • RSSCON.add_card()
    • RSSCON.cross_reference()
    • RSSCON.dependent_nodes
    • RSSCON.independent_nodes
    • RSSCON.raw_fields()
    • RSSCON.repr_fields()
    • RSSCON.safe_cross_reference()
    • RSSCON.type
    • RSSCON.uncross_reference()
    • RSSCON.write_card()
  • RigidElementBase
    • RigidElementBase.cross_reference()
• rods Module
  • CONROD
    • CONROD.Area()
    • CONROD.C()
    • CONROD.Centroid()
    • CONROD.E()
    • CONROD.G()
    • CONROD.J()
    • CONROD.Length()
    • CONROD.MassPerLength()
    • CONROD.Mid()
    • CONROD.Nsm()
    • CONROD.Pid()
    • CONROD.Rho()
    • CONROD.add_card()
    • CONROD.center_of_mass()
    • CONROD.cross_reference()
    • CONROD.export_to_hdf5()
    • CONROD.pid
    • CONROD.raw_fields()
    • CONROD.repr_fields()
    • CONROD.safe_cross_reference()
    • CONROD.type
    • CONROD.uncross_reference()
    • CONROD.write_card()
  • CROD
    • CROD.Area()
    • CROD.C()
    • CROD.Centroid()
    • CROD.E()
    • CROD.G()
    • CROD.J()
    • CROD.Length()
    • CROD.MassPerLength()
    • CROD.Mid()
    • CROD.Nsm()
    • CROD.Rho()
    • CROD.add_card()
    • CROD.center_of_mass()
    • CROD.cross_reference()
    • CROD.export_to_hdf5()
    • CROD.raw_fields()
    • CROD.repr_fields()
    • CROD.safe_cross_reference()
    • CROD.type
    • CROD.uncross_reference()
    • CROD.write_card()
    • CROD.write_card_16()
  • CTUBE
    • CTUBE.Area()
    • CTUBE.Centroid()
    • CTUBE.E()
    • CTUBE.G()
    • CTUBE.J()
    • CTUBE.Length()
    • CTUBE.Mass()
    • CTUBE.Mid()
    • CTUBE.Nsm()
    • CTUBE.Rho()
    • CTUBE.add_card()
    • CTUBE.center_of_mass()
    • CTUBE.cross_reference()
    • CTUBE.export_to_hdf5()
    • CTUBE.raw_fields()
    • CTUBE.safe_cross_reference()
    • CTUBE.type
    • CTUBE.uncross_reference()
    • CTUBE.write_card()
  • RodElement
    • RodElement.Mass()
    • RodElement.get_edge_ids()
    • RodElement.node_ids
• shell Module
  • CPLSTN3
    • CPLSTN3.type
    • CPLSTN3.write_card()
  • CPLSTN4
    • CPLSTN4.type
    • CPLSTN4.write_card()
  • CPLSTN6
    • CPLSTN6.type
  • CPLSTN8
    • CPLSTN8.type
  • CPLSTS3
    • CPLSTS3.Mass()
    • CPLSTS3._get_repr_defaults()
    • CPLSTS3.add_card()
    • CPLSTS3.cross_reference()
    • CPLSTS3.flip_normal()
    • CPLSTS3.node_ids
    • CPLSTS3.raw_fields()
    • CPLSTS3.repr_fields()
    • CPLSTS3.safe_cross_reference()
    • CPLSTS3.type
    • CPLSTS3.uncross_reference()
    • CPLSTS3.validate()
    • CPLSTS3.write_card()
  • CPLSTS4
    • CPLSTS4.Mass()
    • CPLSTS4._get_repr_defaults()
    • CPLSTS4.add_card()
    • CPLSTS4.cross_reference()
    • CPLSTS4.flip_normal()
    • CPLSTS4.node_ids
    • CPLSTS4.raw_fields()
    • CPLSTS4.repr_fields()
    • CPLSTS4.safe_cross_reference()
    • CPLSTS4.type
    • CPLSTS4.uncross_reference()
    • CPLSTS4.validate()
    • CPLSTS4.write_card()
  • CPLSTS6
    • CPLSTS6.type
  • CPLSTS8
    • CPLSTS8.type
  • CQUAD
    • CQUAD.Area()
    • CQUAD.Mass()
    • CQUAD.Thickness()
    • CQUAD.add_card()
    • CQUAD.cross_reference()
    • CQUAD.eid
    • CQUAD.export_to_hdf5()
    • CQUAD.flip_normal()
    • CQUAD.node_ids
    • CQUAD.raw_fields()
    • CQUAD.repr_fields()
    • CQUAD.safe_cross_reference()
    • CQUAD.theta_mcid_ref
    • CQUAD.type
    • CQUAD.uncross_reference()
    • CQUAD.write_card()
  • CQUAD4
    • CQUAD4._properties
    • CQUAD4.add_card()
    • CQUAD4.cp_name_map
    • CQUAD4.cross_reference()
    • CQUAD4.eid
    • CQUAD4.export_to_hdf5()
    • CQUAD4.flip_normal()
    • CQUAD4.get_thickness_scale()
    • CQUAD4.node_ids
    • CQUAD4.raw_fields()
    • CQUAD4.repr_fields()
    • CQUAD4.safe_cross_reference()
    • CQUAD4.split_to_ctria3()
    • CQUAD4.theta_mcid_ref
    • CQUAD4.type
    • CQUAD4.uncross_reference()
    • CQUAD4.validate()
    • CQUAD4.write_as_ctria3()
    • CQUAD4.write_card()
  • CQUAD8
    • CQUAD8.Area()
    • CQUAD8.AreaCentroid()
    • CQUAD8.Normal()
    • CQUAD8.Thickness()
    • CQUAD8.add_card()
    • CQUAD8.cross_reference()
    • CQUAD8.eid
    • CQUAD8.export_to_hdf5()
    • CQUAD8.flip_normal()
    • CQUAD8.get_thickness_scale()
    • CQUAD8.node_ids
    • CQUAD8.raw_fields()
    • CQUAD8.repr_fields()
    • CQUAD8.safe_cross_reference()
    • CQUAD8.theta_mcid_ref
    • CQUAD8.type
    • CQUAD8.uncross_reference()
    • CQUAD8.write_card()
  • CQUADR
    • CQUADR.Thickness()
    • CQUADR.add_card()
    • CQUADR.cross_reference()
    • CQUADR.eid
    • CQUADR.export_to_hdf5()
    • CQUADR.flip_normal()
    • CQUADR.get_thickness_scale()
    • CQUADR.node_ids
    • CQUADR.raw_fields()
    • CQUADR.repr_fields()
    • CQUADR.safe_cross_reference()
    • CQUADR.theta_mcid_ref
    • CQUADR.type
    • CQUADR.uncross_reference()
    • CQUADR.write_card()
  • CSHEAR
    • CSHEAR.Area()
    • CSHEAR.AreaCentroid()
    • CSHEAR.AreaCentroidNormal()
    • CSHEAR.Centroid()
    • CSHEAR.G()
    • CSHEAR.Mass()
    • CSHEAR.Normal()
    • CSHEAR.Thickness()
    • CSHEAR.add_card()
    • CSHEAR.center_of_mass()
    • CSHEAR.cross_reference()
    • CSHEAR.eid
    • CSHEAR.export_to_hdf5()
    • CSHEAR.flip_normal()
    • CSHEAR.node_ids
    • CSHEAR.raw_fields()
    • CSHEAR.repr_fields()
    • CSHEAR.safe_cross_reference()
    • CSHEAR.type
    • CSHEAR.uncross_reference()
    • CSHEAR.validate()
    • CSHEAR.write_card()
  • CTRIA3
    • CTRIA3._get_repr_defaults()
    • CTRIA3._properties
    • CTRIA3.add_card()
    • CTRIA3.add_card_lax()
    • CTRIA3.cp_name_map
    • CTRIA3.cross_reference()
    • CTRIA3.export_to_hdf5()
    • CTRIA3.flip_normal()
    • CTRIA3.get_thickness_scale()
    • CTRIA3.node_ids
    • CTRIA3.raw_fields()
    • CTRIA3.repr_fields()
    • CTRIA3.safe_cross_reference()
    • CTRIA3.theta_mcid_ref
    • CTRIA3.type
    • CTRIA3.uncross_reference()
    • CTRIA3.validate()
    • CTRIA3.write_card()
  • CTRIA6
    • CTRIA6.Area()
    • CTRIA6.AreaCentroidNormal()
    • CTRIA6.Centroid()
    • CTRIA6.Normal()
    • CTRIA6.Thickness()
    • CTRIA6._get_repr_defaults()
    • CTRIA6.add_card()
    • CTRIA6.center_of_mass()
    • CTRIA6.cross_reference()
    • CTRIA6.export_to_hdf5()
    • CTRIA6.flip_normal()
    • CTRIA6.get_thickness_scale()
    • CTRIA6.node_ids
    • CTRIA6.raw_fields()
    • CTRIA6.repr_fields()
    • CTRIA6.safe_cross_reference()
    • CTRIA6.theta_mcid_ref
    • CTRIA6.type
    • CTRIA6.uncross_reference()
    • CTRIA6.write_card()
  • CTRIAR
    • CTRIAR.Thickness()
    • CTRIAR._get_repr_defaults()
    • CTRIAR.add_card()
    • CTRIAR.cross_reference()
    • CTRIAR.eid
    • CTRIAR.export_to_hdf5()
    • CTRIAR.flip_normal()
    • CTRIAR.get_thickness_scale()
    • CTRIAR.node_ids
    • CTRIAR.raw_fields()
    • CTRIAR.repr_fields()
    • CTRIAR.safe_cross_reference()
    • CTRIAR.theta_mcid_ref
    • CTRIAR.type
    • CTRIAR.uncross_reference()
    • CTRIAR.write_card()
  • SNORM
    • SNORM.Cid()
    • SNORM._init_from_empty()
    • SNORM.add_card()
    • SNORM.cid_ref
    • SNORM.cross_reference()
    • SNORM.raw_fields()
    • SNORM.repr_fields()
    • SNORM.safe_cross_reference()
    • SNORM.type
    • SNORM.uncross_reference()
    • SNORM.write_card()
  • _normal()
  • _triangle_area_centroid_normal()
  • transform_shell_material_coordinate_system()
• solid Module
  • CHEXA20
    • CHEXA20.Centroid()
    • CHEXA20.Volume()
    • CHEXA20.add_card()
    • CHEXA20.cross_reference()
    • CHEXA20.eid
    • CHEXA20.faces
    • CHEXA20.get_edge_ids()
    • CHEXA20.get_face()
    • CHEXA20.get_face_area_centroid_normal()
    • CHEXA20.node_ids
    • CHEXA20.safe_cross_reference()
    • CHEXA20.type
    • CHEXA20.write_card()
    • CHEXA20.write_card_16()
  • CHEXA8
    • CHEXA8.Centroid()
    • CHEXA8.Volume()
    • CHEXA8.add_card()
    • CHEXA8.centroid_mass()
    • CHEXA8.cross_reference()
    • CHEXA8.eid
    • CHEXA8.faces
    • CHEXA8.flip_normal()
    • CHEXA8.get_edge_ids()
    • CHEXA8.get_face()
    • CHEXA8.get_face_area_centroid_normal()
    • CHEXA8.material_coordinate_system()
    • CHEXA8.node_ids
    • CHEXA8.safe_cross_reference()
    • CHEXA8.type
    • CHEXA8.write_card()
    • CHEXA8.write_card_16()
  • CHEXCZ
    • CHEXCZ.type
    • CHEXCZ.write_card()
    • CHEXCZ.write_card_16()
  • CPENTA15
    • CPENTA15.Centroid()
    • CPENTA15.Volume()
    • CPENTA15.add_card()
    • CPENTA15.cross_reference()
    • CPENTA15.eid
    • CPENTA15.faces
    • CPENTA15.get_edge_ids()
    • CPENTA15.get_face()
    • CPENTA15.get_face_area_centroid_normal()
    • CPENTA15.node_ids
    • CPENTA15.safe_cross_reference()
    • CPENTA15.type
    • CPENTA15.write_card()
    • CPENTA15.write_card_16()
  • CPENTA6
    • CPENTA6.Centroid()
    • CPENTA6.Volume()
    • CPENTA6.add_card()
    • CPENTA6.centroid_mass()
    • CPENTA6.cross_reference()
    • CPENTA6.eid
    • CPENTA6.faces
    • CPENTA6.get_edge_ids()
    • CPENTA6.get_face()
    • CPENTA6.get_face_area_centroid_normal()
    • CPENTA6.get_face_nodes_and_area()
    • CPENTA6.material_coordinate_system()
    • CPENTA6.node_ids
    • CPENTA6.raw_fields()
    • CPENTA6.safe_cross_reference()
    • CPENTA6.type
    • CPENTA6.write_card()
    • CPENTA6.write_card_16()
  • CPENTCZ
    • CPENTCZ.type
    • CPENTCZ.write_card()
    • CPENTCZ.write_card_16()
  • CPYRAM13
    • CPYRAM13.Centroid()
    • CPYRAM13.Volume()
    • CPYRAM13.add_card()
    • CPYRAM13.cross_reference()
    • CPYRAM13.eid
    • CPYRAM13.faces
    • CPYRAM13.get_edge_ids()
    • CPYRAM13.node_ids
    • CPYRAM13.safe_cross_reference()
    • CPYRAM13.type
    • CPYRAM13.write_card()
    • CPYRAM13.write_card_16()
  • CPYRAM5
    • CPYRAM5.Centroid()
    • CPYRAM5.Volume()
    • CPYRAM5.add_card()
    • CPYRAM5.cross_reference()
    • CPYRAM5.eid
    • CPYRAM5.faces
    • CPYRAM5.get_edge_ids()
    • CPYRAM5.node_ids
    • CPYRAM5.safe_cross_reference()
    • CPYRAM5.type
    • CPYRAM5.write_card()
    • CPYRAM5.write_card_16()
  • CTETRA10
    • CTETRA10.Centroid()
    • CTETRA10.Volume()
    • CTETRA10.add_card()
    • CTETRA10.cross_reference()
    • CTETRA10.eid
    • CTETRA10.faces
    • CTETRA10.get_edge_ids()
    • CTETRA10.get_face_area_centroid_normal()
    • CTETRA10.get_face_nodes()
    • CTETRA10.material_coordinate_system()
    • CTETRA10.node_ids
    • CTETRA10.safe_cross_reference()
    • CTETRA10.type
    • CTETRA10.write_card()
    • CTETRA10.write_card_16()
  • CTETRA4
    • CTETRA4.Centroid()
    • CTETRA4.Volume()
    • CTETRA4.add_card()
    • CTETRA4.ansys_faces
    • CTETRA4.centroid_mass()
    • CTETRA4.cross_reference()
    • CTETRA4.eid
    • CTETRA4.faces
    • CTETRA4.flip_normal()
    • CTETRA4.get_edge_ids()
    • CTETRA4.get_face()
    • CTETRA4.get_face_area_centroid_normal()
    • CTETRA4.get_face_nodes()
    • CTETRA4.material_coordinate_system()
    • CTETRA4.node_ids
    • CTETRA4.safe_cross_reference()
    • CTETRA4.type
    • CTETRA4.write_card()
    • CTETRA4.write_card_16()
  • SolidElement
    • SolidElement.E()
    • SolidElement.G()
    • SolidElement.Mass()
    • SolidElement.Mid()
    • SolidElement.Nu()
    • SolidElement.Rho()
    • SolidElement.Volume()
    • SolidElement._properties
    • SolidElement.center_of_mass()
    • SolidElement.centroid_mass()
    • SolidElement.cross_reference()
    • SolidElement.export_to_hdf5()
    • SolidElement.get_face_area_centroid_normal()
    • SolidElement.raw_fields()
    • SolidElement.uncross_reference()
  • _ctetra_element_coordinate_system()
  • _get_nodes_array()
  • _verify_solid_elem_linear()
  • _verify_solid_elem_quadratic()
  • area_centroid()
  • chexa_face()
  • chexa_face_area_centroid_normal()
  • cpenta_face()
  • cpenta_face_area_centroid_normal()
  • ctetra_face()
  • ctetra_face_area_centroid_normal()
  • volume4()
• springs Module
  • CELAS1
    • CELAS1.K()
    • CELAS1.add_card()
    • CELAS1.c1
    • CELAS1.cross_reference()
    • CELAS1.export_to_hdf5()
    • CELAS1.get_edge_ids()
    • CELAS1.node_ids
    • CELAS1.raw_fields()
    • CELAS1.safe_cross_reference()
    • CELAS1.type
    • CELAS1.uncross_reference()
    • CELAS1.validate()
    • CELAS1.write_card()
  • CELAS2
    • CELAS2.K()
    • CELAS2.add_card()
    • CELAS2.c1
    • CELAS2.cp_name_map
    • CELAS2.cross_reference()
    • CELAS2.export_to_hdf5()
    • CELAS2.ge
    • CELAS2.get_edge_ids()
    • CELAS2.k
    • CELAS2.node_ids
    • CELAS2.raw_fields()
    • CELAS2.repr_fields()
    • CELAS2.s
    • CELAS2.safe_cross_reference()
    • CELAS2.type
    • CELAS2.uncross_reference()
    • CELAS2.validate()
    • CELAS2.write_card()
  • CELAS3
    • CELAS3.K()
    • CELAS3.add_card()
    • CELAS3.cross_reference()
    • CELAS3.export_to_hdf5()
    • CELAS3.get_edge_ids()
    • CELAS3.node_ids
    • CELAS3.nodes
    • CELAS3.raw_fields()
    • CELAS3.safe_cross_reference()
    • CELAS3.type
    • CELAS3.uncross_reference()
    • CELAS3.write_card()
  • CELAS4
    • CELAS4.K()
    • CELAS4.add_card()
    • CELAS4.cp_name_map
    • CELAS4.cross_reference()
    • CELAS4.export_to_hdf5()
    • CELAS4.get_edge_ids()
    • CELAS4.k
    • CELAS4.node_ids
    • CELAS4.raw_fields()
    • CELAS4.safe_cross_reference()
    • CELAS4.type
    • CELAS4.uncross_reference()
    • CELAS4.validate()
    • CELAS4.write_card()
  • SpringElement
    • SpringElement.Mass()
    • SpringElement.repr_fields()
    • SpringElement.write_card_16()

properties Package

• bars Module
  • A_I1_I2_I12()
  • IntegratedLineProperty
    • IntegratedLineProperty.Area()
    • IntegratedLineProperty.I11()
    • IntegratedLineProperty.I12()
    • IntegratedLineProperty.I22()
    • IntegratedLineProperty.J()
    • IntegratedLineProperty.Nsm()
  • Iyy_beam()
  • LineProperty
    • LineProperty.Area()
    • LineProperty.E()
    • LineProperty.G()
    • LineProperty.I11()
    • LineProperty.I22()
    • LineProperty.J()
    • LineProperty.Nsm()
    • LineProperty.Nu()
    • LineProperty.Rho()
  • PBAR
    • PBAR.A
    • PBAR.Area()
    • PBAR.I11()
    • PBAR.I12()
    • PBAR.I22()
    • PBAR.MassPerLength()
    • PBAR.add_card()
    • PBAR.add_card_lax()
    • PBAR.cross_reference()
    • PBAR.export_to_hdf5()
    • PBAR.get_cdef()
    • PBAR.i1
    • PBAR.i12
    • PBAR.i2
    • PBAR.j
    • PBAR.k1
    • PBAR.k2
    • PBAR.mid
    • PBAR.nsm
    • PBAR.pid
    • PBAR.pname_fid_map
    • PBAR.raw_fields()
    • PBAR.repr_fields()
    • PBAR.safe_cross_reference()
    • PBAR.type
    • PBAR.uncross_reference()
    • PBAR.validate()
    • PBAR.write_card()
  • PBARL
    • PBARL.Area()
    • PBARL.I1()
    • PBARL.I11()
    • PBARL.I12()
    • PBARL.I2()
    • PBARL.I22()
    • PBARL.J()
    • PBARL.MassPerLength()
    • PBARL.Nsm()
    • PBARL.Type
    • PBARL._init_from_empty()
    • PBARL._points()
    • PBARL._properties
    • PBARL.add_card()
    • PBARL.add_card_lax()
    • PBARL.cross_reference()
    • PBARL.get_cdef()
    • PBARL.mid
    • PBARL.nsm
    • PBARL.pid
    • PBARL.raw_fields()
    • PBARL.repr_fields()
    • PBARL.safe_cross_reference()
    • PBARL.type
    • PBARL.uncross_reference()
    • PBARL.update_by_pname_fid()
    • PBARL.valid_types
    • PBARL.validate()
    • PBARL.write_card()
  • PBEAM3
    • PBEAM3.Nsm()
    • PBEAM3._init_from_empty()
    • PBEAM3.add_card()
    • PBEAM3.cross_reference()
    • PBEAM3.raw_fields()
    • PBEAM3.safe_cross_reference()
    • PBEAM3.type
    • PBEAM3.uncross_reference()
    • PBEAM3.write_card()
  • PBEND
    • PBEND.MassPerLength()
    • PBEND._init_from_empty()
    • PBEND.add_beam_type_1()
    • PBEND.add_beam_type_2()
    • PBEND.add_card()
    • PBEND.cross_reference()
    • PBEND.raw_fields()
    • PBEND.repr_fields()
    • PBEND.safe_cross_reference()
    • PBEND.type
    • PBEND.uncross_reference()
    • PBEND.validate()
    • PBEND.write_card()
  • PBRSECT
    • PBRSECT.Area()
    • PBRSECT.I11()
    • PBRSECT.I22()
    • PBRSECT.J()
    • PBRSECT.MassPerLength()
    • PBRSECT.Nsm()
    • PBRSECT._finalize_hdf5()
    • PBRSECT._init_from_empty()
    • PBRSECT.add_card()
    • PBRSECT.cross_reference()
    • PBRSECT.mid
    • PBRSECT.pid
    • PBRSECT.plot()
    • PBRSECT.raw_fields()
    • PBRSECT.repr_fields()
    • PBRSECT.type
    • PBRSECT.uncross_reference()
    • PBRSECT.validate()
    • PBRSECT.write_card()
  • _IAreaL()
  • _bar_areaL()
  • bar_section()
  • box1_section()
  • box_section()
  • chan1_section()
  • chan2_section()
  • chan_section()
  • cross_section()
  • dbox_section()
  • get_beam_sections()
  • get_inertia_rectangular()
  • h_section()
  • hat1_section()
  • hat_section()
  • hexa_section()
  • i1_section()
  • i_section()
  • l_section()
  • parse_pbrsect_options()
  • plot_arbitrary_section()
  • rod_section()
  • split_arbitrary_thickness_section()
  • t1_section()
  • t2_section()
  • t_section()
  • tube2_section()
  • tube_section()
  • write_arbitrary_beam_section()
  • zee_section()
• beam Module
  • PBCOMP
    • PBCOMP.MassPerLength()
    • PBCOMP.Mids()
    • PBCOMP._init_from_empty()
    • PBCOMP.add_card()
    • PBCOMP.cross_reference()
    • PBCOMP.j
    • PBCOMP.mid
    • PBCOMP.nsm
    • PBCOMP.pid
    • PBCOMP.raw_fields()
    • PBCOMP.repr_fields()
    • PBCOMP.safe_cross_reference()
    • PBCOMP.type
    • PBCOMP.uncross_reference()
    • PBCOMP.validate()
    • PBCOMP.write_card()
  • PBEAM
    • PBEAM.I1_I2_I12()
    • PBEAM.MassPerLength()
    • PBEAM._init_from_empty()
    • PBEAM._interpolate_sections()
    • PBEAM.add_card()
    • PBEAM.add_card_lax()
    • PBEAM.cross_reference()
    • PBEAM.cwa
    • PBEAM.cwb
    • PBEAM.get_optimization_value()
    • PBEAM.k1
    • PBEAM.k2
    • PBEAM.m1a
    • PBEAM.m1b
    • PBEAM.m2a
    • PBEAM.m2b
    • PBEAM.mid
    • PBEAM.n1a
    • PBEAM.n1b
    • PBEAM.n2a
    • PBEAM.n2b
    • PBEAM.nsia
    • PBEAM.nsib
    • PBEAM.pid
    • PBEAM.raw_fields()
    • PBEAM.repr_fields()
    • PBEAM.s1
    • PBEAM.s2
    • PBEAM.safe_cross_reference()
    • PBEAM.set_optimization_value()
    • PBEAM.type
    • PBEAM.uncross_reference()
    • PBEAM.update_by_pname_fid()
    • PBEAM.validate()
    • PBEAM.write_card()
    • PBEAM.write_card_16()
  • PBEAML
    • PBEAML.Area()
    • PBEAML.I11()
    • PBEAML.I12()
    • PBEAML.I22()
    • PBEAML.J()
    • PBEAML.MassPerLength()
    • PBEAML.Type
    • PBEAML._finalize_hdf5()
    • PBEAML._init_from_empty()
    • PBEAML._properties
    • PBEAML.add_card()
    • PBEAML.add_card_lax()
    • PBEAML.beam_type
    • PBEAML.cross_reference()
    • PBEAML.get_mass_per_lengths()
    • PBEAML.mid
    • PBEAML.pid
    • PBEAML.raw_fields()
    • PBEAML.repr_fields()
    • PBEAML.safe_cross_reference()
    • PBEAML.type
    • PBEAML.uncross_reference()
    • PBEAML.update_by_pname_fid()
    • PBEAML.valid_types
    • PBEAML.validate()
    • PBEAML.verify()
    • PBEAML.write_card()
  • PBMSECT
    • PBMSECT.Area()
    • PBMSECT.I11()
    • PBMSECT.I22()
    • PBMSECT.J()
    • PBMSECT.MassPerLength()
    • PBMSECT.Nsm()
    • PBMSECT._finalize_hdf5()
    • PBMSECT._init_from_empty()
    • PBMSECT._properties
    • PBMSECT.add_card()
    • PBMSECT.cross_reference()
    • PBMSECT.mid
    • PBMSECT.outp_id
    • PBMSECT.pid
    • PBMSECT.plot()
    • PBMSECT.raw_fields()
    • PBMSECT.repr_fields()
    • PBMSECT.safe_cross_reference()
    • PBMSECT.type
    • PBMSECT.uncross_reference()
    • PBMSECT.validate()
    • PBMSECT.write_card()
  • _linearly_interpolate()
  • _sort_pbeam()
  • pbeam_op2_data_to_init()
  • pbeaml_op2_data_to_init()
  • update_pbeam_negative_integer()
• bush Module
  • BushingProperty
    • BushingProperty.cross_reference()
    • BushingProperty.safe_cross_reference()
    • BushingProperty.type
    • BushingProperty.uncross_reference()
  • PBUSH
    • PBUSH._init_from_empty()
    • PBUSH._read_rcv()
    • PBUSH._read_var()
    • PBUSH.add_card()
    • PBUSH.b
    • PBUSH.ge
    • PBUSH.k
    • PBUSH.pid
    • PBUSH.pname_map
    • PBUSH.raw_fields()
    • PBUSH.repr_fields()
    • PBUSH.type
    • PBUSH.update_by_pname_fid()
    • PBUSH.validate()
    • PBUSH.write_card()
  • PBUSH1D
    • PBUSH1D._damper_fields()
    • PBUSH1D._gener_fields()
    • PBUSH1D._init_from_empty()
    • PBUSH1D._properties
    • PBUSH1D._read_damper()
    • PBUSH1D._read_gener()
    • PBUSH1D._read_shock()
    • PBUSH1D._read_spring()
    • PBUSH1D._shock_fields()
    • PBUSH1D._spring_fields()
    • PBUSH1D.add_card()
    • PBUSH1D.pid
    • PBUSH1D.pname_fid_map
    • PBUSH1D.raw_fields()
    • PBUSH1D.repr_fields()
    • PBUSH1D.type
    • PBUSH1D.write_card()
  • PBUSH2D
    • PBUSH2D._init_from_empty()
    • PBUSH2D.add_card()
    • PBUSH2D.raw_fields()
    • PBUSH2D.repr_fields()
    • PBUSH2D.type
    • PBUSH2D.write_card()
  • PBUSHT
    • PBUSHT._init_from_empty()
    • PBUSHT.add_card()
    • PBUSHT.raw_fields()
    • PBUSHT.type
    • PBUSHT.update_by_pname_fid()
    • PBUSHT.write_card()
  • PBUSH_OPTISTRUCT
    • PBUSH_OPTISTRUCT._init_from_empty()
    • PBUSH_OPTISTRUCT._read_var()
    • PBUSH_OPTISTRUCT.add_card()
    • PBUSH_OPTISTRUCT.pid
    • PBUSH_OPTISTRUCT.pname_map
    • PBUSH_OPTISTRUCT.raw_fields()
    • PBUSH_OPTISTRUCT.repr_fields()
    • PBUSH_OPTISTRUCT.type
    • PBUSH_OPTISTRUCT.validate()
    • PBUSH_OPTISTRUCT.write_card()
  • _append_nones()
  • _finish_list_fields_row()
  • _finish_list_fields_row_pbush1d()
• damper Module
  • DamperProperty
    • DamperProperty.cross_reference()
    • DamperProperty.safe_cross_reference()
    • DamperProperty.uncross_reference()
  • PDAMP
    • PDAMP.B()
    • PDAMP._init_from_empty()
    • PDAMP.add_card()
    • PDAMP.b
    • PDAMP.pid
    • PDAMP.pname_fid_map
    • PDAMP.raw_fields()
    • PDAMP.repr_fields()
    • PDAMP.type
    • PDAMP.write_card()
  • PDAMP5
    • PDAMP5.Mid()
    • PDAMP5._init_from_empty()
    • PDAMP5.add_card()
    • PDAMP5.b
    • PDAMP5.cross_reference()
    • PDAMP5.mid
    • PDAMP5.pid
    • PDAMP5.raw_fields()
    • PDAMP5.repr_fields()
    • PDAMP5.type
    • PDAMP5.uncross_reference()
    • PDAMP5.write_card()
  • PDAMPT
    • PDAMPT.Tbid()
    • PDAMPT._init_from_empty()
    • PDAMPT.add_card()
    • PDAMPT.cross_reference()
    • PDAMPT.pid
    • PDAMPT.pname_fid_map
    • PDAMPT.raw_fields()
    • PDAMPT.repr_fields()
    • PDAMPT.tbid
    • PDAMPT.type
    • PDAMPT.uncross_reference()
    • PDAMPT.write_card()
  • PVISC
    • PVISC._init_from_empty()
    • PVISC.add_card()
    • PVISC.cross_reference()
    • PVISC.pname_fid_map
    • PVISC.raw_fields()
    • PVISC.repr_fields()
    • PVISC.type
    • PVISC.uncross_reference()
    • PVISC.write_card()
• mass Module
  • NSM
    • NSM._init_from_empty()
    • NSM._properties
    • NSM.type
  • NSM1
    • NSM1._init_from_empty()
    • NSM1.type
  • NSM1x
    • NSM1x.Type
    • NSM1x.add_card()
    • NSM1x.cross_reference()
    • NSM1x.get_ids()
    • NSM1x.raw_fields()
    • NSM1x.repr_fields()
    • NSM1x.safe_cross_reference()
    • NSM1x.valid_properties
    • NSM1x.write_card()
  • NSMADD
    • NSMADD._init_from_empty()
    • NSMADD._nsm_failed()
    • NSMADD._properties
    • NSMADD.add_card()
    • NSMADD.conid
    • NSMADD.cross_reference()
    • NSMADD.ids
    • NSMADD.nsm_ids
    • NSMADD.raw_fields()
    • NSMADD.safe_cross_reference()
    • NSMADD.type
    • NSMADD.uncross_reference()
    • NSMADD.validate()
    • NSMADD.write_card()
    • NSMADD.write_card_16()
  • NSML
    • NSML._init_from_empty()
    • NSML._properties
    • NSML.type
  • NSML1
    • NSML1._init_from_empty()
    • NSML1.get_eid_mass_cg_by_element()
    • NSML1.type
  • NSMx
    • NSMx.add_card()
    • NSMx.cross_reference()
    • NSMx.ids
    • NSMx.raw_fields()
    • NSMx.repr_fields()
    • NSMx.safe_cross_reference()
    • NSMx.valid_properties
    • NSMx.write_card()
  • PMASS
    • PMASS.Mass()
    • PMASS._init_from_empty()
    • PMASS._properties
    • PMASS.add_card()
    • PMASS.add_card_lax()
    • PMASS.cross_reference()
    • PMASS.pname_fid_map
    • PMASS.raw_fields()
    • PMASS.repr_fields()
    • PMASS.safe_cross_reference()
    • PMASS.type
    • PMASS.uncross_reference()
    • PMASS.write_card()
  • get_id_id0()
  • nsm_ids()
  • safe_xref_nsm()
  • xref_nsm()
• properties Module
  • CrackProperty
    • CrackProperty.Mid()
    • CrackProperty.write_card()
  • PFAST
    • PFAST.Mass()
    • PFAST.Mcid()
    • PFAST._init_from_empty()
    • PFAST.add_card()
    • PFAST.cross_reference()
    • PFAST.d
    • PFAST.ge
    • PFAST.kr1
    • PFAST.kt1
    • PFAST.mass
    • PFAST.mcid
    • PFAST.mflag
    • PFAST.pid
    • PFAST.pname_fid_map
    • PFAST.raw_fields()
    • PFAST.repr_fields()
    • PFAST.safe_cross_reference()
    • PFAST.type
    • PFAST.uncross_reference()
    • PFAST.write_card()
  • PGAP
    • PGAP._init_from_empty()
    • PGAP.add_card()
    • PGAP.cross_reference()
    • PGAP.f0
    • PGAP.ka
    • PGAP.kb
    • PGAP.kt
    • PGAP.mu1
    • PGAP.mu2
    • PGAP.pid
    • PGAP.pname_fid_map
    • PGAP.raw_fields()
    • PGAP.repr_fields()
    • PGAP.safe_cross_reference()
    • PGAP.type
    • PGAP.u0
    • PGAP.uncross_reference()
    • PGAP.write_card()
  • PRAC2D
    • PRAC2D._init_from_empty()
    • PRAC2D.add_card()
    • PRAC2D.cross_reference()
    • PRAC2D.gamma
    • PRAC2D.iplane
    • PRAC2D.mid
    • PRAC2D.nsm
    • PRAC2D.phi
    • PRAC2D.pid
    • PRAC2D.raw_fields()
    • PRAC2D.repr_fields()
    • PRAC2D.safe_cross_reference()
    • PRAC2D.type
    • PRAC2D.uncross_reference()
    • PRAC2D.validate()
  • PRAC3D
    • PRAC3D._init_from_empty()
    • PRAC3D.add_card()
    • PRAC3D.cross_reference()
    • PRAC3D.gamma
    • PRAC3D.mid
    • PRAC3D.phi
    • PRAC3D.pid
    • PRAC3D.raw_fields()
    • PRAC3D.repr_fields()
    • PRAC3D.safe_cross_reference()
    • PRAC3D.type
    • PRAC3D.uncross_reference()
  • PWELD
    • PWELD._init_from_empty()
    • PWELD.add_card()
    • PWELD.connect_type
    • PWELD.cross_reference()
    • PWELD.d
    • PWELD.ldmax
    • PWELD.ldmin
    • PWELD.mid
    • PWELD.mset
    • PWELD.pid
    • PWELD.pname_fid_map
    • PWELD.raw_fields()
    • PWELD.repr_fields()
    • PWELD.type
    • PWELD.uncross_reference()
    • PWELD.write_card()
• rods Module
  • PROD
    • PROD.Area()
    • PROD.C()
    • PROD.E()
    • PROD.G()
    • PROD.J()
    • PROD.MassPerLength()
    • PROD.Nsm()
    • PROD.Rho()
    • PROD.add_card()
    • PROD.cross_reference()
    • PROD.export_to_hdf5()
    • PROD.pname_fid_map
    • PROD.raw_fields()
    • PROD.repr_fields()
    • PROD.safe_cross_reference()
    • PROD.type
    • PROD.uncross_reference()
    • PROD.write_card()
    • PROD.write_card_16()
  • PTUBE
    • PTUBE.Area()
    • PTUBE.E()
    • PTUBE.G()
    • PTUBE.J()
    • PTUBE.MassPerLength()
    • PTUBE.Nsm()
    • PTUBE.Rho()
    • PTUBE._area1()
    • PTUBE._area2()
    • PTUBE.add_card()
    • PTUBE.cross_reference()
    • PTUBE.export_to_hdf5()
    • PTUBE.pname_fid_map
    • PTUBE.raw_fields()
    • PTUBE.repr_fields()
    • PTUBE.safe_cross_reference()
    • PTUBE.type
    • PTUBE.uncross_reference()
    • PTUBE.validate()
    • PTUBE.write_card()
• shell Module
  • CompositeShellProperty
    • CompositeShellProperty.MassPerArea()
    • CompositeShellProperty.MassPerArea_structure()
    • CompositeShellProperty.Material()
    • CompositeShellProperty.Mid()
    • CompositeShellProperty.Mids()
    • CompositeShellProperty.Nsm()
    • CompositeShellProperty.Rho()
    • CompositeShellProperty.TRef
    • CompositeShellProperty.Theta()
    • CompositeShellProperty.Thickness()
    • CompositeShellProperty._adjust_ply_id()
    • CompositeShellProperty.cross_reference()
    • CompositeShellProperty.get_density()
    • CompositeShellProperty.get_mass_per_area()
    • CompositeShellProperty.get_mass_per_area_rho()
    • CompositeShellProperty.get_mass_per_area_structure()
    • CompositeShellProperty.get_material_id()
    • CompositeShellProperty.get_material_ids()
    • CompositeShellProperty.get_nonstructural_mass()
    • CompositeShellProperty.get_sout()
    • CompositeShellProperty.get_souts()
    • CompositeShellProperty.get_theta()
    • CompositeShellProperty.get_thetas()
    • CompositeShellProperty.get_thickness()
    • CompositeShellProperty.get_thicknesses()
    • CompositeShellProperty.get_z_locations()
    • CompositeShellProperty.is_symmetrical
    • CompositeShellProperty.material_ids
    • CompositeShellProperty.nplies
    • CompositeShellProperty.reverse()
    • CompositeShellProperty.safe_cross_reference()
    • CompositeShellProperty.sout()
    • CompositeShellProperty.uncross_reference()
  • PCOMP
    • PCOMP._init_from_empty()
    • PCOMP._properties
    • PCOMP.add_card()
    • PCOMP.add_plies_to_beginning_and_end()
    • PCOMP.ft
    • PCOMP.get_ABD_matrices()
    • PCOMP.get_Ainv_equivalent_pshell()
    • PCOMP.get_individual_ABD_matrices()
    • PCOMP.get_z0_z1_zmean()
    • PCOMP.is_balanced_symmetric()
    • PCOMP.lam
    • PCOMP.nsm
    • PCOMP.pid
    • PCOMP.plies
    • PCOMP.raw_fields()
    • PCOMP.repr_fields()
    • PCOMP.tref
    • PCOMP.type
    • PCOMP.update_by_pname_fid()
    • PCOMP.validate()
    • PCOMP.write_card()
  • PCOMPG
    • PCOMPG.GlobalPlyID()
    • PCOMPG._init_from_empty()
    • PCOMPG._properties
    • PCOMPG.add_card()
    • PCOMPG.add_plies_to_beginning_and_end()
    • PCOMPG.ft
    • PCOMPG.get_ABD_matrices()
    • PCOMPG.get_Ainv_equivalent_pshell()
    • PCOMPG.get_global_ply_ids()
    • PCOMPG.get_individual_ABD_matrices()
    • PCOMPG.get_z0_z1_zmean()
    • PCOMPG.lam
    • PCOMPG.nsm
    • PCOMPG.pid
    • PCOMPG.plies
    • PCOMPG.pname_fid_map
    • PCOMPG.raw_fields()
    • PCOMPG.repr_fields()
    • PCOMPG.tref
    • PCOMPG.type
    • PCOMPG.update_by_pname_fid()
    • PCOMPG.validate()
    • PCOMPG.write_card()
  • PGPLSN
    • PGPLSN.Mid()
    • PGPLSN._init_from_empty()
    • PGPLSN.add_card()
    • PGPLSN.cross_reference()
    • PGPLSN.raw_fields()
    • PGPLSN.repr_fields()
    • PGPLSN.safe_cross_reference()
    • PGPLSN.type
    • PGPLSN.uncross_reference()
    • PGPLSN.write_card()
  • PLPLANE
    • PLPLANE.Cid()
    • PLPLANE.Mid()
    • PLPLANE._init_from_empty()
    • PLPLANE.add_card()
    • PLPLANE.cross_reference()
    • PLPLANE.pid
    • PLPLANE.raw_fields()
    • PLPLANE.repr_fields()
    • PLPLANE.safe_cross_reference()
    • PLPLANE.type
    • PLPLANE.uncross_reference()
    • PLPLANE.write_card()
  • PPLANE
    • PPLANE.MassPerArea()
    • PPLANE.Mid()
    • PPLANE.Thickness()
    • PPLANE._init_from_empty()
    • PPLANE.add_card()
    • PPLANE.cross_reference()
    • PPLANE.pid
    • PPLANE.raw_fields()
    • PPLANE.repr_fields()
    • PPLANE.safe_cross_reference()
    • PPLANE.type
    • PPLANE.uncross_reference()
    • PPLANE.write_card()
  • PSHEAR
    • PSHEAR.MassPerArea()
    • PSHEAR.Mid()
    • PSHEAR.Rho()
    • PSHEAR.Thickness()
    • PSHEAR._init_from_empty()
    • PSHEAR.add_card()
    • PSHEAR.cross_reference()
    • PSHEAR.mid
    • PSHEAR.pid
    • PSHEAR.pname_fid_map
    • PSHEAR.raw_fields()
    • PSHEAR.safe_cross_reference()
    • PSHEAR.type
    • PSHEAR.uncross_reference()
    • PSHEAR.write_card()
  • PSHELL
    • PSHELL.MassPerArea()
    • PSHELL.MassPerArea_no_xref()
    • PSHELL.MassPerArea_structure()
    • PSHELL.Mid()
    • PSHELL.Mid1()
    • PSHELL.Mid2()
    • PSHELL.Mid3()
    • PSHELL.Mid4()
    • PSHELL.Nsm()
    • PSHELL.Rho()
    • PSHELL.Thickness()
    • PSHELL.add_card()
    • PSHELL.add_card_lax()
    • PSHELL.cross_reference()
    • PSHELL.export_to_hdf5()
    • PSHELL.get_ABD_matrices()
    • PSHELL.get_Ainv_equivalent_pshell()
    • PSHELL.get_individual_ABD_matrices()
    • PSHELL.get_z_locations()
    • PSHELL.material_ids
    • PSHELL.materials()
    • PSHELL.mid2
    • PSHELL.mid_ref
    • PSHELL.nsm
    • PSHELL.pid
    • PSHELL.pname_fid_map
    • PSHELL.raw_fields()
    • PSHELL.repr_fields()
    • PSHELL.safe_cross_reference()
    • PSHELL.t
    • PSHELL.tst
    • PSHELL.twelveIt3
    • PSHELL.type
    • PSHELL.uncross_reference()
    • PSHELL.write_card()
  • PTRSHL
    • PTRSHL.I
    • PTRSHL.MassPerArea()
    • PTRSHL.Mid()
    • PTRSHL.Mid1()
    • PTRSHL.Mid2()
    • PTRSHL.Mid3()
    • PTRSHL.Nsm()
    • PTRSHL.Rho()
    • PTRSHL.Thickness()
    • PTRSHL.add_card()
    • PTRSHL.cross_reference()
    • PTRSHL.material_ids
    • PTRSHL.materials()
    • PTRSHL.pid
    • PTRSHL.raw_fields()
    • PTRSHL.repr_fields()
    • PTRSHL.t
    • PTRSHL.ts
    • PTRSHL.type
    • PTRSHL.uncross_reference()
    • PTRSHL.write_card()
  • _check_ply_range()
  • _set_default_thetas()
  • get_2d_plate_transform()
  • get_Qbar_matrix()
  • get_Qbar_matrix_v2()
  • get_Sbar_matrix()
  • map_failure_theory_int()
• solid Module
  • PCOMPLS
    • PCOMPLS.Mid()
    • PCOMPLS.Mids()
    • PCOMPLS.Rho()
    • PCOMPLS.Thickness()
    • PCOMPLS._init_from_empty()
    • PCOMPLS.add_card()
    • PCOMPLS.cross_reference()
    • PCOMPLS.material_ids
    • PCOMPLS.nplies
    • PCOMPLS.raw_fields()
    • PCOMPLS.repr_fields()
    • PCOMPLS.type
    • PCOMPLS.uncross_reference()
    • PCOMPLS.write_card()
  • PCOMPS
    • PCOMPS.Mid()
    • PCOMPS.Mids()
    • PCOMPS.Rho()
    • PCOMPS._init_from_empty()
    • PCOMPS.add_card()
    • PCOMPS.cross_reference()
    • PCOMPS.material_ids
    • PCOMPS.raw_fields()
    • PCOMPS.repr_fields()
    • PCOMPS.safe_cross_reference()
    • PCOMPS.type
    • PCOMPS.uncross_reference()
    • PCOMPS.write_card()
  • PLSOLID
    • PLSOLID.Rho()
    • PLSOLID._init_from_empty()
    • PLSOLID.add_card()
    • PLSOLID.cross_reference()
    • PLSOLID.mid
    • PLSOLID.pid
    • PLSOLID.raw_fields()
    • PLSOLID.safe_cross_reference()
    • PLSOLID.stress_strain
    • PLSOLID.type
    • PLSOLID.uncross_reference()
    • PLSOLID.validate()
    • PLSOLID.write_card()
  • PSOLID
    • PSOLID.E()
    • PSOLID.G()
    • PSOLID.Nu()
    • PSOLID.Rho()
    • PSOLID._init_from_empty()
    • PSOLID.add_card()
    • PSOLID.cross_reference()
    • PSOLID.export_to_hdf5()
    • PSOLID.materials()
    • PSOLID.mid
    • PSOLID.pid
    • PSOLID.raw_fields()
    • PSOLID.repr_fields()
    • PSOLID.safe_cross_reference()
    • PSOLID.type
    • PSOLID.uncross_reference()
    • PSOLID.write_card()
• springs Module
  • PELAS
    • PELAS.K()
    • PELAS._init_from_empty()
    • PELAS.add_card()
    • PELAS.cross_reference()
    • PELAS.ge
    • PELAS.k
    • PELAS.pid
    • PELAS.pname_fid_map
    • PELAS.raw_fields()
    • PELAS.repr_fields()
    • PELAS.s
    • PELAS.safe_cross_reference()
    • PELAS.type
    • PELAS.uncross_reference()
  • PELAST
    • PELAST.Pid()
    • PELAST.Tgeid()
    • PELAST.Tkid()
    • PELAST.Tknid()
    • PELAST._init_from_empty()
    • PELAST.add_card()
    • PELAST.cross_reference()
    • PELAST.pid
    • PELAST.pname_fid_map
    • PELAST.raw_fields()
    • PELAST.tgeid
    • PELAST.tkid
    • PELAST.tknid
    • PELAST.type
    • PELAST.uncross_reference()
  • SpringProperty
    • SpringProperty.write_card()

loads Package

• dloads Module
  • ACSRCE
    • ACSRCE.DPhase()
    • ACSRCE.Delay()
    • ACSRCE.Power()
    • ACSRCE._init_from_empty()
    • ACSRCE.add_card()
    • ACSRCE.cross_reference()
    • ACSRCE.get_load_at_freq()
    • ACSRCE.raw_fields()
    • ACSRCE.repr_fields()
    • ACSRCE.safe_cross_reference()
    • ACSRCE.type
    • ACSRCE.uncross_reference()
    • ACSRCE.write_card()
  • DLOAD
    • DLOAD._init_from_empty()
    • DLOAD.cross_reference()
    • DLOAD.raw_fields()
    • DLOAD.repr_fields()
    • DLOAD.safe_cross_reference()
    • DLOAD.type
    • DLOAD.uncross_reference()
    • DLOAD.write_card()
  • RLOAD1
    • RLOAD1.Tc()
    • RLOAD1.Td()
    • RLOAD1._init_from_empty()
    • RLOAD1._properties
    • RLOAD1.add_card()
    • RLOAD1.cross_reference()
    • RLOAD1.delay_id
    • RLOAD1.dphase_id
    • RLOAD1.get_delay_at_freq()
    • RLOAD1.get_load_at_freq()
    • RLOAD1.get_loads()
    • RLOAD1.get_phase_at_freq()
    • RLOAD1.get_table_at_freq()
    • RLOAD1.raw_fields()
    • RLOAD1.repr_fields()
    • RLOAD1.safe_cross_reference()
    • RLOAD1.type
    • RLOAD1.uncross_reference()
    • RLOAD1.validate()
    • RLOAD1.write_card()
  • RLOAD2
    • RLOAD2.LoadID()
    • RLOAD2.Tb()
    • RLOAD2.Tp()
    • RLOAD2._init_from_empty()
    • RLOAD2._properties
    • RLOAD2.add_card()
    • RLOAD2.cross_reference()
    • RLOAD2.delay_id
    • RLOAD2.dphase_id
    • RLOAD2.get_damping_at_freq()
    • RLOAD2.get_delay_at_freq()
    • RLOAD2.get_load_at_freq()
    • RLOAD2.get_loads()
    • RLOAD2.get_phase_at_freq()
    • RLOAD2.get_phi_at_freq()
    • RLOAD2.raw_fields()
    • RLOAD2.repr_fields()
    • RLOAD2.safe_cross_reference()
    • RLOAD2.type
    • RLOAD2.uncross_reference()
    • RLOAD2.validate()
    • RLOAD2.write_card()
  • TLOAD1
    • TLOAD1.Tid()
    • TLOAD1.Type
    • TLOAD1._init_from_empty()
    • TLOAD1._properties
    • TLOAD1.add_card()
    • TLOAD1.cross_reference()
    • TLOAD1.delay
    • TLOAD1.delay_id
    • TLOAD1.excite_id
    • TLOAD1.get_delay_at_time()
    • TLOAD1.get_load_at_time()
    • TLOAD1.get_loads()
    • TLOAD1.raw_fields()
    • TLOAD1.repr_fields()
    • TLOAD1.safe_cross_reference()
    • TLOAD1.sid
    • TLOAD1.tid
    • TLOAD1.type
    • TLOAD1.uncross_reference()
    • TLOAD1.us0
    • TLOAD1.validate()
    • TLOAD1.vs0
    • TLOAD1.write_card()
  • TLOAD2
    • TLOAD2.T1
    • TLOAD2.T2
    • TLOAD2.Type
    • TLOAD2._init_from_empty()
    • TLOAD2._properties
    • TLOAD2.add_card()
    • TLOAD2.b
    • TLOAD2.c
    • TLOAD2.cross_reference()
    • TLOAD2.delay_id
    • TLOAD2.dphase_id
    • TLOAD2.frequency
    • TLOAD2.get_delay_at_time()
    • TLOAD2.get_load_at_time()
    • TLOAD2.get_loads()
    • TLOAD2.get_phase_at_time()
    • TLOAD2.phase
    • TLOAD2.raw_fields()
    • TLOAD2.repr_fields()
    • TLOAD2.safe_cross_reference()
    • TLOAD2.sid
    • TLOAD2.type
    • TLOAD2.uncross_reference()
    • TLOAD2.us0
    • TLOAD2.validate()
    • TLOAD2.vs0
    • TLOAD2.write_card()
  • _cross_reference_excite_id()
  • _cross_reference_excite_id_backup()
  • fix_loadtype_rload1()
  • fix_loadtype_rload2()
  • fix_loadtype_tload1()
  • fix_loadtype_tload2()
  • get_lseqs_by_excite_id()
  • update_loadtype()
• loads Module
  • DAREA
    • DAREA._init_from_empty()
    • DAREA._properties
    • DAREA.add()
    • DAREA.add_card()
    • DAREA.cross_reference()
    • DAREA.node_ids
    • DAREA.raw_fields()
    • DAREA.safe_cross_reference()
    • DAREA.type
    • DAREA.uncross_reference()
    • DAREA.write_card()
  • DEFORM
    • DEFORM.Eid()
    • DEFORM._init_from_empty()
    • DEFORM.add_card()
    • DEFORM.cross_reference()
    • DEFORM.get_loads()
    • DEFORM.raw_fields()
    • DEFORM.safe_cross_reference()
    • DEFORM.type
    • DEFORM.uncross_reference()
    • DEFORM.write_card()
  • DynamicLoad
  • LOADCYH
    • LOADCYH._init_from_empty()
    • LOADCYH.add_card()
    • LOADCYH.cross_reference()
    • LOADCYH.get_loads()
    • LOADCYH.raw_fields()
    • LOADCYH.repr_fields()
    • LOADCYH.safe_cross_reference()
    • LOADCYH.type
    • LOADCYH.uncross_reference()
    • LOADCYH.write_card()
  • LOADCYN
    • LOADCYN._init_from_empty()
    • LOADCYN.add_card()
    • LOADCYN.cross_reference()
    • LOADCYN.get_loads()
    • LOADCYN.raw_fields()
    • LOADCYN.repr_fields()
    • LOADCYN.safe_cross_reference()
    • LOADCYN.type
    • LOADCYN.uncross_reference()
    • LOADCYN.write_card()
  • LSEQ
    • LSEQ.Lid()
    • LSEQ.LoadID()
    • LSEQ.Tid()
    • LSEQ._init_from_empty()
    • LSEQ.add_card()
    • LSEQ.cross_reference()
    • LSEQ.get_loads()
    • LSEQ.raw_fields()
    • LSEQ.repr_fields()
    • LSEQ.safe_cross_reference()
    • LSEQ.type
    • LSEQ.uncross_reference()
    • LSEQ.write_card()
  • Load
    • Load.node_ids
    • Load.type
  • LoadCombination
    • LoadCombination.LoadID()
    • LoadCombination.add_card()
    • LoadCombination.get_load_ids()
    • LoadCombination.get_loads()
    • LoadCombination.scale
    • LoadCombination.sid
    • LoadCombination.validate()
  • RFORCE
    • RFORCE.Cid()
    • RFORCE.Nid()
    • RFORCE._init_from_empty()
    • RFORCE._properties
    • RFORCE.add_card()
    • RFORCE.cross_reference()
    • RFORCE.get_loads()
    • RFORCE.node_id
    • RFORCE.raw_fields()
    • RFORCE.repr_fields()
    • RFORCE.safe_cross_reference()
    • RFORCE.type
    • RFORCE.uncross_reference()
    • RFORCE.validate()
    • RFORCE.write_card()
  • RFORCE1
    • RFORCE1.Cid()
    • RFORCE1.Nid()
    • RFORCE1._init_from_empty()
    • RFORCE1._properties
    • RFORCE1.add_card()
    • RFORCE1.cross_reference()
    • RFORCE1.get_loads()
    • RFORCE1.node_id
    • RFORCE1.raw_fields()
    • RFORCE1.safe_cross_reference()
    • RFORCE1.type
    • RFORCE1.uncross_reference()
    • RFORCE1.validate()
    • RFORCE1.write_card()
  • SLOAD
    • SLOAD.Nid()
    • SLOAD._init_from_empty()
    • SLOAD._properties
    • SLOAD.add_card()
    • SLOAD.cross_reference()
    • SLOAD.get_loads()
    • SLOAD.node_ids
    • SLOAD.raw_fields()
    • SLOAD.repr_fields()
    • SLOAD.safe_cross_reference()
    • SLOAD.sid
    • SLOAD.type
    • SLOAD.uncross_reference()
    • SLOAD.validate()
    • SLOAD.write_card()
    • SLOAD.write_card_16()
  • SPCD
    • SPCD._init_from_empty()
    • SPCD._properties
    • SPCD.add_card()
    • SPCD.cross_reference()
    • SPCD.get_loads()
    • SPCD.node_ids
    • SPCD.raw_fields()
    • SPCD.safe_cross_reference()
    • SPCD.type
    • SPCD.uncross_reference()
    • SPCD.write_card()
• random_loads Module
  • RANDPS
    • RANDPS.Tid()
    • RANDPS._init_from_empty()
    • RANDPS.add_card()
    • RANDPS.cross_reference()
    • RANDPS.get_loads()
    • RANDPS.j
    • RANDPS.k
    • RANDPS.raw_fields()
    • RANDPS.repr_fields()
    • RANDPS.safe_cross_reference()
    • RANDPS.sid
    • RANDPS.tid
    • RANDPS.type
    • RANDPS.uncross_reference()
    • RANDPS.validate()
    • RANDPS.write_card()
    • RANDPS.x
  • RANDT1
    • RANDT1._init_from_empty()
    • RANDT1.add_card()
    • RANDT1.cross_reference()
    • RANDT1.get_loads()
    • RANDT1.raw_fields()
    • RANDT1.repr_fields()
    • RANDT1.safe_cross_reference()
    • RANDT1.sid
    • RANDT1.type
    • RANDT1.uncross_reference()
    • RANDT1.write_card()
  • RandomLoad
• static_loads Module
  • ACCEL
    • ACCEL.Cid()
    • ACCEL.N
    • ACCEL._init_from_empty()
    • ACCEL.add_card()
    • ACCEL.cid
    • ACCEL.cross_reference()
    • ACCEL.direction
    • ACCEL.get_loads()
    • ACCEL.raw_fields()
    • ACCEL.safe_cross_reference()
    • ACCEL.sid
    • ACCEL.type
    • ACCEL.uncross_reference()
    • ACCEL.validate()
    • ACCEL.write_card()
  • ACCEL1
    • ACCEL1.Cid()
    • ACCEL1.N
    • ACCEL1._init_from_empty()
    • ACCEL1._properties
    • ACCEL1.add_card()
    • ACCEL1.cid
    • ACCEL1.cross_reference()
    • ACCEL1.get_loads()
    • ACCEL1.node_ids
    • ACCEL1.nodes
    • ACCEL1.raw_fields()
    • ACCEL1.safe_cross_reference()
    • ACCEL1.scale
    • ACCEL1.sid
    • ACCEL1.type
    • ACCEL1.uncross_reference()
    • ACCEL1.validate()
    • ACCEL1.write_card()
  • CLOAD
    • CLOAD._init_from_empty()
    • CLOAD.cross_reference()
    • CLOAD.get_load_ids()
    • CLOAD.raw_fields()
    • CLOAD.safe_cross_reference()
    • CLOAD.type
    • CLOAD.uncross_reference()
    • CLOAD.write_card()
  • FORCE
    • FORCE.type
    • FORCE.write_card()
  • FORCE1
    • FORCE1.type
  • FORCE2
    • FORCE2._properties
    • FORCE2.type
  • GRAV
    • GRAV.Cid()
    • GRAV.GravityVector()
    • GRAV.N
    • GRAV._init_from_empty()
    • GRAV.add_card()
    • GRAV.add_card_lax()
    • GRAV.cid
    • GRAV.cross_reference()
    • GRAV.get_loads()
    • GRAV.mb
    • GRAV.raw_fields()
    • GRAV.repr_fields()
    • GRAV.safe_cross_reference()
    • GRAV.scale
    • GRAV.sid
    • GRAV.type
    • GRAV.uncross_reference()
    • GRAV.validate()
    • GRAV.write_card()
  • LOAD
    • LOAD._init_from_empty()
    • LOAD.cross_reference()
    • LOAD.get_load_types()
    • LOAD.get_reduced_loads()
    • LOAD.raw_fields()
    • LOAD.repr_fields()
    • LOAD.safe_cross_reference()
    • LOAD.type
    • LOAD.uncross_reference()
    • LOAD.write_card()
  • Load0
    • Load0.Cid()
    • Load0.add_card()
    • Load0.add_card_lax()
    • Load0.cross_reference()
    • Load0.export_to_hdf5()
    • Load0.get_loads()
    • Load0.node_id
    • Load0.raw_fields()
    • Load0.repr_fields()
    • Load0.safe_cross_reference()
    • Load0.scaled_vector
    • Load0.to_global()
    • Load0.uncross_reference()
    • Load0.validate()
  • Load1
    • Load1.G1()
    • Load1.G2()
    • Load1._init_from_empty()
    • Load1._properties
    • Load1.add_card()
    • Load1.cross_reference()
    • Load1.get_loads()
    • Load1.node_id
    • Load1.node_ids
    • Load1.raw_fields()
    • Load1.repr_fields()
    • Load1.safe_cross_reference()
    • Load1.scaled_vector
    • Load1.to_global()
    • Load1.uncross_reference()
    • Load1.write_card()
  • Load2
    • Load2.G1()
    • Load2.G2()
    • Load2.G3()
    • Load2.G4()
    • Load2._init_from_empty()
    • Load2._properties
    • Load2.add_card()
    • Load2.cross_reference()
    • Load2.get_loads()
    • Load2.node_id
    • Load2.node_ids
    • Load2.raw_fields()
    • Load2.repr_fields()
    • Load2.safe_cross_reference()
    • Load2.scaled_vector
    • Load2.uncross_reference()
    • Load2.validate()
    • Load2.write_card()
  • MOMENT
    • MOMENT.node_id
    • MOMENT.node_ids
    • MOMENT.raw_fields()
    • MOMENT.repr_fields()
    • MOMENT.type
    • MOMENT.uncross_reference()
    • MOMENT.write_card()
  • MOMENT1
    • MOMENT1.type
  • MOMENT2
    • MOMENT2._properties
    • MOMENT2.type
  • PLOAD
    • PLOAD._init_from_empty()
    • PLOAD._properties
    • PLOAD.add_card()
    • PLOAD.cross_reference()
    • PLOAD.get_loads()
    • PLOAD.raw_fields()
    • PLOAD.repr_fields()
    • PLOAD.safe_cross_reference()
    • PLOAD.type
    • PLOAD.uncross_reference()
    • PLOAD.write_card()
  • PLOAD1
    • PLOAD1.Eid()
    • PLOAD1.Type
    • PLOAD1._init_from_empty()
    • PLOAD1.add_card()
    • PLOAD1.cross_reference()
    • PLOAD1.get_loads()
    • PLOAD1.raw_fields()
    • PLOAD1.repr_fields()
    • PLOAD1.safe_cross_reference()
    • PLOAD1.type
    • PLOAD1.uncross_reference()
    • PLOAD1.valid_scales
    • PLOAD1.valid_types
    • PLOAD1.validate()
    • PLOAD1.write_card()
  • PLOAD2
    • PLOAD2._init_from_empty()
    • PLOAD2._properties
    • PLOAD2.add_card()
    • PLOAD2.cross_reference()
    • PLOAD2.element_ids
    • PLOAD2.get_loads()
    • PLOAD2.raw_fields()
    • PLOAD2.raw_fields_separate()
    • PLOAD2.repr_fields()
    • PLOAD2.safe_cross_reference()
    • PLOAD2.type
    • PLOAD2.uncross_reference()
    • PLOAD2.write_card()
    • PLOAD2.write_card_separate()
  • PLOAD4
    • PLOAD4.Cid()
    • PLOAD4.G1()
    • PLOAD4.G34()
    • PLOAD4._init_from_empty()
    • PLOAD4._properties
    • PLOAD4.add_card()
    • PLOAD4.cid
    • PLOAD4.cross_reference()
    • PLOAD4.element_ids
    • PLOAD4.g1
    • PLOAD4.g34
    • PLOAD4.get_element_ids()
    • PLOAD4.get_loads()
    • PLOAD4.node_ids
    • PLOAD4.raw_fields()
    • PLOAD4.repr_fields()
    • PLOAD4.safe_cross_reference()
    • PLOAD4.type
    • PLOAD4.uncross_reference()
    • PLOAD4.validate()
    • PLOAD4.write_card()
  • normalize()
  • update_pload4_vector()

thermal Package

• loads Module
  • QBDY1
    • QBDY1.Eids()
    • QBDY1._init_from_empty()
    • QBDY1._properties
    • QBDY1.add_card()
    • QBDY1.cross_reference()
    • QBDY1.element_ids
    • QBDY1.get_loads()
    • QBDY1.nQFluxTerms()
    • QBDY1.qflux
    • QBDY1.raw_fields()
    • QBDY1.repr_fields()
    • QBDY1.safe_cross_reference()
    • QBDY1.sid
    • QBDY1.type
    • QBDY1.uncross_reference()
    • QBDY1.write_card()
  • QBDY2
    • QBDY2.Eid()
    • QBDY2._init_from_empty()
    • QBDY2.add_card()
    • QBDY2.cross_reference()
    • QBDY2.eid
    • QBDY2.get_loads()
    • QBDY2.nQFluxTerms()
    • QBDY2.raw_fields()
    • QBDY2.repr_fields()
    • QBDY2.safe_cross_reference()
    • QBDY2.sid
    • QBDY2.type
    • QBDY2.uncross_reference()
    • QBDY2.write_card()
  • QBDY3
    • QBDY3.Eids()
    • QBDY3._init_from_empty()
    • QBDY3._properties
    • QBDY3.add_card()
    • QBDY3.control_node
    • QBDY3.cross_reference()
    • QBDY3.eids
    • QBDY3.element_ids
    • QBDY3.get_loads()
    • QBDY3.q0
    • QBDY3.raw_fields()
    • QBDY3.repr_fields()
    • QBDY3.safe_cross_reference()
    • QBDY3.sid
    • QBDY3.type
    • QBDY3.uncross_reference()
    • QBDY3.write_card()
  • QHBDY
    • QHBDY._init_from_empty()
    • QHBDY._properties
    • QHBDY.add_card()
    • QHBDY.af
    • QHBDY.cross_reference()
    • QHBDY.flag_to_nnodes
    • QHBDY.get_loads()
    • QHBDY.grids
    • QHBDY.q0
    • QHBDY.raw_fields()
    • QHBDY.repr_fields()
    • QHBDY.safe_cross_reference()
    • QHBDY.sid
    • QHBDY.type
    • QHBDY.uncross_reference()
    • QHBDY.write_card()
  • QVECT
    • QVECT.Eids()
    • QVECT._init_from_empty()
    • QVECT._properties
    • QVECT.add_card()
    • QVECT.cross_reference()
    • QVECT.element_ids
    • QVECT.get_loads()
    • QVECT.raw_fields()
    • QVECT.repr_fields()
    • QVECT.safe_cross_reference()
    • QVECT.sid
    • QVECT.type
    • QVECT.uncross_reference()
    • QVECT.validate()
    • QVECT.write_card()
  • QVOL
    • QVOL.Eids()
    • QVOL._init_from_empty()
    • QVOL._properties
    • QVOL.add_card()
    • QVOL.cross_reference()
    • QVOL.element_ids
    • QVOL.get_loads()
    • QVOL.raw_fields()
    • QVOL.repr_fields()
    • QVOL.safe_cross_reference()
    • QVOL.sid
    • QVOL.type
    • QVOL.uncross_reference()
    • QVOL.write_card()
  • TEMP
    • TEMP._init_from_empty()
    • TEMP.add()
    • TEMP.add_card()
    • TEMP.cross_reference()
    • TEMP.export_to_hdf5()
    • TEMP.get_loads()
    • TEMP.raw_fields()
    • TEMP.repr_fields()
    • TEMP.safe_cross_reference()
    • TEMP.sid
    • TEMP.temperatures
    • TEMP.type
    • TEMP.uncross_reference()
    • TEMP.write_card()
  • TEMPB3
    • TEMPB3._init_from_empty()
    • TEMPB3.add_card()
    • TEMPB3.cross_reference()
    • TEMPB3.get_loads()
    • TEMPB3.raw_fields()
    • TEMPB3.type
    • TEMPB3.uncross_reference()
    • TEMPB3.write_card()
  • TEMPD
    • TEMPD._init_from_empty()
    • TEMPD.add()
    • TEMPD.add_card()
    • TEMPD.add_card_lax()
    • TEMPD.cross_reference()
    • TEMPD.raw_fields()
    • TEMPD.safe_cross_reference()
    • TEMPD.type
    • TEMPD.uncross_reference()
    • TEMPD.write_card()
  • TEMPP1
    • TEMPP1._init_from_empty()
    • TEMPP1.add_card()
    • TEMPP1.raw_fields()
    • TEMPP1.type
    • TEMPP1.write_card()
  • TEMPRB
    • TEMPRB._init_from_empty()
    • TEMPRB.add_card()
    • TEMPRB.cross_reference()
    • TEMPRB.get_loads()
    • TEMPRB.raw_fields()
    • TEMPRB.repr_fields()
    • TEMPRB.safe_cross_reference()
    • TEMPRB.sid
    • TEMPRB.type
    • TEMPRB.uncross_reference()
    • TEMPRB.write_card()
  • ThermalLoad
• radiation Module
  • RADBC
    • RADBC.Eids()
    • RADBC.add_card()
    • RADBC.control_node
    • RADBC.cross_reference()
    • RADBC.famb
    • RADBC.nodamb
    • RADBC.raw_fields()
    • RADBC.repr_fields()
    • RADBC.type
    • RADBC.validate()
    • RADBC.write_card()
  • RADCAV
    • RADCAV.add_card()
    • RADCAV.raw_fields()
    • RADCAV.repr_fields()
    • RADCAV.type
    • RADCAV.write_card()
  • RADLST
    • RADLST.add_card()
    • RADLST.raw_fields()
    • RADLST.type
    • RADLST.write_card()
  • RADM
    • RADM.add_card()
    • RADM.radmid
    • RADM.raw_fields()
    • RADM.repr_fields()
    • RADM.type
    • RADM.validate()
    • RADM.write_card()
  • RADMTX
    • RADMTX.add_card()
    • RADMTX.raw_fields()
    • RADMTX.type
    • RADMTX.write_card()
  • VIEW
    • VIEW.add_card()
    • VIEW.iview
    • VIEW.raw_fields()
    • VIEW.repr_fields()
    • VIEW.type
    • VIEW.write_card()
  • VIEW3D
    • VIEW3D.add_card()
    • VIEW3D.icavity
    • VIEW3D.raw_fields()
    • VIEW3D.repr_fields()
    • VIEW3D.type
    • VIEW3D.write_card()
• thermal Module
  • CHBDYE
    • CHBDYE.Eid()
    • CHBDYE.Eid2()
    • CHBDYE.Pid()
    • CHBDYE._init_from_empty()
    • CHBDYE._properties
    • CHBDYE.add_card()
    • CHBDYE.cross_reference()
    • CHBDYE.eid
    • CHBDYE.eid2
    • CHBDYE.get_edge_ids()
    • CHBDYE.hex_map
    • CHBDYE.iview_back
    • CHBDYE.iview_front
    • CHBDYE.node_ids
    • CHBDYE.nodes
    • CHBDYE.pent_map
    • CHBDYE.rad_mid_back
    • CHBDYE.rad_mid_front
    • CHBDYE.raw_fields()
    • CHBDYE.repr_fields()
    • CHBDYE.safe_cross_reference()
    • CHBDYE.side
    • CHBDYE.side_maps
    • CHBDYE.tet_map
    • CHBDYE.type
    • CHBDYE.uncross_reference()
    • CHBDYE.write_card()
  • CHBDYG
    • CHBDYG.Eid()
    • CHBDYG._init_from_empty()
    • CHBDYG._properties
    • CHBDYG.add_card()
    • CHBDYG.cross_reference()
    • CHBDYG.eid
    • CHBDYG.get_edge_ids()
    • CHBDYG.iview_back
    • CHBDYG.iview_front
    • CHBDYG.node_ids
    • CHBDYG.nodes
    • CHBDYG.rad_mid_back
    • CHBDYG.rad_mid_front
    • CHBDYG.raw_fields()
    • CHBDYG.repr_fields()
    • CHBDYG.safe_cross_reference()
    • CHBDYG.surface_type
    • CHBDYG.type
    • CHBDYG.uncross_reference()
    • CHBDYG.validate()
    • CHBDYG.write_card()
  • CHBDYP
    • CHBDYP.Ce()
    • CHBDYP.Eid()
    • CHBDYP.Pid()
    • CHBDYP.Type
    • CHBDYP._finalize_hdf5()
    • CHBDYP._init_from_empty()
    • CHBDYP._properties
    • CHBDYP.add_card()
    • CHBDYP.ce
    • CHBDYP.cross_reference()
    • CHBDYP.e1
    • CHBDYP.eid
    • CHBDYP.g0
    • CHBDYP.g1
    • CHBDYP.g2
    • CHBDYP.gmid
    • CHBDYP.iview_back
    • CHBDYP.iview_front
    • CHBDYP.node_ids
    • CHBDYP.nodes
    • CHBDYP.pid
    • CHBDYP.rad_mid_back
    • CHBDYP.rad_mid_front
    • CHBDYP.raw_fields()
    • CHBDYP.repr_fields()
    • CHBDYP.safe_cross_reference()
    • CHBDYP.type
    • CHBDYP.uncross_reference()
    • CHBDYP.write_card()
  • CONV
    • CONV.Eid()
    • CONV.TA()
    • CONV._init_from_empty()
    • CONV.add_card()
    • CONV.control_node
    • CONV.cross_reference()
    • CONV.eid
    • CONV.film_node
    • CONV.pconid
    • CONV.raw_fields()
    • CONV.repr_fields()
    • CONV.type
    • CONV.uncross_reference()
    • CONV.write_card()
  • CONVM
    • CONVM.Eid()
    • CONVM._init_from_empty()
    • CONVM._properties
    • CONVM.add_card()
    • CONVM.cross_reference()
    • CONVM.film_node_id
    • CONVM.pconvm_id
    • CONVM.raw_fields()
    • CONVM.repr_fields()
    • CONVM.type
    • CONVM.write_card()
  • PCONV
    • PCONV.Ce()
    • PCONV.Gidin()
    • PCONV._init_from_empty()
    • PCONV.add_card()
    • PCONV.ce
    • PCONV.chlen
    • PCONV.cross_reference()
    • PCONV.expf
    • PCONV.form
    • PCONV.ftype
    • PCONV.gidin
    • PCONV.mid
    • PCONV.pconid
    • PCONV.raw_fields()
    • PCONV.repr_fields()
    • PCONV.tid
    • PCONV.type
    • PCONV.uncross_reference()
    • PCONV.write_card()
  • PCONVM
    • PCONVM._init_from_empty()
    • PCONVM.add_card()
    • PCONVM.coef
    • PCONVM.exppi
    • PCONVM.exppo
    • PCONVM.expr
    • PCONVM.flag
    • PCONVM.form
    • PCONVM.mid
    • PCONVM.pconid
    • PCONVM.raw_fields()
    • PCONVM.repr_fields()
    • PCONVM.type
    • PCONVM.uncross_reference()
    • PCONVM.write_card()
  • PHBDY
    • PHBDY._init_from_empty()
    • PHBDY.add_card()
    • PHBDY.af
    • PHBDY.d1
    • PHBDY.pid
    • PHBDY.raw_fields()
    • PHBDY.repr_fields()
    • PHBDY.type
    • PHBDY.uncross_reference()
    • PHBDY.write_card()
  • TEMPBC
    • TEMPBC._init_from_empty()
    • TEMPBC._properties
    • TEMPBC.add_card()
    • TEMPBC.eid
    • TEMPBC.raw_fields()
    • TEMPBC.type
    • TEMPBC.write_card()
  • ThermalBC
  • ThermalCard
    • ThermalCard.cross_reference()
  • ThermalElement
  • ThermalProperty