Source code for pyNastran.bdf.cards.material_deps

"""
All material dependency cards are defined in this file.  This includes:

 * MATS1 (isotropic solid/shell)

 * MATT1 (isotropic solid/shell)
 * MATT2 (anisotropic)
 * MATT3 (linear orthotropic) - NA
 * MATT4 (thermal)
 * MATT5 (thermal)
 * MATT8 (orthotropic shell) - NA
 * MATT9 (anisotropic solid) - NA

All cards are Material objects.

"""
#pylint: disable=E1103,C0103,C0111
from __future__ import annotations
from typing import TYPE_CHECKING

from pyNastran.bdf.cards.base_card import BaseCard
from pyNastran.bdf.bdf_interface.assign_type import (
    integer, integer_or_blank, double, double_or_blank, string)
from pyNastran.bdf.field_writer_8 import print_card_8
from pyNastran.bdf.field_writer_16 import print_card_16
if TYPE_CHECKING:  # pragma: no cover
    from pyNastran.bdf.bdf import BDF


[docs] class MaterialDependence(BaseCard): def __init__(self): self.mid = None
[docs] def Mid(self): if self.mid_ref is None: return self.mid return self.mid_ref.mid # TODO: is this something that should be supported?
[docs] def _get_table(self, key): """internal method for accessing tables""" table = getattr(self, key) table_ref = getattr(self, key + '_ref') if table_ref is not None: return table_ref.tid return table
[docs] class MaterialDependenceThermal(MaterialDependence): def __init__(self): MaterialDependence.__init__(self)
[docs] def _xref_table(self, model, key, msg): slot = getattr(self, key) if slot is not None: setattr(self, key + '_ref', model.TableM(slot, msg + f' for {key}'))
[docs] class MATS1(MaterialDependence): """ Specifies stress-dependent material properties for use in applications involving nonlinear materials. This entry is used if a MAT1, MAT2 or MAT9 entry is specified with the same MID in a nonlinear solution sequence (SOLs 106 and 129). """ type = 'MATS1' def __init__(self, mid, tid, Type, h, hr, yf, limit1, limit2, comment=''): MaterialDependence.__init__(self) if comment: self.comment = comment #: Identification number of a MAT1, MAT2, or MAT9 entry. self.mid = mid #: Identification number of a TABLES1 or TABLEST entry. If H is #: given, then this field must be blank. self.tid = tid #: Type of material nonlinearity. ('NLELAST' for nonlinear elastic #: or 'PLASTIC' for elastoplastic.) self.Type = Type #: Work hardening slope (slope of stress versus plastic strain) #: in units of stress. For elastic-perfectly plastic cases, #: H=0.0. For more than a single slope in the plastic range, #: the stress-strain data must be supplied on a TABLES1 entry #: referenced by TID, and this field must be blank self.h = h #: Hardening Rule, selected by one of the following values #: (Integer): (1) Isotropic (Default) (2) Kinematic #: (3) Combined isotropic and kinematic hardening self.hr = hr #: Yield function criterion, selected by one of the following #: values (1) Von Mises (2) Tresca (3) Mohr-Coulomb #: (4) Drucker-Prager self.yf = yf #: Initial yield point self.limit1 = limit1 #: Internal friction angle, measured in degrees, for the #: Mohr-Coulomb and Drucker-Prager yield criteria self.limit2 = limit2 self.tid_ref = None self.mid_ref = None
[docs] @classmethod def _init_from_empty(cls): mid = 1 tid = 1 Type = None h = None hr = None yf = None limit1 = None limit2 = None return MATS1(mid, tid, Type, h, hr, yf, limit1, limit2, comment='')
[docs] def validate(self): if self.Type not in ['NLELAST', 'PLASTIC', 'PLSTRN']: raise ValueError('MATS1 Type must be [NLELAST, PLASTIC, PLSTRN]; Type=%r' % self.Type)
[docs] @classmethod def add_card(cls, card, comment=''): """ Adds a MATS1 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') tid = integer_or_blank(card, 2, 'tid') Type = string(card, 3, 'Type') if Type not in ['NLELAST', 'PLASTIC', 'PLSTRN']: raise ValueError('MATS1 Type must be [NLELAST, PLASTIC, PLSTRN]; Type=%r' % Type) if Type == 'NLELAST': # should we even read these? h = None hr = None yf = None limit1 = None limit2 = None #h = blank(card, 4, 'h') #hr = blank(card, 6, 'hr') #yf = blank(card, 5, 'yf') #limit1 = blank(card, 7, 'yf') #limit2 = blank(card, 8, 'yf') else: h = double_or_blank(card, 4, 'H') yf = integer_or_blank(card, 5, 'yf', 1) hr = integer_or_blank(card, 6, 'hr', 1) limit1 = double(card, 7, 'limit1') if yf in [3, 4]: limit2 = double(card, 8, 'limit2') else: #limit2 = blank(card, 8, 'limit2') limit2 = None assert len(card) <= 9, f'len(MATS1 card) = {len(card):d}\ncard={card}' return MATS1(mid, tid, Type, h, hr, yf, limit1, limit2, comment=comment)
@classmethod def add_op2_data(cls, data, comment=''): """ Adds a MATS1 card from the OP2 Parameters ---------- data : list[varies] a list of fields defined in OP2 format comment : str; default='' a comment for the card """ (mid, tid, Type, h, yf, hr, limit1, limit2) = data if Type == 1: Type = 'NLELAST' elif Type == 2: Type = 'PLASTIC' elif Type == 3: Type = 'PLSTRN' else: # pragma: no cover raise RuntimeError(f'Invalid Type: mid={mid}; Type={Type}; must be 1=NLELAST, ' '2=PLASTIC, or 3=PLSTRN') return MATS1(mid, tid, Type, h, hr, yf, limit1, limit2, comment=comment)
[docs] def Yf(self): d = {1: 'VonMises', 2: 'Tresca', 3: 'MohrCoulomb', 4: 'Drucker-Prager'} return d[self.yf]
[docs] def Hf(self): d = {1: 'Isotropic', 2: 'Kinematic', 3: 'Combined'} return d[self.hr]
[docs] def E(self, strain): """ Gets E (Young's Modulus) for a given strain. Parameters ---------- strain : float / None the strain (None -> linear E value) Returns ------- E : float Young's Modulus """ msg = "E (Young's Modulus) not implemented for MATS1" raise NotImplementedError(msg)
#if self.tid: #E = self.tid_ref.Value(strain) #return E
[docs] def cross_reference(self, model: BDF) -> None: """ Cross links the card so referenced cards can be extracted directly Parameters ---------- model : BDF() the BDF object """ msg = ', which is required by MATS1 mid=%s' % self.mid self.mid_ref = model.Material(self.mid, msg=msg) if self.tid: # then self.h is used self.tid_ref = model.Table(self.tid, msg=msg) # TABLES1 or TABLEST
[docs] def uncross_reference(self) -> None: """Removes cross-reference links""" self.mid = self.Mid() if self.tid: self.tid = self.Tid() self.tid_ref = None self.mid_ref = None
[docs] def Tid(self): if self.tid_ref is None: return self.tid return self.tid_ref.tid
[docs] def raw_fields(self): list_fields = ['MATS1', self.Mid(), self.Tid(), self.Type, self.h, self.yf, self.hr, self.limit1, self.limit2] return list_fields
[docs] def repr_fields(self): return self.raw_fields()
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: card = self.repr_fields() if size == 8: return self.comment + print_card_8(card) return self.comment + print_card_16(card)
[docs] class MATDMG(MaterialDependence): """ Material Properties for Progressive Ply Failure Defines material properties and parameters for progressive ply failure in composite solid elements defined with the PCOMPS bulk entry. Used in combination with MAT11 entries that have the same MID. Valid for SOLs 401 and 402. +--------+-------+--------+-------+------+-----+-----+-----+-----+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +========+=======+========+=======+======+=====+=====+=====+=====+ | MATDMG | MID | PPFMOD | | | | | | | +--------+-------+--------+-------+------+-----+-----+-----+-----+ | | COEF1 | COEF2 | -etc- | | | | | | +--------+-------+--------+-------+------+-----+-----+-----+-----+ Format for PPFMOD == "UD" +--------+--------+------+------+------+---------+---------+------+------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +========+========+======+======+======+=========+=========+======+======+ | MATDMG | MID | UD | | | | | | | +--------+--------+------+------+------+---------+---------+------+------+ | | Y012 | YC12 | YS12 | YS22 | Y11LIMT | Y11LIMC | KSIT | KSIC | +--------+--------+------+------+------+---------+---------+------+------+ | | B2 | B3 | A | LITK | BIGK | EXPN | TAU | ADEL | +--------+--------+------+------+------+---------+---------+------+------+ | | PLYUNI | TID | HBAR | DMAX | PE | | | | +--------+--------+------+------+------+---------+---------+------+------+ Format for PPFMOD == "EUD" +--------+--------+------+------+-------+---------+---------+------+------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +========+========+======+======+=======+=========+=========+======+======+ | MATDMG | MID | EUD | | | | | | | +--------+--------+------+------+-------+---------+---------+------+------+ | | Y012 | YC12 | K | ALPHA | Y11LIMT | Y11LIMC | KSIT | KSIC | +--------+--------+------+------+-------+---------+---------+------+------+ | | B2 | B3 | A | LITK | BIGK | EXPN | TAU | ADEL | +--------+--------+------+------+-------+---------+---------+------+------+ | | USER | R01 | HBAR | DMAX | DS | GIC | GIIC | GIIIC| +--------+--------+------+------+-------+---------+---------+------+------+ """ type = 'MATDMG' def __init__(self, mid, ppf_model, y012, yc12, ys12, ys22, y11limt, y11limc, ksit=None, ksic=None, b2=None, b3=None, a=None, litk=None, bigk=None, expn=None, tau=None, adel=None, plyuni=None, tid=None, hbar=None, dmax=None, pe=None, user=None, r01=None, ds=None, gic=None, giic=None, giiic=None, comment=''): MaterialDependence.__init__(self) if comment: self.comment = comment if ppf_model == 'EUD': assert gic is not None, f'Invalid GIC; {gic}; should be a float in case of PPFMOD == "EUD"' assert giic is not None, f'Invalid GIIC; {giic}; should be a float in case of PPFMOD == "EUD"' assert giiic is not None, f'Invalid GIIIC; {giiic}; should be a float in case of PPFMOD == "EUD"' self.mid = mid self.ppf_model = ppf_model self.y012 = y012 self.yc12 = yc12 self.ys12 = ys12 self.ys22 = ys22 self.y11limt = y11limt self.y11limc = y11limc self.ksit = ksit self.ksic = ksic self.b2 = b2 self.b3 = b3 self.a = a self.litk = litk self.bigk = bigk self.expn = expn self.tau = tau self.adel = adel self.plyuni = plyuni self.tid = tid self.hbar = hbar self.dmax = dmax self.pe = pe self.user = user self.r01 = r01 self.ds = ds self.gic = gic self.giic = giic self.giiic = giiic
[docs] @classmethod def add_card(cls, card, comment=''): """ Adds a MATDMG card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') ppf_model = string(card, 2, 'PPFMOD') y012 = double(card, 9, 'Y012') yc12 = double(card, 10, 'YC12') ys12 = double(card, 11, 'YS12') ys22 = double(card, 12, 'YS22') y11limt = double(card, 13, 'Y11LIMT') y11limc = double(card, 14, 'Y11LIMC') ksit = double_or_blank(card, 15, 'KSIT') ksic = double_or_blank(card, 16, 'KSIC') b2 = double(card, 17, 'B2') b3 = double(card, 18, 'B3') a = double(card, 19, 'A') litk = double(card, 20, 'LITK') bigk = double(card, 21, 'BIGK') expn = double(card, 22, 'EXPN') tau = double(card, 23, 'TAU') adel = double(card, 24, 'ADEL') if ppf_model == 'UD': plyuni = integer_or_blank(card, 25, 'PLYUNI') tid = integer_or_blank(card, 26, 'TID') hbar = double(card, 27, 'HBAR') dmax = double(card, 28, 'DMAX') pe = integer_or_blank(card, 29, 'PE') user = None r01 = None ds = None gic = None giic = None giiic = None elif ppf_model == 'EUD': user = integer(card, 25, 'USER') r01 = double(card, 26, 'R01') hbar = double(card, 27, 'HBAR') dmax = double(card, 28, 'DMAX') ds = double_or_blank(card, 29, 'DS') gic = double(card, 30, 'GIC') giic = double(card, 31, 'GIIC') giiic = double(card, 32, 'GIIIC') plyuni = None tid = None pe = None else: raise RuntimeError(f'Invalid PPFMOD: mid={mid}; PPFMOD={ppf_model}; must be UD or EUD.') return MATDMG(mid, ppf_model, y012, yc12, ys12, ys22, y11limt, y11limc, ksit, ksic, b2, b3, a, litk, bigk, expn, tau, adel, plyuni, tid, hbar, dmax, pe, user, r01, ds, gic, giic, giiic, comment=comment)
[docs] def raw_fields(self): if self.ppf_model == "UD": list_fields = ['MATDMG', self.mid, self.ppf_model, None, None, None, None, None, None, self.y012, self.yc12, self.ys12, self.ys22, self.y11limt, self.y11limc, self.ksit, self.ksic, self.b2, self.b3, self.a, self.litk, self.bigk, self.expn, self.tau, self.adel, self.plyuni, self.tid, self.hbar, self.dmax, self.pe, self.user, self.r01, self.ds, self.gic, self.giic, self.giiic] else: list_fields = ['MATDMG', self.mid, self.ppf_model, None, None, None, None, None, None, self.y012, self.yc12, self.ys12, self.ys22, self.y11limt, self.y11limc, self.ksit, self.ksic, self.b2, self.b3, self.a, self.litk, self.bigk, self.expn, self.tau, self.adel, self.user, self.r01, self.hbar, self.dmax, self.ds, self.gic, self.giic, self.giiic] return list_fields
[docs] def repr_fields(self): """ Gets the fields in their simplified form Returns ------- fields : [varies, ...] the fields that define the card """ return self.raw_fields()
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: card = self.repr_fields() if size == 8: return self.comment + print_card_8(card) return self.comment + print_card_16(card)
[docs] class MATT1(MaterialDependenceThermal): """ Specifies temperature-dependent material properties on MAT1 entry fields via TABLEMi entries. +-------+-------+-------+-------+-------+--------+------+------+-------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +=======+=======+=======+=======+=======+========+======+======+=======+ | MATT1 | MID | T(E) | T(G) | T(NU) | T(RHO) | T(A) | | T(GE) | +-------+-------+-------+-------+-------+--------+------+------+-------+ | | T(ST) | T(SC) | T(SS) | | | | | | +-------+-------+-------+-------+-------+--------+------+------+-------+ """ type = 'MATT1'
[docs] @classmethod def _init_from_empty(cls): mid = 1 return MATT1(mid, e_table=None, g_table=None, nu_table=None, rho_table=None, a_table=None, ge_table=None, st_table=None, sc_table=None, ss_table=None, comment='')
def __init__(self, mid, e_table=None, g_table=None, nu_table=None, rho_table=None, a_table=None, ge_table=None, st_table=None, sc_table=None, ss_table=None, comment=''): MaterialDependenceThermal.__init__(self) if comment: self.comment = comment self.mid = mid if e_table == 0: e_table = None if g_table == 0: g_table = None if nu_table == 0: nu_table = None if rho_table == 0: rho_table = None if a_table == 0: a_table = None if ge_table == 0: ge_table = None if st_table == 0: st_table = None if sc_table == 0: sc_table = None if ss_table == 0: ss_table = None self.e_table = e_table self.g_table = g_table self.nu_table = nu_table self.rho_table = rho_table self.a_table = a_table self.ge_table = ge_table self.st_table = st_table self.sc_table = sc_table self.ss_table = ss_table self.mid_ref = None self.ss_table_ref = None self.e_table_ref = None self.g_table_ref = None self.nu_table_ref = None self.rho_table_ref = None self.a_table_ref = None self.ge_table_ref = None self.st_table_ref = None self.sc_table_ref = None self.ss_table_ref = None
[docs] @classmethod def add_card(cls, card, comment=''): """ Adds a MATT1 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') e_table = integer_or_blank(card, 2, 'T(E)') g_table = integer_or_blank(card, 3, 'T(G)') nu_table = integer_or_blank(card, 4, 'T(nu)') rho_table = integer_or_blank(card, 5, 'T(rho)') a_table = integer_or_blank(card, 6, 'T(A)') ge_table = integer_or_blank(card, 8, 'T(ge)') st_table = integer_or_blank(card, 9, 'T(st)') sc_table = integer_or_blank(card, 10, 'T(sc)') ss_table = integer_or_blank(card, 11, 'T(ss)') assert len(card) <= 12, f'len(MATT1 card) = {len(card):d}\ncard={card}' return MATT1(mid, e_table, g_table, nu_table, rho_table, a_table, ge_table, st_table, sc_table, ss_table, comment=comment)
@classmethod def add_op2_data(cls, data, comment=''): """ Adds a MATT1 card from the OP2 Parameters ---------- data : list[varies] a list of fields defined in OP2 format comment : str; default='' a comment for the card """ (mid, E_table, G_table, nu_table, rho_table, A_table, dunno_a, ge_table, st_table, sc_table, ss_table, dunno_b) = data if E_table == 0: E_table = None elif E_table > 100000000: E_table = -(E_table - 100000000) if G_table == 0: G_table = None elif G_table > 100000000: G_table = -(G_table - 100000000) if nu_table == 0: nu_table = None elif nu_table > 100000000: nu_table = -(nu_table - 100000000) if rho_table == 0: rho_table = None elif rho_table > 100000000: rho_table = -(rho_table - 100000000) if E_table == 0: E_table = None if A_table > 100000000: A_table = -(A_table - 100000000) mat = MATT1(mid, E_table, G_table, nu_table, rho_table, A_table, ge_table, st_table, sc_table, ss_table, comment=comment) assert dunno_a == 0, '%s; dunno_a=%s\n%s' % (data, dunno_a, str(mat)) assert dunno_b == 0, '%s; dunno_b=%s\n%s' % (data, dunno_b, str(mat)) return mat
[docs] def E(self, temperature): """ Gets E (Young's Modulus) for a given temperature. Parameters ---------- temperature : float; default=None the temperature (None -> linear E value) Returns ------- E : float Young's Modulus """ E = None if self.E_table: E = self.E_table.Value(temperature) return E
[docs] def cross_reference(self, model: BDF) -> None: """ Cross links the card so referenced cards can be extracted directly Parameters ---------- model : BDF() the BDF object """ msg = ', which is required by MATT1 mid=%s' % self.mid self.mid_ref = model.Material(self.mid, msg=msg) self._xref_table(model, 'e_table', msg=msg) self._xref_table(model, 'g_table', msg=msg) self._xref_table(model, 'nu_table', msg=msg) self._xref_table(model, 'rho_table', msg=msg) self._xref_table(model, 'a_table', msg=msg) self._xref_table(model, 'ge_table', msg=msg) self._xref_table(model, 'st_table', msg=msg) self._xref_table(model, 'sc_table', msg=msg) self._xref_table(model, 'ss_table', msg=msg)
[docs] def uncross_reference(self) -> None: """Removes cross-reference links""" self.mid = self.Mid() ## TODO: remove refs self.e_table = self.E_table() self.g_table = self.G_table() self.nu_table = self.Nu_table() self.rho_table = self.Rho_table() self.a_table = self.A_table() self.ge_table = self.Ge_table() self.st_table = self.St_table() self.sc_table = self.Sc_table() self.ss_table = self.Ss_table() self.mid_ref = None self.mid_ref = None self.ss_table_ref = None self.e_table_ref = None self.g_table_ref = None self.nu_table_ref = None self.rho_table_ref = None self.a_table_ref = None self.ge_table_ref = None self.st_table_ref = None self.sc_table_ref = None self.ss_table_ref = None
[docs] def E_table(self): return self._get_table('e_table')
[docs] def G_table(self): return self._get_table('g_table')
[docs] def Nu_table(self): return self._get_table('nu_table')
[docs] def Rho_table(self): return self._get_table('rho_table')
[docs] def A_table(self): return self._get_table('a_table')
[docs] def Ge_table(self): return self._get_table('ge_table')
[docs] def St_table(self): return self._get_table('st_table')
[docs] def Sc_table(self): return self._get_table('sc_table')
[docs] def Ss_table(self): return self._get_table('ss_table')
[docs] def raw_fields(self): list_fields = [ 'MATT1', self.Mid(), self.E_table(), self.G_table(), self.Nu_table(), self.Rho_table(), self.A_table(), self.Ge_table(), self.St_table(), self.Sc_table(), self.Ss_table(), ] return list_fields
[docs] def repr_fields(self): return self.raw_fields()
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: card = self.repr_fields() if size == 8: return self.comment + print_card_8(card) return self.comment + print_card_16(card)
[docs] class MATT2(MaterialDependenceThermal): """ Specifies temperature-dependent material properties on MAT2 entry fields via TABLEMi entries. +-------+-------+--------+--------+--------+--------+--------+--------+--------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +=======+=======+========+========+========+========+========+========+========+ | MATT2 | MID | T(G12) | T(G13) | T(G13) | T(G22) | T(G23) | T(G33) | T(RHO) | +-------+-------+--------+--------+--------+--------+--------+--------+--------+ | | T(A1) | T(A2) | T(A3) | | T(GE) | T(ST) | T(SC) | T(SS) | +-------+-------+--------+--------+--------+--------+--------+--------+--------+ """ type = 'MATT2'
[docs] @classmethod def _init_from_empty(cls): mid = 1 return MATT2(mid, g11_table=None, g12_table=None, g13_table=None, g22_table=None, g23_table=None, g33_table=None, rho_table=None, a1_table=None, a2_table=None, a3_table=None, ge_table=None, st_table=None, sc_table=None, ss_table=None, comment='')
def __init__(self, mid, g11_table=None, g12_table=None, g13_table=None, g22_table=None, g23_table=None, g33_table=None, rho_table=None, a1_table=None, a2_table=None, a3_table=None, ge_table=None, st_table=None, sc_table=None, ss_table=None, comment=''): MaterialDependenceThermal.__init__(self) if comment: self.comment = comment if g11_table == 0: g11_table = None if g12_table == 0: g12_table = None if g13_table == 0: g13_table = None if g22_table == 0: g22_table = None if g23_table == 0: g23_table = None if g33_table == 0: g33_table = None if rho_table == 0: rho_table = None if a1_table == 0: a1_table = None if a2_table == 0: a2_table = None if a3_table == 0: a3_table = None if ge_table == 0: ge_table = None if st_table == 0: st_table = None if sc_table == 0: sc_table = None if ss_table == 0: ss_table = None self.mid = mid self.g11_table = g11_table self.g12_table = g12_table self.g13_table = g13_table self.g22_table = g22_table self.g23_table = g23_table self.g33_table = g33_table self.rho_table = rho_table self.a1_table = a1_table self.a2_table = a2_table self.a3_table = a3_table self.ge_table = ge_table self.st_table = st_table self.sc_table = sc_table self.ss_table = ss_table self.mid_ref = None self.g11_table_ref = None self.g12_table_ref = None self.g13_table_ref = None self.g22_table_ref = None self.g23_table_ref = None self.g33_table_ref = None self.rho_table_ref = None self.a1_table_ref = None self.a2_table_ref = None self.a3_table_ref = None self.ge_table_ref = None self.st_table_ref = None self.sc_table_ref = None self.ss_table_ref = None
[docs] def validate(self): assert self.g11_table is None or self.g11_table > 0 assert self.g12_table is None or self.g12_table > 0 assert self.g13_table is None or self.g13_table > 0 assert self.g22_table is None or self.g22_table > 0 assert self.g23_table is None or self.g23_table > 0 assert self.g33_table is None or self.g33_table > 0 assert self.rho_table is None or self.rho_table > 0 assert self.a1_table is None or self.a1_table > 0 assert self.a2_table is None or self.a2_table > 0 assert self.a3_table is None or self.a3_table > 0 assert self.ge_table is None or self.ge_table > 0 assert self.st_table is None or self.st_table > 0 assert self.sc_table is None or self.sc_table > 0 assert self.ss_table is None or self.ss_table > 0
[docs] @classmethod def add_card(cls, card, comment=''): """ Adds a MATT2 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') g11_table = integer_or_blank(card, 2, 'T(G11)') g12_table = integer_or_blank(card, 3, 'T(G12)') g13_table = integer_or_blank(card, 4, 'T(G13)') g22_table = integer_or_blank(card, 5, 'T(G22)') g23_table = integer_or_blank(card, 6, 'T(G23)') g33_table = integer_or_blank(card, 7, 'T(G33)') rho_table = integer_or_blank(card, 8, 'T(rho)') a1_table = integer_or_blank(card, 9, 'T(A1)') a2_table = integer_or_blank(card, 10, 'T(A2)') a3_table = integer_or_blank(card, 11, 'T(A3)') ge_table = integer_or_blank(card, 13, 'T(ge)') st_table = integer_or_blank(card, 14, 'T(st)') sc_table = integer_or_blank(card, 15, 'T(sc)') ss_table = integer_or_blank(card, 16, 'T(ss)') assert len(card) <= 17, f'len(MATT2 card) = {len(card):d}\ncard={card}' return MATT2(mid, g11_table, g12_table, g13_table, g22_table, g23_table, g33_table, rho_table, a1_table, a2_table, a3_table, ge_table, st_table, sc_table, ss_table, comment=comment)
[docs] def cross_reference(self, model: BDF) -> None: """ Cross links the card so referenced cards can be extracted directly Parameters ---------- model : BDF() the BDF object """ msg = ', which is required by MATT2 mid=%s' % self.mid self.mid_ref = model.Material(self.mid, msg=msg) self._xref_table(model, 'g11_table', msg=msg) self._xref_table(model, 'g12_table', msg=msg) self._xref_table(model, 'g13_table', msg=msg) self._xref_table(model, 'g22_table', msg=msg) self._xref_table(model, 'g23_table', msg=msg) self._xref_table(model, 'g33_table', msg=msg) self._xref_table(model, 'rho_table', msg=msg) self._xref_table(model, 'a1_table', msg=msg) self._xref_table(model, 'a2_table', msg=msg) self._xref_table(model, 'a3_table', msg=msg) self._xref_table(model, 'ge_table', msg=msg) self._xref_table(model, 'st_table', msg=msg) self._xref_table(model, 'sc_table', msg=msg) self._xref_table(model, 'ss_table', msg=msg)
[docs] def uncross_reference(self) -> None: """Removes cross-reference links""" self.mid = self.Mid() self.g11_table = self.G11_table() self.g12_table = self.G12_table() self.g13_table = self.G13_table() self.g22_table = self.G22_table() self.g23_table = self.G23_table() self.g33_table = self.G33_table() self.rho_table = self.Rho_table() self.a1_table = self.A1_table() self.a2_table = self.A2_table() self.a3_table = self.A3_table() self.ge_table = self.Ge_table() self.st_table = self.St_table() self.sc_table = self.Sc_table() self.ss_table = self.Ss_table() self.mid_ref = None
[docs] def G11_table(self): return self._get_table('g11_table')
[docs] def G12_table(self): return self._get_table('g12_table')
[docs] def G13_table(self): return self._get_table('g13_table')
[docs] def G22_table(self): return self._get_table('g22_table')
[docs] def G23_table(self): return self._get_table('g23_table')
[docs] def G33_table(self): return self._get_table('g33_table')
[docs] def Rho_table(self): return self._get_table('rho_table')
[docs] def A1_table(self): return self._get_table('a1_table')
[docs] def A2_table(self): return self._get_table('a2_table')
[docs] def A3_table(self): return self._get_table('a3_table')
[docs] def Ge_table(self): return self._get_table('ge_table')
[docs] def St_table(self): return self._get_table('st_table')
[docs] def Sc_table(self): return self._get_table('sc_table')
[docs] def Ss_table(self): return self._get_table('ss_table')
[docs] def raw_fields(self): list_fields = [ 'MATT2', self.Mid(), self.G11_table(), self.G12_table(), self.G13_table(), self.G22_table(), self.G23_table(), self.G33_table(), self.Rho_table(), self.A1_table(), self.A2_table(), self.A3_table(), None, self.Ge_table(), self.St_table(), self.Sc_table(), self.Ss_table() ] return list_fields
[docs] def repr_fields(self): return self.raw_fields()
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: card = self.repr_fields() if size == 8: return self.comment + print_card_8(card) return self.comment + print_card_16(card)
#MATT3 - CTRIAX6 only
[docs] class MATT3(MaterialDependenceThermal): """ Specifies temperature-dependent material properties on MAT3 entry fields via TABLEMi entries that are temperature dependent. +--------+-------+-------+--------+-------+----------+----------+---------+--------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +========+=======+=======+========+=======+==========+==========+=========+========+ | MATT3 | MID | T(EX) | T(ETH) | T(EZ) | T(NUXTH) | T(NUTHZ) | T(NUZX) | T(RHO) | +--------+-------+-------+--------+-------+----------+----------+---------+--------+ | | | | T(GZX) | T(AX) | T(ATH) | T(AZ) | | T(GE) | +--------+-------+-------+--------+-------+----------+----------+---------+--------+ """ type = 'MATT3'
[docs] @classmethod def _init_from_empty(cls): mid = 1 return MATT3(mid, ex_table=None, eth_table=None, ez_table=None, nuth_table=None, nuxz_table=None, rho_table=None, gzx_table=None, ax_table=None, ath_table=None, az_table=None, ge_table=None, comment='')
def __init__(self, mid, ex_table=None, eth_table=None, ez_table=None, nuth_table=None, nuxz_table=None, rho_table=None, gzx_table=None, ax_table=None, ath_table=None, az_table=None, ge_table=None, comment=''): """ Creates a MATT3 card """ MaterialDependenceThermal.__init__(self) if comment: self.comment = comment ex_table = None if ex_table == 0 else ex_table eth_table = None if eth_table == 0 else eth_table ez_table = None if ez_table == 0 else ez_table nuth_table = None if nuth_table == 0 else nuth_table nuxz_table = None if nuxz_table == 0 else nuxz_table rho_table = None if rho_table == 0 else rho_table gzx_table = None if gzx_table == 0 else gzx_table ax_table = None if ax_table == 0 else ax_table ath_table = None if ath_table == 0 else ath_table az_table = None if az_table == 0 else az_table ge_table = None if ge_table == 0 else ge_table self.mid = mid self.ex_table = ex_table self.eth_table = eth_table self.ez_table = ez_table self.nuth_table = nuth_table self.nuxz_table = nuxz_table self.rho_table = rho_table self.gzx_table = gzx_table self.ax_table = ax_table self.ath_table = ath_table self.az_table = az_table self.ge_table = ge_table self.ex_table_ref = None self.eth_table_ref = None self.ez_table_ref = None self.nuth_table_ref = None self.nuxz_table_ref = None self.rho_table_ref = None self.gzx_table_ref = None self.ax_table_ref = None self.ath_table_ref = None self.az_table_ref = None self.ge_table_ref = None self.mid_ref = None
[docs] def validate(self): assert self.ex_table is None or self.ex_table > 0 assert self.eth_table is None or self.eth_table > 0 assert self.ez_table is None or self.ez_table > 0 assert self.nuth_table is None or self.nuth_table > 0 assert self.nuxz_table is None or self.nuxz_table > 0 assert self.rho_table is None or self.rho_table > 0 assert self.gzx_table is None or self.gzx_table > 0 assert self.ax_table is None or self.ax_table > 0 assert self.ath_table is None or self.ath_table > 0 assert self.az_table is None or self.az_table > 0 assert self.ge_table is None or self.ge_table > 0
[docs] def cross_reference(self, model: BDF) -> None: msg = ', which is required by MATT3 mid=%s' % self.mid self.mid_ref = model.Material(self.mid, msg=msg) #self._get_table('ex_table') if self.ex_table is not None: self.ex_table_ref = model.TableM(self.ex_table) if self.eth_table is not None: self.eth_table_ref = model.TableM(self.eth_table) if self.ez_table is not None: self.ez_table_ref = model.TableM(self.ez_table) if self.nuth_table is not None: self.nuth_table_ref = model.TableM(self.nuth_table) if self.nuxz_table is not None: self.nuxz_table_ref = model.TableM(self.nuxz_table) if self.rho_table is not None: self.rho_table_ref = model.TableM(self.rho_table) if self.gzx_table is not None: self.gzx_table_ref = model.TableM(self.gzx_table) if self.ax_table is not None: self.ax_table_ref = model.TableM(self.ax_table) if self.ath_table is not None: self.ath_table_ref = model.TableM(self.ath_table) if self.az_table is not None: self.az_table_ref = model.TableM(self.az_table) if self.ge_table is not None: self.ge_table_ref = model.TableM(self.ge_table)
[docs] def uncross_reference(self) -> None: """Removes cross-reference links""" self.mid = self.Mid() self.mid_ref = None self.ex_table = self.Ex_table() self.eth_table = self.Eth_table() self.ez_table = self.Ez_table() self.nuth_table = self.Nuth_table() self.nuxz_table = self.Nuxz_table() self.rho_table = self.Rho_table() self.gzx_table = self.Gzx_table() self.ax_table = self.Ax_table() self.ath_table = self.Ath_table() self.az_table = self.Az_table() self.ge_table = self.Ge_table() self.ex_table_ref = None self.eth_table_ref = None self.ez_table_ref = None self.nuth_table_ref = None self.nuxz_table_ref = None self.rho_table_ref = None self.gzx_table_ref = None self.ax_table_ref = None self.ath_table_ref = None self.az_table_ref = None self.ge_table_ref = None
[docs] @classmethod def add_card(cls, card, comment=''): """ Adds a MATT3 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') ex_table = integer_or_blank(card, 2, 'T(EX)') eth_table = integer_or_blank(card, 3, 'T(ETH)') ez_table = integer_or_blank(card, 5, 'T(EZ)') nuth_table = integer_or_blank(card, 6, 'T(NUTH)') nuxz_table = integer_or_blank(card, 7, 'T(NUXZ)') rho_table = integer_or_blank(card, 8, 'T(RHO)') gzx_table = integer_or_blank(card, 11, 'T(GZX)') ax_table = integer_or_blank(card, 12, 'T(AX)') ath_table = integer_or_blank(card, 13, 'T(ATH)') az_table = integer_or_blank(card, 14, 'T(AZ)') ge_table = integer_or_blank(card, 16, 'T(GE)') assert len(card) <= 16, f'len(MATT3 card) = {len(card):d}\ncard={card}' return MATT3(mid, ex_table, eth_table, ez_table, nuth_table, nuxz_table, rho_table, gzx_table, ax_table, ath_table, az_table, ge_table, comment=comment)
[docs] def Ex_table(self): if self.ex_table_ref is not None: return self.ex_table_ref.tid return self.ex_table
[docs] def Eth_table(self): if self.eth_table_ref is not None: return self.eth_table_ref.tid return self.eth_table
[docs] def Ez_table(self): if self.ez_table_ref is not None: return self.ez_table_ref.tid return self.eth_table
[docs] def Nuth_table(self): if self.nuth_table_ref is not None: return self.nuth_table_ref.tid return self.nuth_table
[docs] def Nuxz_table(self): if self.nuxz_table_ref is not None: return self.nuxz_table_ref.tid return self.nuxz_table
[docs] def Rho_table(self): if self.rho_table_ref is not None: return self.rho_table_ref.tid return self.rho_table
[docs] def Gzx_table(self): if self.gzx_table_ref is not None: return self.gzx_table_ref.tid return self.gzx_table
[docs] def Ax_table(self): if self.ax_table_ref is not None: return self.ax_table_ref.tid return self.ax_table
[docs] def Ath_table(self): if self.ath_table_ref is not None: return self.ath_table_ref.tid return self.ath_table
[docs] def Az_table(self): if self.az_table_ref is not None: return self.az_table_ref.tid return self.az_table
[docs] def Ge_table(self): if self.ge_table_ref is not None: return self.ge_table_ref.tid return self.ge_table
[docs] def raw_fields(self): list_fields = [ 'MATT3', self.Mid(), self.Ex_table(), self.Eth_table(), self.Ez_table(), self.Nuth_table(), self.Nuxz_table(), self.Rho_table(), None, None, self.Gzx_table(), self.Ax_table(), self.Ath_table(), self.Az_table(), None, self.Ge_table(), ] return list_fields
[docs] def repr_fields(self): return self.raw_fields()
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: card = self.repr_fields() if size == 8: return self.comment + print_card_8(card) return self.comment + print_card_16(card)
[docs] class MATT4(MaterialDependenceThermal): """ Specifies temperature-dependent material properties on MAT2 entry fields via TABLEMi entries. +-------+-------+-------+-------+--------+-------+-------+---------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | +=======+=======+=======+=======+========+=======+=======+=========+ | MATT4 | MID | T(K) | T(CP) | | T(H) | T(mu) | T(HGEN) | +-------+-------+-------+-------+--------+-------+-------+---------+ """ type = 'MATT4'
[docs] @classmethod def _init_from_empty(cls): mid = 1 return MATT4(mid, k_table=None, cp_table=None, h_table=None, mu_table=None, hgen_table=None, comment='')
def __init__(self, mid, k_table=None, cp_table=None, h_table=None, mu_table=None, hgen_table=None, comment=''): MaterialDependenceThermal.__init__(self) if comment: self.comment = comment if k_table == 0: k_table = None if cp_table == 0: cp_table = None if h_table == 0: h_table = None if mu_table == 0: mu_table = None if hgen_table == 0: hgen_table = None self.mid = mid self.k_table = k_table self.cp_table = cp_table self.h_table = h_table self.mu_table = mu_table self.hgen_table = hgen_table self.mid_ref = None self.k_table_ref = None self.cp_table_ref = None self.h_table_ref = None self.mu_table_ref = None self.hgen_table_ref = None
[docs] @classmethod def add_card(cls, card: BDFCard, comment: str=''): """ Adds a MATT4 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') k_table = integer_or_blank(card, 2, 'T(K)') cp_table = integer_or_blank(card, 3, 'T(CP)') h_table = integer_or_blank(card, 5, 'T(H)') mu_table = integer_or_blank(card, 6, 'T(mu)') hgen_table = integer_or_blank(card, 7, 'T(HGEN)') assert len(card) <= 8, 'len(MATT4 card) = {len(card):d}\ncard={card}' return MATT4(mid, k_table, cp_table, h_table, mu_table, hgen_table, comment=comment)
@classmethod def add_op2_data(cls, data, comment=''): """ Adds a MATT4 card from the OP2 Parameters ---------- data : list[varies] a list of fields defined in OP2 format comment : str; default='' a comment for the card """ (mid, k_table, cp_table, null, h_table, mu_table, hgen_table) = data assert null == 0, data return MATT4(mid, k_table, cp_table, h_table, mu_table, hgen_table, comment=comment)
[docs] def cross_reference(self, model: BDF) -> None: """ Cross links the card so referenced cards can be extracted directly Parameters ---------- model : BDF() the BDF object """ msg = ', which is required by MATT4 mid=%s' % self.mid self.mid_ref = model.Material(self.mid, msg=msg) self._xref_table(model, 'k_table', msg=msg) self._xref_table(model, 'cp_table', msg=msg) self._xref_table(model, 'h_table', msg=msg) self._xref_table(model, 'mu_table', msg=msg) self._xref_table(model, 'hgen_table', msg=msg)
[docs] def uncross_reference(self) -> None: """Removes cross-reference links""" self.mid = self.Mid() self.k_table = self.K_table() self.cp_table = self.Cp_table() self.h_table = self.H_table() self.mu_table = self.Mu_table() self.hgen_table = self.Hgen_table() self.mid_ref = None self.mid_ref = None self.k_table_ref = None self.cp_table_ref = None self.h_table_ref = None self.mu_table_ref = None self.hgen_table_ref = None
[docs] def K_table(self): return self._get_table('k_table')
[docs] def Cp_table(self): return self._get_table('cp_table')
[docs] def H_table(self): return self._get_table('h_table')
[docs] def Mu_table(self): return self._get_table('mu_table')
[docs] def Hgen_table(self): return self._get_table('hgen_table')
[docs] def raw_fields(self): list_fields = [ 'MATT4', self.Mid(), self.K_table(), self.Cp_table(), None, self.H_table(), self.Mu_table(), self.Hgen_table() ] return list_fields
[docs] def repr_fields(self): return self.raw_fields()
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: card = self.repr_fields() if size == 8: return self.comment + print_card_8(card) return self.comment + print_card_16(card)
[docs] class MATT5(MaterialDependenceThermal): """ Specifies temperature-dependent material properties on MAT2 entry fields via TABLEMi entries. +-------+---------+---------+--------+--------+--------+--------+--------+-------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +=======+=========+=========+========+========+========+========+========+=======+ | MATT5 | MID | T(Kxx) | T(Kxy) | T(Kxz) | T(Kyy) | T(Kyz) | T(Kzz) | T(CP) | +-------+---------+---------+--------+--------+--------+--------+--------+-------+ | | | T(HGEN) | | | | | | | +-------+---------+---------+--------+--------+--------+--------+--------+-------+ """ type = 'MATT5'
[docs] @classmethod def _init_from_empty(cls): mid = 1 return MATT5(mid, kxx_table=None, kxy_table=None, kxz_table=None, kyy_table=None, kyz_table=None, kzz_table=None, cp_table=None, hgen_table=None, comment='')
def __init__(self, mid, kxx_table=None, kxy_table=None, kxz_table=None, kyy_table=None, kyz_table=None, kzz_table=None, cp_table=None, hgen_table=None, comment=''): MaterialDependenceThermal.__init__(self) if comment: self.comment = comment self.mid = mid self.kxx_table = kxx_table self.kxy_table = kxy_table self.kxz_table = kxz_table self.kyy_table = kyy_table self.kyz_table = kyz_table self.kzz_table = kzz_table self.cp_table = cp_table self.hgen_table = hgen_table self.mid_ref = None self.kxx_table_ref = None self.kxy_table_ref = None self.kxz_table_ref = None self.kyy_table_ref = None self.kyz_table_ref = None self.kzz_table_ref = None self.cp_table_ref = None self.hgen_table_ref = None
[docs] @classmethod def add_card(cls, card, comment=''): """ Adds a MATT5 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') kxx_table = integer_or_blank(card, 2, 'T(Kxx)') kxy_table = integer_or_blank(card, 3, 'T(Kxy)') kxz_table = integer_or_blank(card, 5, 'T(Kxz)') kyy_table = integer_or_blank(card, 6, 'T(Kyy)') kyz_table = integer_or_blank(card, 7, 'T(Kyz)') kzz_table = integer_or_blank(card, 8, 'T(Kyz)') cp_table = integer_or_blank(card, 9, 'T(Kyz)') hgen_table = integer_or_blank(card, 11, 'T(HGEN)') assert len(card) <= 12, f'len(MATT5 card) = {len(card):d}\ncard={card}' return MATT5(mid, kxx_table, kxy_table, kxz_table, kyy_table, kyz_table, kzz_table, cp_table, hgen_table, comment=comment)
@classmethod def add_op2_data(cls, data, comment=''): """ Adds a MATT5 card from the OP2 Parameters ---------- data : list[varies] a list of fields defined in OP2 format comment : str; default='' a comment for the card """ (mid, kxx_table, kxy_table, kxz_table, kyy_table, kyz_table, kzz_table, cp_table, null, hgen_table) = data if kxx_table == 0: kxx_table = None if kxy_table == 0: kxy_table = None if kxz_table == 0: kxz_table = None if kyy_table == 0: kyy_table = None if kyz_table == 0: kyz_table = None if kzz_table == 0: kzz_table = None if cp_table == 0: cp_table = None if hgen_table == 0: hgen_table = None assert null == 0, data return MATT5(mid, kxx_table, kxy_table, kxz_table, kyy_table, kyz_table, kzz_table, cp_table, hgen_table, comment=comment)
[docs] def cross_reference(self, model: BDF) -> None: """ Cross links the card so referenced cards can be extracted directly Parameters ---------- model : BDF() the BDF object """ msg = ', which is required by MATT5 mid=%s' % self.mid self.mid_ref = model.Material(self.mid, msg=msg) self._xref_table(model, 'kxx_table', msg=msg) self._xref_table(model, 'kxy_table', msg=msg) self._xref_table(model, 'kxz_table', msg=msg) self._xref_table(model, 'kyy_table', msg=msg) self._xref_table(model, 'kyz_table', msg=msg) self._xref_table(model, 'kzz_table', msg=msg) self._xref_table(model, 'cp_table', msg=msg) self._xref_table(model, 'hgen_table', msg=msg)
[docs] def uncross_reference(self) -> None: """Removes cross-reference links""" self.mid = self.Mid() self.kxx_table = self.Kxx_table() self.kxy_table = self.Kxy_table() self.kxz_table = self.Kxz_table() self.kyy_table = self.Kyy_table() self.kyz_table = self.Kyz_table() self.kzz_table = self.Kzz_table() self.cp_table = self.Cp_table() self.hgen_table = self.Hgen_table() self.mid_ref = None self.kxx_table_ref = None self.kxy_table_ref = None self.kxz_table_ref = None self.kyy_table_ref = None self.kyz_table_ref = None self.kzz_table_ref = None self.cp_table_ref = None self.hgen_table_ref = None
[docs] def Kxx_table(self): return self._get_table('kxx_table')
[docs] def Kxy_table(self): return self._get_table('kxy_table')
[docs] def Kxz_table(self): return self._get_table('kxz_table')
[docs] def Kyy_table(self): return self._get_table('kyy_table')
[docs] def Kyz_table(self): return self._get_table('kyz_table')
[docs] def Kzz_table(self): return self._get_table('kzz_table')
[docs] def Cp_table(self): return self._get_table('cp_table')
[docs] def Hgen_table(self): return self._get_table('hgen_table')
[docs] def raw_fields(self): list_fields = ['MATT5', self.Mid(), self.Kxx_table(), self.Kxy_table(), self.Kxz_table(), self.Kyy_table(), self.Kyz_table(), self.Kzz_table(), self.Cp_table(), None, self.Hgen_table()] return list_fields
[docs] def repr_fields(self): return self.raw_fields()
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: card = self.repr_fields() if size == 8: return self.comment + print_card_8(card) return self.comment + print_card_16(card)
[docs] class MATT8(MaterialDependenceThermal): """ Specifies temperature-dependent material properties on MAT2 entry fields via TABLEMi entries. +-------+--------+--------+-------+---------+--------+--------+--------+--------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +=======+========+========+=======+=========+========+========+========+========+ | MATT8 | MID | T(E1) | T(E2) | T(Nu12) | T(G12) | T(G1z) | T(G2z) | T(RHO) | +-------+--------+--------+-------+---------+--------+--------+--------+--------+ | | T(A1) | T(A2) | | T(Xt) | T(Xc) | T(Yt) | T(Yc) | T(S) | +-------+--------+--------+-------+---------+--------+--------+--------+--------+ | | T(GE) | T(F12) | | | | | | | +-------+--------+--------+-------+---------+--------+--------+--------+--------+ """ type = 'MATT8'
[docs] @classmethod def _init_from_empty(cls): mid = 1 return MATT8(mid, e1_table=None, e2_table=None, nu12_table=None, g12_table=None, g1z_table=None, g2z_table=None, rho_table=None, a1_table=None, a2_table=None, xt_table=None, xc_table=None, yt_table=None, yc_table=None, s_table=None, ge_table=None, f12_table=None, comment='')
def __init__(self, mid, e1_table=None, e2_table=None, nu12_table=None, g12_table=None, g1z_table=None, g2z_table=None, rho_table=None, a1_table=None, a2_table=None, xt_table=None, xc_table=None, yt_table=None, yc_table=None, s_table=None, ge_table=None, f12_table=None, comment=''): MaterialDependenceThermal.__init__(self) if comment: self.comment = comment self.mid = mid self.e1_table = e1_table self.e2_table = e2_table self.nu12_table = nu12_table self.g12_table = g12_table self.g1z_table = g1z_table self.g2z_table = g2z_table self.rho_table = rho_table self.a1_table = a1_table self.a2_table = a2_table self.xt_table = xt_table self.xc_table = xc_table self.yt_table = yt_table self.yc_table = yc_table self.s_table = s_table self.ge_table = ge_table self.f12_table = f12_table self.mid_ref = None self.e1_table_ref = None self.e2_table_ref = None self.nu12_table_ref = None self.g12_table_ref = None self.g1z_table_ref = None self.g2z_table_ref = None self.rho_table_ref = None self.a1_table_ref = None self.a2_table_ref = None self.xt_table_ref = None self.xc_table_ref = None self.yt_table_ref = None self.yc_table_ref = None self.s_table_ref = None self.ge_table_ref = None self.f12_table_ref = None
[docs] @classmethod def add_card(cls, card, comment=''): """ Adds a MATT8 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') e1_table = integer_or_blank(card, 2, 'T(E1)') e2_table = integer_or_blank(card, 3, 'T(E2)') nu12_table = integer_or_blank(card, 4, 'T(Nu12)') g12_table = integer_or_blank(card, 5, 'T(G12)') g1z_table = integer_or_blank(card, 6, 'T(G1z)') g2z_table = integer_or_blank(card, 7, 'T(G2z)') rho_table = integer_or_blank(card, 8, 'T(Rho)') a1_table = integer_or_blank(card, 9, 'T(A1)') a2_table = integer_or_blank(card, 10, 'T(A2)') xt_table = integer_or_blank(card, 12, 'T(Xt)') xc_table = integer_or_blank(card, 13, 'T(Xc)') yt_table = integer_or_blank(card, 14, 'T(Yt)') yc_table = integer_or_blank(card, 15, 'T(Yc)') s_table = integer_or_blank(card, 16, 'T(S)') ge_table = integer_or_blank(card, 17, 'T(GE)') f12_table = integer_or_blank(card, 18, 'T(F12)') assert len(card) <= 19, f'len(MATT8 card) = {len(card):d}\ncard={card}' return MATT8(mid, e1_table, e2_table, nu12_table, g12_table, g1z_table, g2z_table, rho_table, a1_table, a2_table, xt_table, xc_table, yt_table, yc_table, s_table, ge_table, f12_table, comment=comment)
[docs] def cross_reference(self, model: BDF) -> None: """ Cross links the card so referenced cards can be extracted directly Parameters ---------- model : BDF() the BDF object """ msg = ', which is required by MATT8 mid=%s' % self.mid self.mid_ref = model.Material(self.mid, msg=msg) if self.e1_table is not None: self.e1_table_ref = model.TableM(self.e1_table) if self.e2_table is not None: self.e2_table_ref = model.TableM(self.e2_table) if self.nu12_table is not None: self.nu12_table_ref = model.TableM(self.nu12_table) if self.g12_table is not None: self.g12_table_ref = model.TableM(self.g12_table) if self.g1z_table is not None: self.g1z_table_ref = model.TableM(self.g1z_table) if self.g2z_table is not None: self.g2z_table_ref = model.TableM(self.g2z_table) if self.rho_table is not None: self.rho_table_ref = model.TableM(self.rho_table) if self.a1_table is not None: self.a1_table_ref = model.TableM(self.a1_table) if self.a2_table is not None: self.a2_table_ref = model.TableM(self.a2_table) if self.xt_table is not None: self.xt_table_ref = model.TableM(self.xt_table) if self.xc_table is not None: self.xc_table_ref = model.TableM(self.xc_table) if self.yt_table is not None: self.yt_table_ref = model.TableM(self.yt_table) if self.s_table is not None: self.s_table_ref = model.TableM(self.s_table)
[docs] def uncross_reference(self) -> None: """Removes cross-reference links""" self.e1_table = self.E1_table() self.e2_table = self.E2_table() self.nu12_table = self.Nu12_table() self.g12_table = self.G12_table() self.g1z_table = self.G1z_table() self.g2z_table = self.G2z_table() self.rho_table = self.Rho_table() self.a1_table = self.A1_table() self.a2_table = self.A2_table() self.xt_table = self.Xt_table() self.xc_table = self.Xc_table() self.yt_table = self.Yt_table() self.yc_table = self.Yc_table() self.s_table = self.S_table() self.ge_table = self.Ge_table() self.f12_table = self.F12_table() self.e1_table_ref = None self.e2_table_ref = None self.nu12_table_ref = None self.g12_table_ref = None self.g1z_table_ref = None self.g2z_table_ref = None self.rho_table_ref = None self.a1_table_ref = None self.a2_table_ref = None self.xt_table_ref = None self.xc_table_ref = None self.yt_table_ref = None self.yc_table_ref = None self.s_table_ref = None self.ge_table_ref = None self.f12_table_ref = None
[docs] def E1_table(self): if self.e1_table_ref is not None: return self.e1_table_ref.tid return self.e1_table
[docs] def E2_table(self): if self.e2_table_ref is not None: return self.e2_table_ref.tid return self.e2_table
[docs] def Nu12_table(self): if self.nu12_table_ref is not None: return self.nu12_table_ref.tid return self.nu12_table
[docs] def G12_table(self): if self.g12_table_ref is not None: return self.g12_table_ref.tid return self.g12_table
[docs] def G1z_table(self): if self.g1z_table_ref is not None: return self.g1z_table_ref.tid return self.g1z_table
[docs] def G2z_table(self): if self.g2z_table_ref is not None: return self.g2z_table_ref.tid return self.g2z_table
[docs] def Rho_table(self): if self.rho_table_ref is not None: return self.rho_table_ref.tid return self.rho_table
[docs] def A1_table(self): if self.a1_table_ref is not None: return self.a1_table_ref.tid return self.a1_table
[docs] def A2_table(self): if self.a2_table_ref is not None: return self.a2_table_ref.tid return self.a2_table
[docs] def S_table(self): if self.s_table_ref is not None: return self.s_table_ref.tid return self.s_table
[docs] def Ge_table(self): if self.ge_table_ref is not None: return self.ge_table_ref.tid return self.ge_table
[docs] def F12_table(self): if self.f12_table_ref is not None: return self.f12_table_ref.tid return self.f12_table
[docs] def Xt_table(self): if self.xt_table_ref is not None: return self.xt_table_ref.tid return self.xt_table
[docs] def Xc_table(self): if self.xc_table_ref is not None: return self.xc_table_ref.tid return self.xc_table
[docs] def Yt_table(self): if self.yt_table_ref is not None: return self.yt_table_ref.tid return self.yt_table
[docs] def Yc_table(self): if self.yc_table_ref is not None: return self.yc_table_ref.tid return self.yc_table
[docs] def raw_fields(self): list_fields = ['MATT8', self.mid, self.E1_table(), self.E2_table(), self.Nu12_table(), self.G12_table(), self.G1z_table(), self.G2z_table(), self.Rho_table(), self.A1_table(), self.A2_table(), None, self.Xt_table(), self.Xc_table(), self.Yt_table(), self.Yc_table(), self.S_table(), self.Ge_table(), self.F12_table()] return list_fields
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: """ +--------+--------+--------+--------+--------+--------+--------+--------+--------+ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +========+========+========+========+========+========+========+========+========+ | MATT9 | MID | T(G11) | T(G12) | T(G13) | T(G14) | T(G15) | T(G16) | T(G22) | +--------+--------+--------+--------+--------+--------+--------+--------+--------+ | | T(G23) | T(G24) | T(G25) | T(G26) | T(G33) | T(G34) | T(G35) | T(G36) | +--------+--------+--------+--------+--------+--------+--------+--------+--------+ | | T(G44) | T(G45) | T(G46) | T(G55) | T(G56) | T(G66) | T(RHO) | T(A1) | +--------+--------+--------+--------+--------+--------+--------+--------+--------+ | | T(A2) | T(A3) | T(A4) | T(A5) | T(A6) | | T(GE) | | +--------+--------+--------+--------+--------+--------+--------+--------+--------+ """ list_fields = self.raw_fields() return self.comment + print_card_8(list_fields)
[docs] class MATT9(MaterialDependenceThermal): type = 'MATT9'
[docs] @classmethod def _init_from_empty(cls): mid = 1 return MATT9(mid, g11_table=None, g12_table=None, g13_table=None, g14_table=None, g15_table=None, g16_table=None, g22_table=None, g23_table=None, g24_table=None, g25_table=None, g26_table=None, g33_table=None, g34_table=None, g35_table=None, g36_table=None, g44_table=None, g45_table=None, g46_table=None, g55_table=None, g56_table=None, g66_table=None, rho_table=None, a1_table=None, a2_table=None, a3_table=None, a4_table=None, a5_table=None, a6_table=None, ge_table=None, comment='')
def __init__(self, mid, g11_table=None, g12_table=None, g13_table=None, g14_table=None, g15_table=None, g16_table=None, g22_table=None, g23_table=None, g24_table=None, g25_table=None, g26_table=None, g33_table=None, g34_table=None, g35_table=None, g36_table=None, g44_table=None, g45_table=None, g46_table=None, g55_table=None, g56_table=None, g66_table=None, rho_table=None, a1_table=None, a2_table=None, a3_table=None, a4_table=None, a5_table=None, a6_table=None, ge_table=None, comment=''): MaterialDependenceThermal.__init__(self) if comment: self.comment = comment self.mid = mid self.g11_table = g11_table self.g12_table = g12_table self.g13_table = g13_table self.g14_table = g14_table self.g15_table = g15_table self.g16_table = g16_table self.g22_table = g22_table self.g23_table = g23_table self.g24_table = g24_table self.g25_table = g25_table self.g26_table = g26_table self.g33_table = g33_table self.g34_table = g34_table self.g35_table = g35_table self.g36_table = g36_table self.g44_table = g44_table self.g45_table = g45_table self.g46_table = g46_table self.g55_table = g55_table self.g56_table = g56_table self.g66_table = g66_table self.rho_table = rho_table self.a1_table = a1_table self.a2_table = a2_table self.a3_table = a3_table self.a4_table = a4_table self.a5_table = a5_table self.a6_table = a6_table self.ge_table = ge_table self.mid_ref = None
[docs] @classmethod def add_card(cls, card: BDFCard, comment: str=''): """ Adds a MATT9 card from ``BDF.add_card(...)`` Parameters ---------- card : BDFCard() a BDFCard object comment : str; default='' a comment for the card """ mid = integer(card, 1, 'mid') g11_table = integer_or_blank(card, 2, 'T(G11)') g12_table = integer_or_blank(card, 3, 'T(G12)') g13_table = integer_or_blank(card, 4, 'T(G13)') g14_table = integer_or_blank(card, 5, 'T(G14)') g15_table = integer_or_blank(card, 6, 'T(G15)') g16_table = integer_or_blank(card, 7, 'T(G16)') g22_table = integer_or_blank(card, 8, 'T(G22)') g23_table = integer_or_blank(card, 9, 'T(G23)') g24_table = integer_or_blank(card, 10, 'T(G24)') g25_table = integer_or_blank(card, 11, 'T(G25)') g26_table = integer_or_blank(card, 12, 'T(G26)') g33_table = integer_or_blank(card, 13, 'T(G33)') g34_table = integer_or_blank(card, 14, 'T(G34)') g35_table = integer_or_blank(card, 15, 'T(G35)') g36_table = integer_or_blank(card, 16, 'T(G36)') g44_table = integer_or_blank(card, 17, 'T(G44)') g45_table = integer_or_blank(card, 18, 'T(G45)') g46_table = integer_or_blank(card, 19, 'T(G46)') g55_table = integer_or_blank(card, 20, 'T(G55)') g56_table = integer_or_blank(card, 21, 'T(G56)') g66_table = integer_or_blank(card, 22, 'T(G66)') rho_table = integer_or_blank(card, 23, 'T(RHO)') a1_table = integer_or_blank(card, 24, 'T(A1)') a2_table = integer_or_blank(card, 25, 'T(A2)') a3_table = integer_or_blank(card, 26, 'T(A3)') a4_table = integer_or_blank(card, 27, 'T(A4)') a5_table = integer_or_blank(card, 28, 'T(A5)') a6_table = integer_or_blank(card, 29, 'T(A6)') ge_table = integer_or_blank(card, 31, 'T(GE)') assert len(card) <= 32, f'len(MATT9 card) = {len(card):d}\ncard={card}' return MATT9(mid, g11_table, g12_table, g13_table, g14_table, g15_table, g16_table, g22_table, g23_table, g24_table, g25_table, g26_table, g33_table, g34_table, g35_table, g36_table, g44_table, g45_table, g46_table, g55_table, g56_table, g66_table, rho_table, a1_table, a2_table, a3_table, a4_table, a5_table, a6_table, ge_table, comment=comment)
[docs] def cross_reference(self, model: BDF) -> None: """ Cross links the card so referenced cards can be extracted directly Parameters ---------- model : BDF() the BDF object """ msg = ', which is required by MATT9 mid=%s' % self.mid self.mid_ref = model.Material(self.mid, msg=msg)
#if self.e1_table is not None: #self.e1_table_ref = model.TableM(self.e1_table) #if self.e2_table is not None: #self.e2_table_ref = model.TableM(self.e2_table)
[docs] def uncross_reference(self) -> None: """Removes cross-reference links""" pass
#self.e1_table = self.E1_table() #self.e2_table = self.E2_table() #self.e1_table_ref = None #self.e2_table_ref = None #def E1_table(self): #if self.e1_table_ref is not None: #return self.e1_table_ref.tid #return self.e1_table
[docs] def raw_fields(self): list_fields = [ 'MATT9', self.mid, self.g11_table, self.g12_table, self.g13_table, self.g14_table, self.g15_table, self.g16_table, self.g22_table, self.g23_table, self.g24_table, self.g25_table, self.g26_table, self.g33_table, self.g34_table, self.g35_table, self.g36_table, self.g44_table, self.g45_table, self.g46_table, self.g55_table, self.g56_table, self.g66_table, self.rho_table, self.a1_table, self.a2_table, self.a3_table, self.a4_table, self.a5_table, self.a6_table, self.ge_table, ] return list_fields
[docs] def write_card(self, size: int=8, is_double: bool=False) -> str: list_fields = self.raw_fields() return self.comment + print_card_8(list_fields)