def __init__(self, card=None, data=None, comment=''):
"""
Defines the properties of a shear panel (CSHEAR entry).
+--------+-----+-----+---+-----+----+----+
| PSHEAR | PID | MID | T | NSM | F1 | F2 |
+--------+-----+-----+---+-----+----+----+
"""
ShellProperty.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: Material ID
self.mid = integer(card, 2, 'mid')
self.t = double(card, 3, 't')
self.nsm = double_or_blank(card, 4, 'nsm', 0.0)
self.f1 = double_or_blank(card, 5, 'f1', 0.0)
self.f2 = double_or_blank(card, 6, 'f2', 0.0)
assert self.t > 0.0
#assert self.f1 >= 0.0
#assert self.f2 >= 0.0
assert len(card) <= 7, 'len(PSHEAR card) = %i' % len(card)
else:
#(pid,mid,t,nsm,f1,f2) = out
self.pid = data[0]
self.mid = data[1]
self.t = data[2]
self.nsm = data[3]
self.f1 = data[4]
self.f2 = data[5]
def __init__(self, card=None, data=None, comment=''):
CrackProperty.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: Material ID
self.mid = integer(card, 2, 'mid')
self.thick = double(card, 3, 'thick')
#: Plane strain or plane stress option.
#: Use 0 for plane strain; 1 for plane stress. (Integer = 0 or 1)
self.iPlane = integer(card, 4, 'iPlane')
if self.iPlane not in [0, 1]:
raise RuntimeError('Invalid value for iPlane on PRAC2D, can '
'only be 0,1 iPlane=|%s|' % self.iPlane)
#: Non-structural mass per unit area.(Real >= 0.0; Default = 0)
self.nsm = double_or_blank(card, 5, 'nsm', 0.)
#: Exponent used in the displacement field. See Remark 4.
#: (Real; Default = 0.5)
self.gamma = double_or_blank(card, 6, 'gamma', 0.5)
#: Angle (in degrees) relative to the element x-axis along which
#: stress intensity factors are to be calculated. See Remark 4.
#: (Real; Default = 180.0)
self.phi = double_or_blank(card, 7, 'phi', 180.)
assert len(card) <= 8, 'len(PRAC2D card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
"""
::
RBAR EID GA GB CNA CNB CMA CMB ALPHA
RBAR 5 1 2 123456 6.5-6
"""
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.ga = integer(card, 2, 'ga')
self.gb = integer(card, 3, 'gb')
self.cna = components_or_blank(card, 4, 'cna')
self.cnb = components_or_blank(card, 5, 'cnb')
self.cma = components_or_blank(card, 6, 'cma')
self.cmb = components_or_blank(card, 7, 'cmb')
self.alpha = double_or_blank(card, 8, 'alpha', 0.0)
assert len(card) <= 9, 'len(RBAR card) = %i' % len(card)
else:
self.eid = data[0]
self.ga = data[1]
self.gb = data[2]
self.cna = data[3]
self.cnb = data[4]
self.cma = data[5]
self.cmb = data[6]
self.alpha = data[7]
def __init__(self, card=None, data=None, comment=''):
LineDamper.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.pid = integer(card, 2, 'pid')
nids = [integer_or_blank(card, 3, 'g1', 0),
integer_or_blank(card, 5, 'g2', 0)]
#: component number
self.c1 = integer_or_blank(card, 4, 'c1', 0)
self.c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CDAMP1 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = [data[2], data[4]]
self.c1 = data[3]
self.c2 = data[5]
self.prepare_node_ids(nids, allow_empty_nodes=True)
assert len(self.nodes) == 2
msg = 'on\n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' % str(self)
assert self.c1 in [0, 1, 2, 3, 4, 5, 6], 'c1=|%s| %s' % (self.c1, msg)
assert self.c2 in [0, 1, 2, 3, 4, 5, 6], 'c2=|%s| %s' % (self.c2, msg)
def __init__(self, card=None, data=None, comment=''):
SolidProperty.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: Material ID
self.mid = integer(card, 2, 'mid')
self.cordm = integer_or_blank(card, 3, 'cordm', 0)
self.integ = integer_string_or_blank(card, 4, 'integ')
#validIntegration = ['THREE', 'TWO', 'FULL', 'BUBBLE',
# 2, 3, None, 'REDUCED']
self.stress = integer_string_or_blank(card, 5, 'stress')
self.isop = integer_string_or_blank(card, 6, 'isop')
self.fctn = string_or_blank(card, 7, 'fctn', 'SMECH')
assert len(card) <= 8, 'len(PSOLID card) = %i' % len(card)
else:
self.pid = data[0]
self.mid = data[1]
self.cordm = data[2]
self.integ = data[3]
self.stress = data[4]
self.isop = data[5]
self.fctn = data[6]
if self.fctn == 'SMEC':
self.fctn = 'SMECH'
def __init__(self, card=None, data=None, comment=''):
LineElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.pid = integer_or_blank(card, 2, 'pid', self.eid)
self.ga = integer(card, 3, 'ga')
self.gb = integer(card, 4, 'gb')
x1Go = integer_double_or_blank(card, 5, 'x1_g0', 0.0)
if isinstance(x1Go, integer_types):
self.g0 = x1Go
self.x = None
elif isinstance(x1Go, float):
self.g0 = None
self.x = array([double_or_blank(card, 5, 'x1', 0.0),
double_or_blank(card, 6, 'x2', 0.0),
double_or_blank(card, 7, 'x3', 0.0)], dtype='float64')
if norm(self.x) == 0.0:
msg = 'G0 vector defining plane 1 is not defined.\n'
msg += 'G0 = %s\n' % self.g0
msg += 'X = %s\n' % self.x
raise RuntimeError(msg)
else:
raise ValueError('invalid x1Go=|%s| on CBEND' % x1Go)
self.geom = integer(card, 8, 'geom')
assert len(card) == 9, 'len(CBEND card) = %i' % len(card)
assert self.geom in [1, 2, 3, 4], 'geom is invalid geom=|%s|' % self.geom
else:
raise NotImplementedError(data)
if self.g0 in [self.ga, self.gb]:
msg = 'G0=%s cannot be GA=%s or GB=%s' % (self.g0, self.ga, self.gb)
raise RuntimeError(msg)
def __init__(self, card=None, data=None, comment=''):
"""
::
FORCE 3 1 100. 0. 0. 1.
"""
Force.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.node = integer(card, 2, 'node')
self.cid = integer_or_blank(card, 3, 'cid', 0)
self.mag = double(card, 4, 'mag')
xyz = array([double_or_blank(card, 5, 'X1', 0.0),
double_or_blank(card, 6, 'X2', 0.0),
double_or_blank(card, 7, 'X3', 0.0)])
assert len(card) <= 8, 'len(FORCE card) = %i' % len(card)
else:
self.sid = data[0]
self.node = data[1]
self.cid = data[2]
self.mag = data[3]
xyz = data[4:7]
assert len(xyz) == 3, 'xyz=%s' % (xyz)
self.xyz = array(xyz)
def __init__(self, card=None, data=None, comment=''):
"""
if coming from a BDF object, card is used
if coming from the OP2, data is used
"""
if comment:
self._comment = comment
Node.__init__(self, card, data)
if card:
self.nid = integer(card, 1, 'nid')
self.phi = double(card, 4, 'phi')
self.cd = integer(card, 6, 'cd')
self.ps = integer(card, 7, 'ps')
self.idf = integer(card, 8, 'idf')
else:
self.nid = data[0]
self.phi = data[1]
self.cd = data[2]
self.ps = data[3]
self.idf = data[4]
assert self.nid > 0, 'nid=%s' % self.nid
assert self.phi >= 0, 'phi=%s' % self.phi
assert self.cd >= 0, 'cd=%s' % self.cd
assert self.ps >= 0, 'ps=%s' % self.ps
assert self.idf >= 0, 'idf=%s' % self.idf
def loadHESS_INV(self, nRows, card):
alphaOmega_default = None
LJ_default = None
if self.method == 'INV':
alphaOmega_default = 0.0
LJ_default = 1.0
for iRow in xrange(nRows):
NEj = integer(card, 9 + 7 * iRow + 5, 'NE%s' + str(iRow))
NDJ_default = None
if self.method == 'INV':
NDJ_default = 3 * NEj
i = 9 + 8 * iRow
self.alphaAjs.append(
double_or_blank(card, i, 'alphaA' + str(iRow), alphaOmega_default))
self.omegaAjs.append(
double_or_blank(card, i + 1, 'omegaA' + str(iRow), alphaOmega_default))
self.alphaBjs.append(
double_or_blank(card, i + 2, 'alphaB' + str(iRow), alphaOmega_default))
self.omegaBjs.append(
double_or_blank(card, i + 3, 'omegaB' + str(iRow), alphaOmega_default))
self.LJs.append(
double_or_blank(i + 4, LJ_default))
self.NEJs.append(
integer(card, i + 5, 'NEJ' + str(iRow)))
self.NDJs.append(
integer_or_blank(card, i + 6, 'NDJ' + str(iRow), NDJ_default))
def __init__(self, card, data):
Load.__init__(self, card, data)
if card:
#: load ID
self.sid = integer(card, 1, 'sid')
#: overall scale factor
self.scale = double(card, 2, 'scale')
#: individual scale factors (corresponds to loadIDs)
self.scaleFactors = []
#: individual loadIDs (corresponds to scaleFactors)
self.loadIDs = []
# alternating of scale factor & load set ID
nLoads = len(card) - 3
assert nLoads % 2 == 0
for i in xrange(nLoads // 2):
n = 2 * i + 3
self.scaleFactors.append(double(card, n, 'scaleFactor'))
self.loadIDs.append(integer(card, n + 1, 'loadID'))
else:
self.sid = data[0]
self.scale = data[1]
self.scaleFactors = data[2]
self.loadIDs = data[3]
assert len(data) == 4, '%s data=%s' % (self.type, data)
def __init__(self, card=None, data=None, comment=''):
Property.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: Material ID
self.mid1 = integer_or_blank(card, 2, 'mid1', 0)
self.t1 = double_or_blank(card, 3, 't1')
self.mid2 = integer_or_blank(card, 4, 'mid2', 0)
if self.mid2 > 0:
self.i = double(card, 5, 'i')
assert self.i > 0.0
else:
self.i = blank(card, 5, 'i')
self.mid3 = integer(card, 6, 0)
if self.mid3 > 0:
self.t2 = double(card, 7, 't3')
assert self.t2 > 0.0
else:
self.t2 = blank(card, 7, 't3')
self.nsm = double(card, 8, 'nsm')
self.z1 = double(card, 9, 'z1')
self.z2 = double(card, 10, 'z2')
self.phi = fields(double, card, 'phi', i=11, j=len(card))
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
Method.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Set identification number. (Unique Integer > 0)
self.sid = integer(card, 1, 'sid')
#: Coordinates of point in complex plane. (Real)
self.alpha1 = double(card, 2, 'alpha1')
#: Coordinates of point in complex plane. (Real)
self.omega1 = double(card, 3, 'omega1')
#: Multiplicity of complex root at pole defined by point at ALPHAi
#: and OMEGAi
self.m1 = integer(card, 4, 'm1')
#: Coordinates of point in complex plane. (Real)
self.alpha2 = double(card, 5, 'alpha2')
#: Coordinates of point in complex plane. (Real)
self.omega2 = double(card, 6, 'omega2')
#: Multiplicity of complex root at pole defined by point at ALPHAi
#: and OMEGAi
self.m2 = integer(card, 7, 'm2')
assert len(card) == 8, 'len(EIGP card) = %i' % len(card)
else:
raise NotImplementedError('EIGP')
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.eid = integer(card, 2, 'eid')
self.Type = string(card, 3, 'Type')
self.scale = string(card, 4, 'scale')
self.x1 = double(card, 5, 'x1')
self.p1 = double(card, 6, 'p1')
self.x2 = double_or_blank(card, 7, 'x2', self.x1)
self.p2 = double_or_blank(card, 8, 'p2', self.p1)
assert 0 <= self.x1 <= self.x2
assert len(card) <= 9, 'len(PLOAD1 card) = %i' % len(card)
else:
self.sid = data[0]
self.eid = data[1]
self.Type = data[2]
self.scale = data[3]
self.x1 = data[4]
self.p1 = data[5]
self.x2 = data[6]
self.p2 = data[7]
if self.Type not in self.validTypes:
msg = '%s is an invalid type on the PLOAD1 card' % self.Type
raise RuntimeError(msg)
assert self.scale in self.validScales, '%s is an invalid scale on the PLOAD1 card' % (self.scale)
def __init__(self, card=None, data=None, comment=''):
Constraint.__init__(self, card, data)
self.IDs = []
self.Cs = []
if comment:
self._comment = comment
if card:
self.conid = integer(card, 1, 'conid') # really a support id sid
nfields = len(card)
assert len(card) > 2
nterms = int((nfields - 1.) / 2.)
n = 1
for i in range(nterms):
nstart = 2 + 2 * i
ID = integer(card, nstart, 'ID%s' % n)
C = components_or_blank(card, nstart + 1, 'component%s' % n, '0')
self.IDs.append(ID)
self.Cs.append(C)
n += 1
else:
msg = '%s has not implemented data parsing' % self.type
raise NotImplementedError(msg)
assert len(self.IDs) > 0
assert len(self.IDs) == len(self.Cs)
def __init__(self, card=None, data=None, comment=''):
Constraint.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.conid = integer(card, 1, 'sid')
if card.field(5) in [None, '']:
self.gids = [integer(card, 2, 'G1'),]
self.constraints = [components_or_blank(card, 3, 'C1', 0)]
self.enforced = [double_or_blank(card, 4, 'D1', 0.0)]
else:
self.gids = [
integer(card, 2, 'G1'),
integer_or_blank(card, 5, 'G2'),
]
# :0 if scalar point 1-6 if grid
self.constraints = [components_or_blank(card, 3, 'C1', 0),
components_or_blank(card, 6, 'C2', 0)]
self.enforced = [double_or_blank(card, 4, 'D1', 0.0),
double_or_blank(card, 7, 'D2', 0.0)]
else:
self.conid = data[0]
self.gids = [data[1]]
self.constraints = [data[2]]
self.enforced = [data[3]]
def add(self, card, comment=''):
i = self.i
self.property_id[i] = integer(card, 1, 'pid')
self.material_id[i] = integer(card, 2, 'mid')
self.cordm[i] = integer_or_blank(card, 3, 'cordm', 0)
self.integ[i] = integer_string_or_blank(card, 4, 'integ', '')
#validIntegration = ['THREE', 'TWO', 'FULL', 'BUBBLE',
# 2, 3, None, 'REDUCED']
# ISOP
# ------
# 1. FULL
# 2.
# 3.
# REDUCED
# IN
# ------
# 1.
# 2. TWO
# 3. THREE
# BUBBLE - 2 for CTETRA, 3 for CHEXA/CPENTA
# STRESS
# ------
# 1. GAUSS (no midside nodes on CPENTA/CHEXA; ok on CTETRA)
# 2.
self.stress[i] = integer_string_or_blank(card, 5, 'stress', '')
self.isop[i] = integer_string_or_blank(card, 6, 'isop', '')
self.fctn[i] = string_or_blank(card, 7, 'fctn', 'SMECH')
assert len(card) <= 8, 'len(PSOLID card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
SpringElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
#: property ID
self.pid = integer_or_blank(card, 2, 'pid', self.eid)
nids = [integer(card, 3, 'g1'), integer_or_blank(card, 5, 'g2', 0)]
#: component number
self.c1 = integer_or_blank(card, 4, 'c1', 0)
self.c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CELAS1 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = [data[2], data[3]]
self.c1 = data[4]
self.c2 = data[5]
msg = 'on\n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' % str(self)
assert self.c1 in [0, 1, 2, 3, 4, 5, 6], 'c1=|%s| %s' % (self.c1, msg)
assert self.c2 in [0, 1, 2, 3, 4, 5, 6], 'c2=|%s| %s' % (self.c2, msg)
self.prepareNodeIDs(nids, allowEmptyNodes=True)
assert len(self.nodes) == 2
def __init__(self, card, nCoord, data):
Coord.__init__(self, card, data)
self.isResolved = False
if nCoord is not None:
assert nCoord == 0 or nCoord == 1, 'nCoord=|%s|' % (nCoord)
nCoord *= 4 # 0 if the 1st coord, 4 if the 2nd
#: the coordinate ID
self.cid = integer(card, 1 + nCoord, 'cid')
#: a Node at the origin
self.g1 = integer(card, 2 + nCoord, 'g1')
#: a Node on the z-axis
self.g2 = integer(card, 3 + nCoord, 'g2')
#: a Node on the xz-plane
self.g3 = integer(card, 4 + nCoord, 'g3')
else:
self.cid = data[0]
self.g1 = data[1]
self.g2 = data[2]
self.g3 = data[3]
assert len(data) == 4, 'data = %s' % (data)
assert self.g1 != self.g2
assert self.g1 != self.g3
assert self.g2 != self.g3
self.e1 = None
self.e2 = None
self.e3 = None
self.i = None
self.j = None
self.k = None
def add(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.property_id[i] = integer(card, 2, 'property_id')
self.coord_id[i] = integer_or_blank(card, 3, 'cp', 0)
self.nspan[i] = integer_or_blank(card, 4, 'nspan', 0)
self.nchord[i] = integer_or_blank(card, 5, 'nchord', 0)
#if self.nspan==0:
self.lspan[i] = integer_or_blank(card, 6, 'lspan', 0)
#if self.nchord==0:
self.lchord[i] = integer_or_blank(card, 7, 'lchord', 0)
self.igid[i] = integer(card, 8, 'igid')
self.p1[i, :] = [double_or_blank(card, 9, 'x1', 0.0),
double_or_blank(card, 10, 'y1', 0.0),
double_or_blank(card, 11, 'z1', 0.0)]
self.x12[i] = double_or_blank(card, 12, 'x12', 0.)
self.p4[i, :] = [double_or_blank(card, 13, 'x4', 0.0),
double_or_blank(card, 14, 'y4', 0.0),
double_or_blank(card, 15, 'z4', 0.0)]
self.x43[i] = double_or_blank(card, 16, 'x43', 0.)
assert len(card) <= 17, 'len(CAERO1 card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
"""
Intilizes the CORD3G
:param self: the CORD3G coordinate system object
:param card: a list version of the fields
"""
if comment:
self._comment = comment
Coord.__init__(self, card, data)
self.cid = integer(card, 1, 'cid')
method = string_or_blank(card, 2, 'E313')
self.methodES = method[0]
self.methodInt = int(method[1:])
assert self.methodES in ['E', 'S'] # Euler / Space-Fixed
assert 0 < self.methodInt < 1000
self.form = string_or_blank(card, 3, 'form', 'EQN')
self.thetas = [integer(card, 4, 'theta1'),
integer(card, 5, 'theta2'),
integer(card, 6, 'theta3')]
assert len(self.thetas) == 3, 'thetas=%s' % (self.thetas)
self.rid = integer_or_blank(card, 7, 'cidRef')
assert len(card) <= 8, 'len(CORD3G card) = %i' % len(card)
# EQN for DEQATN, TABLE for TABLE3D
assert self.form in ['EQN', 'TABLE']
def __init__(self, card=None, data=None, comment=''):
TabularLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.exciteID = integer(card, 2, 'exciteID')
self.delay = integer_double_or_blank(card, 3, 'delay', 0)
self.dphase = integer_double_or_blank(card, 4, 'dphase')
self.tc = integer_double_or_blank(card, 5, 'tc', 0)
self.td = integer_double_or_blank(card, 6, 'td', 0)
self.Type = integer_string_or_blank(card, 7, 'Type', 'LOAD')
assert self.tc > 0 or self.td > 0, 'either RLOAD TC or TD > 0; tc=%s td=%s' % (tc, td)
if self.Type in [0, 'L', 'LO', 'LOA', 'LOAD']:
self.Type = 'LOAD'
elif self.Type in [1, 'D', 'DI', 'DIS', 'DISP']:
self.Type = 'DISP'
elif self.Type in [2, 'V', 'VE', 'VEL', 'VELO']:
self.Type = 'VELO'
elif self.Type in [3, 'A', 'AC', 'ACC', 'ACCE']:
self.Type = 'ACCE'
else:
msg = 'invalid RLOAD1 type Type=%r' % self.Type
raise RuntimeError(msg)
assert len(card) <= 8, 'len(RLOAD1 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
ThermalLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Load set identification number. (Integer > 0)
self.sid = integer(card, 1, 'sid')
#: Identification number of an CHBDYj element. (Integer > 0)
self.eid = integer(card, 2, 'eid')
qFlux = []
j = 1
for i in range(3, len(card)):
q = double_or_blank(card, i, 'qFlux%i' % j)
qFlux.append(q)
j += 1
assert len(qFlux) > 0
#: Heat flux at the i-th grid point on the referenced CHBDYj
#: element. (Real or blank)
self.qFlux = wipe_empty_fields(qFlux)
else:
self.sid = data[0]
self.eid = data[1]
self.qFlux = data[2]
def __init__(self, card=None, data=None, comment=''):
TabularLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.exciteID = integer(card, 2, 'exciteID')
self.delay = integer_double_or_blank(card, 3, 'delay', 0)
self.dphase = integer_double_or_blank(card, 4, 'dphase')
self.tb = integer_or_blank(card, 5, 'tb', 0)
self.tp = integer_or_blank(card, 6, 'tp', 0)
self.Type = integer_string_or_blank(card, 7, 'Type', 'LOAD')
if self.Type in [0, 'L', 'LO', 'LOA', 'LOAD']:
self.Type = 'LOAD'
elif self.Type in [1, 'D', 'DI', 'DIS', 'DISP']:
self.Type = 'DISP'
elif self.Type in [2, 'V', 'VE', 'VEL', 'VELO']:
self.Type = 'VELO'
elif self.Type in [3, 'A', 'AC', 'ACC', 'ACCE']:
self.Type = 'ACCE'
else:
msg = 'invalid RLOAD2 type Type=|%s|' % self.Type
raise RuntimeError(msg)
assert len(card) <= 8, 'len(RLOAD2 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def add(self, card, comment=''):
assert self.n > 0, self.n
i = self.i
load_id = integer(card, 1, 'load_id')
tbar = double(card, 3, 'Tbar')
tprime = double(card, 4, 'Tprime')
t1 = double_or_blank(card, 5, 'T1')
t2 = double_or_blank(card, 6, 'T2')
self.load_id[i] = load_id
self.element_id[i] = integer(card, 2, 'element_id')
self.tbar[i] = tbar
self.tprime[i] = tprime
self.temp[i, 0] = t1
self.temp[i, 1] = t2
self.i += 1
if len(card) >= 7:
# i must be < self.n
eids = expand_thru(card[9:])
for eid in eids:
self.load_id[i] = load_id
assert isinstance(eid, int), eid
self.element_id[i] = eid
self.tbar[i] = tbar
self.tprime[i] = tprime
self.temp[i, 0] = t1
self.temp[i, 1] = t2
self.i += 1
assert self.i <= self.n
assert len(card) <= 7, '%s; n=%s' % (card, len(card))
#assert len(card) <= 7, len(card)
self.eids = None
def __init__(self, card=None, data=None, comment=''):
"""
Defines a static concentrated moment at a grid point by specifying a
magnitude and two grid points that determine the direction.::
MOMENT1 SID G M G1 G2
"""
Moment.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.node = integer(card, 2, 'node')
self.mag = double(card, 3, 'mag')
self.g1 = integer(card, 4, 'g1')
self.g2 = integer(card, 5, 'g2')
assert len(card) == 6, 'len(MOMENT1 card) = %i' % len(card)
else:
self.sid = data[0]
self.node = data[1]
self.mag = data[2]
self.g1 = data[3]
self.g2 = data[4]
self.g3 = data[5]
self.g4 = data[6]
xyz = data[7:10]
raise NotImplementedError('MOMENT1 is probably wrong')
#assert len(xyz) == 3, 'xyz=%s' % (xyz)
#self.xyz = array(xyz)
self.xyz = None
def add(self, card, comment=''):
i = self.i
#comment = self._comments[i]
eid = integer(card, 1, 'element_id')
#if comment:
#self._comments[eid] = comment
#: Element ID
self.element_id[i] = eid
#: Property ID
self.property_id[i] = integer(card, 2, 'property_id')
#: Node IDs
nids = array([
integer(card, 3, 'node_id_1'), integer(card, 4, 'node_id_2'),
integer(card, 5, 'node_id_3'), integer(card, 6, 'node_id_4'),
integer(card, 7, 'node_id_5'), integer(card, 8, 'node_id_6'),
integer(card, 9, 'node_id_7'), integer(card, 10, 'node_id_8'),
integer_or_blank(card, 11, 'node_id_9', 0),
integer_or_blank(card, 12, 'node_id_10', 0),
integer_or_blank(card, 13, 'node_id_11', 0),
integer_or_blank(card, 14, 'node_id_12', 0),
integer_or_blank(card, 15, 'node_id_13', 0),
integer_or_blank(card, 16, 'node_id_14', 0),
integer_or_blank(card, 17, 'node_id_15', 0),
integer_or_blank(card, 18, 'node_id_16', 0),
integer_or_blank(card, 19, 'node_id_17', 0),
integer_or_blank(card, 20, 'node_id_18', 0),
integer_or_blank(card, 21, 'node_id_19', 0),
integer_or_blank(card, 22, 'node_id_20', 0)
], dtype='int32')
self.node_ids[i, :] = nids
assert len(card) <= 23, 'len(CHEXA20 card) = %i' % len(card)
self.i += 1
def getShockA(self, card, iStart):
self.shockType = string_or_blank(card, iStart + 1, 'shockType')
self.shockCVT = double(card, iStart + 2, 'shockCVT')
self.shockCVC = double_or_blank(card, iStart + 3, 'shockCVC')
self.shockExpVT = double_or_blank(card, iStart + 4, 'shockExpVT', 1.0)
self.shockExpVC = double_or_blank(card, iStart + 5,
'shockExpVC', self.shockExpVT)
if self.shockType == 'TABLE':
pass
# self.shockIDTS = integer(card, iStart + 6, 'shockIDTS')
# self.shockIDETS = blank(card, iStart + 9, 'shockIDETS')
# self.shockIDECS = blank(card, iStart + 10, 'shockIDECS')
# self.shockIDETSD = blank(card, iStart + 11, 'shockIDETSD')
# self.shockIDECSD = blank(card, iStart + 12, 'shockIDECSD')
elif self.shockType == 'EQUAT':
self.shockIDTS = blank(card, iStart + 6, 'shockIDTS')
self.shockIDETS = integer(card, iStart + 9, 'shockIDETS')
self.shockIDECS = integer_or_blank(card, iStart + 10,
'shockIDECS', self.shockIDETS)
self.shockIDETSD = integer(card, iStart + 11, 'shockIDETSD')
self.shockIDECSD = integer_or_blank(card, iStart + 11,
'shockIDECSD', self.shockIDETSD)
else:
raise RuntimeError('Invalid shockType=|%s| on card\n%s' %(self.shockType, card))
iStart += 8
return iStart
def __init__(self, card=None, data=None, comment=''):
SolidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element ID
self.eid = integer(card, 1, 'eid')
#: Property ID
self.pid = integer(card, 2, 'pid')
nids = [
integer(card, 3, 'nid1'),
integer(card, 4, 'nid2'),
integer(card, 5, 'nid3'),
integer(card, 6, 'nid4'),
integer(card, 7, 'nid5'),
integer(card, 8, 'nid6'),
integer(card, 9, 'nid7'),
integer(card, 10, 'nid8')
]
assert len(card) == 11, 'len(CHEXA8 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = data[2:]
assert len(data) == 10, 'len(data)=%s data=%s' % (len(data), data)
self.prepare_node_ids(nids)
assert len(self.nodes) == 8
def __init__(self, card=None, data=None, comment=''):
LineElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.pid = integer_or_blank(card, 2, 'pid', self.eid)
self.ga = integer(card, 3, 'ga')
self.gb = integer(card, 4, 'gb')
self.gc = integer(card, 5, 'gc')
self.initX_G0(card)
self.wa = array([double_or_blank(card, 9, 'w1a', 0.0),
double_or_blank(card, 10, 'w2a', 0.0),
double_or_blank(card, 11, 'w3a', 0.0)], dtype='float64')
self.wb = array([double_or_blank(card, 12, 'w1b', 0.0),
double_or_blank(card, 13, 'w2b', 0.0),
double_or_blank(card, 14, 'w3b', 0.0)], dtype='float64')
self.wc = array([double_or_blank(card, 15, 'w1c', 0.0),
double_or_blank(card, 16, 'w2c', 0.0),
double_or_blank(card, 17, 'w3c', 0.0)], dtype='float64')
self.tw = array([double_or_blank(card, 18, 0., 'twa'),
double_or_blank(card, 19, 0., 'twb'),
double_or_blank(card, 20, 0., 'twc')], dtype='float64')
self.s = array([integer_or_blank(card, 21, 'sa'),
integer_or_blank(card, 22, 'sb'),
integer_or_blank(card, 23, 'sc')], dtype='float64')
assert len(card) <= 24, 'len(CBEAM3 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
"""
Defines a static concentrated moment at a grid point by specifying a
scale factor and a vector that determines the direction.::
MOMENT SID G CID M N1 N2 N3
MOMENT 2 5 6 2.9 0.0 1.0 0.0
"""
Moment.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.node = integer(card, 2, 'node')
self.cid = integer_or_blank(card, 3, 'cid', 0)
self.mag = double(card, 4, 'mag')
xyz = array([double_or_blank(card, 5, 'X1', 0.0),
double_or_blank(card, 6, 'X2', 0.0),
double_or_blank(card, 7, 'X3', 0.0)])
assert len(card) <= 8, 'len(MOMENT card) = %i' % len(card)
else:
raise NotImplementedError(data)
assert len(xyz) == 3, 'xyz=%s' % xyz
self.xyz = xyz
def __init__(self, card=None, data=None, comment=''):
"""
::
DVPREL1 200000 PCOMP 2000 T2
200000 1.0
"""
if comment:
self._comment = comment
self.oid = integer(card, 1, 'oid')
self.Type = string(card, 2, 'Type')
self.pid = integer(card, 3, 'pid')
self.pNameFid = integer_or_string(card, 4, 'pName_FID')
#: Minimum value allowed for this property.
#: .. todo:: bad default (see DVMREL1)
self.pMin = double_or_blank(card, 5, 'pMin')
self.pMax = double_or_blank(card, 6, 'pMax', 1e20)
self.c0 = double_or_blank(card, 7, 'c0', 0.0)
self.dvids = []
self.coeffs = []
endFields = [interpret_value(field) for field in card[9:]]
nFields = len(endFields) - 1
if nFields % 2 == 1:
endFields.append(None)
nFields += 1
i = 0
for i in xrange(0, nFields, 2):
self.dvids.append(endFields[i])
self.coeffs.append(endFields[i + 1])
if nFields % 2 == 1:
print(card)
print("dvids = %s" % (self.dvids))
print("coeffs = %s" % (self.coeffs))
print(str(self))
raise RuntimeError('invalid DVPREL1...')
def build(self):
"""
:param self: the FORCE object
:param cards: the list of FORCE cards
"""
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float
#: Property ID
self.load_id = zeros(ncards, 'int32')
self.node_id = zeros(ncards, 'int32')
self.coord_id = zeros(ncards, 'int32')
self.mag = zeros(ncards, float_fmt)
self.xyz = zeros((ncards, 3), float_fmt)
for i, card in enumerate(cards):
self.load_id[i] = integer(card, 1, 'sid')
self.node_id[i] = integer(card, 2, 'node')
self.coord_id[i] = integer_or_blank(card, 3, 'cid', 0)
self.mag[i] = double(card, 4, 'mag')
xyz = [
double_or_blank(card, 5, 'X1', 0.0),
double_or_blank(card, 6, 'X2', 0.0),
double_or_blank(card, 7, 'X3', 0.0)
]
self.xyz[i] = xyz
assert len(card) <= 8, 'len(FORCE card) = %i' % len(card)
i = self.load_id.argsort()
self.load_id = self.load_id[i]
self.node_id = self.node_id[i]
self.coord_id = self.coord_id[i]
self.mag = self.mag[i]
self.xyz = self.xyz[i]
self._cards = []
self._comments = []
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
self.sid = integer(card, 1, 'sid')
f1 = double(card, 2, 'f1') # default=0.0 ?
f2 = double(card, 3, 'f2')
nf = integer_or_blank(card, 4, 'nf', 1)
assert len(card) <= 5, 'len(FREQ2 card) = %i' % len(card)
d = 1. / nf * log(f2 / f1)
self.freqs = []
for i in range(nf):
self.freqs.append(f1 * exp(i * d)) # 0 based index
self.cleanFreqs()
def __init__(self, card=None, data=None, comment=''):
ThermalLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Load set identification number. (Integer > 0)
self.sid = integer(card, 1, 'sid')
nfields = len(card) - 2
assert nfields % 2 == 0
#: dictionary of temperatures where the key is the grid ID (Gi)
#: and the value is the temperature (Ti)
self.temperatures = {}
for i in range(nfields // 2):
n = i * 2 + 2
gi = integer(card, n, 'g' + str(i))
Ti = double(card, n + 1, 'T' + str(i))
self.temperatures[gi] = Ti
else:
#print "TEMP data = ",data
self.sid = data[0]
self.temperatures = {data[1]: data[2]}
def __init__(self, card=None, data=None, comment=''):
BushElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.pid = integer_or_blank(card, 2, 'pid')
self.ga = integer(card, 3, 'ga')
self.gb = integer(card, 4, 'gb')
self.cid = integer_or_blank(card, 5, 'cid', 0)
self.plane = string_or_blank(card, 6, 'plane', 'XY')
if self.plane not in ['XY', 'YZ', 'ZX']:
msg = ("plane not in required list, plane=|%s|\n"
"expected planes = ['XY','YZ','ZX']" % self.plane)
raise RuntimeError(msg)
self.sptid = integer_or_blank(card, 7, 'sptid')
assert len(card) <= 8, 'len(CBUSH2D card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
self.ga = data[2]
self.gb = data[3]
def __init__(self, card=None, data=None, comment=''):
"""
::
RBAR1 EID GA GB CB ALPHA
RBAR1 5 1 2 123 6.5-6
"""
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.ga = integer(card, 2, 'ga')
self.gb = integer(card, 3, 'gb')
self.cb = components_or_blank(card, 4, 'cb')
self.alpha = double_or_blank(card, 5, 'alpha', 0.0)
assert len(card) <= 6, 'len(RBAR1 card) = %i' % len(card)
else:
self.eid = data[0]
self.ga = data[1]
self.gb = data[2]
self.cb = data[3]
self.alpha = data[4]
def __init__(self, card=None, data=None, comment=''):
Constraint.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.conid = integer(card, 1, 'conid')
self.constraints = components(card, 2, 'constraints') # 246 = y; dx, dz dir
nodes = card.fields(3)
self.nodes = expand_thru(nodes)
self.nodes.sort()
else:
self.conid = data[0]
self.constraints = data[1]
self.nodes = data[2:]
def __init__(self, card=None, data=None, comment=''):
"""
Defines values for the initial conditions of variables used in
structural transient analysis. Both displacement and velocity values
may be specified at independent degrees-of-freedom. This entry may not
be used for heat transfer analysis.
"""
Table.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.G = integer(card, 2, 'G')
assert self.G > 0
self.C = components(card, 3, 'C')
self.U0 = double(card, 4, 'U0')
self.V0 = double(card, 5, 'V0')
else:
self.sid = data[0]
self.G = data[1]
self.C = data[2]
self.U0 = data[3]
self.V0 = data[4]
def __init__(self, card=None, data=None, comment=''):
DamperProperty.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: Identification number of a TABLEDi entry that defines the
#: damping force per-unit velocity versus frequency relationship
self.tbid = integer_or_blank(card, 2, 'tbid', 0)
assert len(card) <= 3, 'len(PDAMPT card) = %i' % len(card)
else:
self.pid = data[0]
self.tbid = data[1]
def add_grid(self, card=None, data=None, comment=''):
"""
if coming from a BDF object, card is used
if coming from the OP2, data is used
"""
if comment:
self._comments[self._nnodes] = comment
if card:
nid = integer(card, 1, 'nid')
cp = integer_or_blank(card, 2, 'cp', 0)
x = double_or_blank(card, 3, 'x1', 0.)
y = double_or_blank(card, 4, 'x2', 0.)
z = double_or_blank(card, 5, 'x3', 0.)
xyz = [x, y, z]
cd = integer_or_blank(card, 6, 'cd', 0)
ps = components_or_blank(card, 7, 'ps', '')
seid = integer_or_blank(card, 8, 'seid', 0)
assert len(card) <= 9, 'len(GRID card) = %i' % len(card)
else:
nid = data[0]
cp = data[1]
xyz = data[2:5]
cd = data[5]
ps = data[6]
seid = data[7]
if ps == 0:
ps = ''
assert len(xyz) == 3, '%s len=%s' % (xyz, len(xyz))
assert nid > 0, 'nid=%s' % nid
assert cp >= 0, 'cp=%s' % cp
assert cd >= -1, 'cd=%s' % cd
assert seid >= 0, 'seid=%s' % seid
#print("nid", self.nid)
#print("nid", self._nidmap)
if nid in self._nidmap:
asdf
self._nidmap[nid] = self._nnodes
self.nid.append(nid)
self.cp.append(cp)
self.xyz.append(xyz)
self.cd.append(cd)
self.ps.append(ps)
self.seid.append(seid)
self._nnodes += 1
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.oid = integer(card, 1, 'oid')
self.label = string(card, 2, 'label')
self.xinit = double(card, 3, 'xinit')
self.xlb = double_or_blank(card, 4, 'xlb', -1e20)
self.xub = double_or_blank(card, 5, 'xub', 1e20)
self.delx = double_or_blank(card, 6, 'delx', 1e20)
self.ddval = integer_or_blank(card, 7, 'ddval')
assert len(card) <= 8, 'len(DESVAR card) = %i' % len(card)
else:
raise NotImplementedError(data)
def build(self):
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
#: Property ID
self.property_id = zeros(ncards, 'int32')
self.material_id = zeros(ncards, 'int32')
ncards = len(cards)
for i, card in enumerate(cards):
self.property_id[i] = integer(card, 1, 'property_id')
self.material_id[i] = integer(card, 2, 'material_id')
i = self.property_id.argsort()
self.property_id = self.property_id[i]
self.material_id = self.material_id[i]
unique_pids = unique(self.property_id)
if len(unique_pids) != len(self.property_id):
raise RuntimeError('There are duplicate PCOMP IDs...')
self._cards = []
self._comments = []
def build(self):
"""
:param self: the CELAS1 object
"""
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
#: Element ID
self.element_id = zeros(ncards, 'int32')
#: Property ID
self.property_id = zeros(ncards, 'int32')
#: Node IDs
self.node_ids = zeros((ncards, 2), 'int32')
#: component number
self.components = zeros((ncards, 2), 'int32')
for i, card in enumerate(cards):
self.element_id[i] = integer(card, 1, 'eid')
self.property_id[i] = integer_or_blank(card, 2, 'pid', self.element_id[i])
self.node_ids[i] = [integer(card, 3, 'n1'),
integer(card, 5, 'n2')]
self.components[i] = [integer_or_blank(card, 4, 'c1', 0),
integer_or_blank(card, 6, 'c2', 0)]
assert len(card) <= 7, 'len(CELAS1 card) = %i' % len(card)
i = self.element_id.argsort()
self.element_id = self.element_id[i]
self.property_id = self.property_id[i]
self.node_ids = self.node_ids[i, :]
self.components = self.components[i, :]
unique_eids = unique(self.element_id)
if len(unique_eids) != len(self.element_id):
raise RuntimeError('There are duplicate CELAS1 IDs...')
self._cards = []
self._comments = []
def add(self, card, comment=''):
i = self.i
self.property_id[i] = integer(card, 1, 'property_id')
self.material_id[i] = integer(card, 2, 'material_id')
self.area[i] = double_or_blank(card, 3, 'area', 0.0)
self.I1[i] = double_or_blank(card, 4, 'I1', 0.0)
self.I2[i] = double_or_blank(card, 5, 'I2', 0.0)
#: .. todo:: support SOL 600 default
Jdefault = 0.5 * (self.I1[i] + self.I2[i])
self.J[i] = double_or_blank(card, 6, 'J', Jdefault)
self.nsm[i] = double_or_blank(card, 7, 'non-structural_mass', 0.0)
if 0:
self.C1 = double_or_blank(card, 9, 'C1', 0.0)
self.C2 = double_or_blank(card, 10, 'C2', 0.0)
self.D1 = double_or_blank(card, 11, 'D1', 0.0)
self.D2 = double_or_blank(card, 12, 'D2', 0.0)
self.E1 = double_or_blank(card, 13, 'E1', 0.0)
self.E2 = double_or_blank(card, 14, 'E2', 0.0)
self.F1 = double_or_blank(card, 15, 'F1', 0.0)
self.F2 = double_or_blank(card, 16, 'F2', 0.0)
#: default=infinite; assume 1e8
self.K1 = double_or_blank(card, 17, 'K1', 1e8)
#: default=infinite; assume 1e8
self.K2 = double_or_blank(card, 18, 'K2', 1e8)
#: I12 -> use I12()
self.i12 = double_or_blank(card, 19, 'I12', 0.0)
if self.A == 0.0 and self.i12 == 0.0:
assert self.K1 is None, 'K1 must be blank if A=0.0 and I12=0.0; A=%r I12=%r K1=%r' % (
self.A, self.i12, self.K1)
assert self.K2 is None, 'K2 must be blank if A=0.0 and I12=0.0; A=%r I12=%r K2=%r' % (
self.A, self.i12, self.K2)
assert len(card) <= 20, 'len(PBAR card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
Property.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: Material ID
self.mid1 = integer_or_blank(card, 2, 'mid1', 0)
self.t1 = double_or_blank(card, 3, 't1')
self.mid2 = integer_or_blank(card, 4, 'mid2', 0)
if self.mid2 > 0:
self.i = double(card, 5, 'i')
assert self.i > 0.0
else:
self.i = blank(card, 5, 'i')
self.mid3 = integer(card, 6, 0)
if self.mid3 > 0:
self.t2 = double(card, 7, 't3')
assert self.t2 > 0.0
else:
self.t2 = blank(card, 7, 't3')
self.nsm = double(card, 8, 'nsm')
self.z1 = double(card, 9, 'z1')
self.z2 = double(card, 10, 'z2')
j = 1
self.phi = []
for i in range(11, len(card)):
phii = double(card, i, 'phi' % j)
self.phi.append(phii)
j += 1
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.oid = integer(card, 1, 'oid')
n = 1
ddvals = []
for i in range(2, len(card)):
ddval = double_string_or_blank(card, i, 'DDVAL%s' % n)
if ddval:
ddvals.append(ddval)
self.ddvals = expand_thru_by(ddvals)
self.ddvals.sort()
else:
raise NotImplementedError(data)
def add_from_bdf(self, card, comment):
"""
Fills the LOAD object from the BDF reader
:param self: the LOAD object
:param card: the BDFCard object
:param comment: a comment
"""
if comment:
self._comment = comment
#: load ID
self.load_id = integer(card, 1, 'sid')
#: overall scale factor
self.scale = double(card, 2, 'scale')
# alternating of scale factor & load set ID
nLoads = len(card) - 3
assert nLoads % 2 == 0
for i in range(nLoads // 2):
n = 2 * i + 3
self.scale_factors.append(double(card, n, 'scaleFactor'))
self.load_ids.append(integer(card, n + 1, 'loadID'))
def build(self):
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float
self.element_id = zeros(ncards, 'int32')
self.property_id = zeros(ncards, 'int32')
self.node_ids = zeros((ncards, 10), 'int32')
comments = {}
for i, card in enumerate(cards):
comment = self._comments[i]
element_id = integer(card, 1, 'element_id')
#if comment:
#self.comments[eid] = comment
#: Element ID
self.element_id[i] = element_id
#: Property ID
self.property_id[i] = integer(card, 2, 'property_id')
#: Node IDs
self.node_ids[i, :] = fields(integer,
card,
'node_ids',
i=3,
j=13)
assert len(card) == 13, 'len(CTETRA10 card) = %i' % len(card)
i = self.element_id.argsort()
self.element_id = self.element_id[i]
self.property_id = self.property_id[i]
self.node_ids = self.node_ids[i, :]
self._cards = []
self._comments = []
def add(self, card, comment):
i = self.i
self.property_id[i] = integer(card, 1, 'property_id')
self.material_id[i] = integer(card, 2, 'material_id')
self.group[i] = string_or_blank(card, 3, 'group', 'MSCBMLO')
Type = string(card, 4, 'Type')
self.Type[i] = Type
ndim = self.valid_types[Type]
j = 9 + ndim + 1
dim = fields(double_or_blank, card, 'dim', i=9, j=j)
nsm = double_or_blank(card, 9 + ndim + 1, 'nsm', 0.0)
if ndim > 0:
nsm = set_default_if_blank(dim.pop(), 0.0)
#else:
#nsm = 0.0
self.dim[i] = dim
self.nsm[i] = nsm
assert isinstance(nsm, float), 'nsm=%r' % nsm
if Type not in self.valid_types:
msg = ('Invalid PBARL Type, Type=%s '
'validTypes=%s' % (Type, self.valid_types.keys()))
raise RuntimeError(msg)
if len(dim) != self.valid_types[Type]:
msg = 'dim=%s len(dim)=%s Type=%s len(dimType)=%s' % (
dim, len(dim), Type, self.valid_types[Type])
raise RuntimeError(msg)
assert None not in dim
self.i += 1
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
#: Convection property identification number. (Integer > 0)
self.pconid = integer(card, 1, 'pconid')
assert self.pconid > 0
#: Material property identification number. (Integer > 0)
self.mid = integer(card, 2, 'mid')
assert self.mid > 0
#: Type of formula used for free convection.
#: (Integer 0, 1, 10, 11, 20, or 21)
self.form = integer_or_blank(card, 3, 'form', 0)
assert self.form in [0, 1, 10, 11, 20, 21]
#: Flag for mass flow convection. (Integer = 0 or 1; Default = 0)
self.flag = integer_or_blank(card, 4, 'flag', 0)
#: Constant coefficient used for forced convection
self.coef = double(card, 5, 'coef')
#: Reynolds number convection exponent. (Real > 0.0; Default = 0.0)
self.expr = double_or_blank(card, 6, 'expr', 0.0)
#: Prandtl number convection exponent for heat transfer into the
#: workingfluid. (Real > 0.0; Default = 0.0)
self.exppi = double_or_blank(card, 7, 'exppi', 0.0)
#: Prandtl number convection exponent for heat transfer into the
#: working fluid. (Real > 0.0; Default = 0.0)
self.exppo = double_or_blank(card, 8, 'exppo', 0.0)
assert len(card) <= 9, 'len(PCONVM card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
#ThermalBC.__init__(self, card, data)
if card:
#: CHBDYG, CHBDYE, or CHBDYP surface element identification number.
#: (Integer > 0)
self.eid = integer(card, 1, 'eid')
assert self.eid > 0
#: Convection property identification number of a PCONV entry
self.pconID = integer(card, 2, 'pconID')
#: Point for film convection fluid property temperature
self.flmnd = integer_or_blank(card, 3, 'flmnd', 0)
#: Control point for free convection boundary condition.
self.cntrlnd = integer_or_blank(card, 4, 'cntrlnd', 0)
TA1 = integer(card, 5, 'TA1')
assert TA1 > 0
#: Ambient points used for convection 0's are allowed for TA2 and
#: higher. (Integer > 0 for TA1 and Integer > 0 for TA2 through TA8;
#: Default for TA2 through TA8 is TA1.)
TA2 = integer_or_blank(card, 6, 'ta2', TA1)
TA3 = integer_or_blank(card, 7, 'ta3', TA1)
TA4 = integer_or_blank(card, 8, 'ta4', TA1)
TA5 = integer_or_blank(card, 9, 'ta5', TA1)
TA6 = integer_or_blank(card, 10, 'ta6', TA1)
TA7 = integer_or_blank(card, 11, 'ta7', TA1)
TA8 = integer_or_blank(card, 12, 'ta8', TA1)
self.ta = [TA1, TA2, TA3, TA4, TA5, TA6, TA7, TA8]
assert len(card) <= 13, 'len(CONV card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
#: Random analysis set identification number. (Integer > 0)
#: Defined by RANDOM in the Case Control Deck.
self.sid = integer(card, 1, 'sid')
#: Subcase identification number of the excited load set.
#: (Integer > 0)
self.j = integer(card, 2, 'j')
#: Subcase identification number of the applied load set.
#: (Integer >= 0; K >= J)
self.k = integer(card, 3, 'k')
#: Components of the complex number. (Real)
self.x = double_or_blank(card, 4, 'x', 0.0)
self.y = double_or_blank(card, 5, 'y', 0.0)
#: Identification number of a TABRNDi entry that defines G(F).
self.tid = integer_or_blank(card, 6, 'tid', 0)
assert len(card) <= 7, 'len(RANDPS card) = %i' % len(card)
else:
raise NotImplementedError(data)
def add(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.property_id[i] = integer(card, 2, 'property_id')
self.node_ids[i] = [
integer(card, 3, 'n1'),
integer(card, 4, 'n2'),
integer(card, 5, 'n3')
]
#self.thetaMcid = integer_double_or_blank(card, 6, 'thetaMcid', 0.0)
#self.zOffset = double_or_blank(card, 7, 'zOffset', 0.0)
blank(card, 8, 'blank')
blank(card, 9, 'blank')
self.t_flag[i] = integer_or_blank(card, 10, 'TFlag', 0)
self.thickness[i] = [
double_or_blank(card, 11, 'T1', 1.0),
double_or_blank(card, 12, 'T2', 1.0),
double_or_blank(card, 13, 'T3', 1.0),
]
self.i += 1
def __init__(self,
card=None,
data=None,
comment=''): # this card has missing fields
Ring.__init__(self, card, data)
if comment:
self._comment = comment
self.nid = integer(card, 1, 'nid')
blank(card, 2, 'blank')
self.R = double(card, 3, 'R')
self.z = double(card, 4, 'z')
blank(card, 5, 'blank')
blank(card, 6, 'blank')
self.ps = integer_or_blank(card, 7, 'ps')
assert len(card) <= 8, 'len(RINGAX card) = %i' % len(card)
def build(self):
"""
:param self: the GRAV object
:param cards: the list of GRAV cards
"""
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float
#: Set identification number
self.load_id = zeros(ncards, 'int32')
#: Coordinate system identification number.
self.coord_id = zeros(ncards, 'int32')
#: scale factor
self.scale = zeros(ncards, float_fmt)
self.N = zeros((ncards, 3), float_fmt)
self.mb = zeros(ncards, 'int32')
for i, card in enumerate(cards):
self.load_id[i] = integer(card, 1, 'sid')
self.coord_id[i] = integer_or_blank(card, 2, 'cid', 0)
self.scale[i] = double(card, 3, 'scale')
#: Acceleration vector components measured in coordinate system CID
self.N[i, :] = [
double_or_blank(card, 4, 'N1', 0.0),
double_or_blank(card, 5, 'N2', 0.0),
double_or_blank(card, 6, 'N3', 0.0)
]
#: Indicates whether the CID coordinate system is defined in the
#: main Bulk Data Section (MB = -1) or the partitioned superelement
#: Bulk Data Section (MB = 0). Coordinate systems referenced in the
#: main Bulk Data Section are considered stationary with respect to
#: the assembly basic coordinate system. See Remark 10.
#: (Integer; Default = 0)
self.mb[i] = integer_or_blank(card, 7, 'mb', 0)
assert len(card) <= 8, 'len(GRAV card) = %i' % len(card)
i = self.load_id.argsort()
self.load_id = self.load_id[i]
self.node_id = self.node_id[i]
self.coord_id = self.coord_id[i]
self.scale = self.scale[i]
self.N = self.N[i]
self._cards = []
self._comments = []
def build(self):
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float
self.material_id = zeros(ncards, 'int32')
self.rho = zeros(ncards, float_fmt)
self.E = zeros(ncards, float_fmt)
self.G = zeros(ncards, float_fmt)
self.nu = zeros(ncards, float_fmt)
self.a = zeros(ncards, float_fmt)
self.TRef = zeros(ncards, float_fmt)
self.ge = zeros(ncards, float_fmt)
self.St = zeros(ncards, float_fmt)
self.Sc = zeros(ncards, float_fmt)
self.Ss = zeros(ncards, float_fmt)
self.mcsid = zeros(ncards, 'int32')
for (i, card) in enumerate(cards):
#if comment:
# self._comment = comment
self.material_id[i] = integer(card, 1, 'mid')
self.set_E_G_nu(i, card)
self.rho[i] = double_or_blank(card, 5, 'rho', 0.)
self.a[i] = double_or_blank(card, 6, 'a', 0.0)
self.TRef[i] = double_or_blank(card, 7, 'TRef', 0.0)
self.ge[i] = double_or_blank(card, 8, 'ge', 0.0)
self.St[i] = double_or_blank(card, 9, 'St', 0.0)
self.Sc[i] = double_or_blank(card, 10, 'Sc', 0.0)
self.Ss[i] = double_or_blank(card, 11, 'Ss', 0.0)
self.mcsid[i] = integer_or_blank(card, 12, 'Mcsid', 0)
assert len(card) <= 13, 'len(MAT1 card) = %i' % len(card)
i = self.material_id.argsort()
self.material_id = self.material_id[i]
self.E = self.E[i]
self.G = self.G[i]
self.rho = self.rho[i]
self.a = self.a[i]
self.TRef = self.TRef[i]
self.ge = self.ge[i]
self.St = self.St[i]
self.Sc = self.Sc[i]
self.Ss = self.Ss[i]
self.mcsid = self.mcsid[i]
self._cards = []
self._comments = []
def __init__(self, card=None, data=None, comment=''):
MaterialDependence.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.mid = integer(card, 1, 'mid')
self._k_table = integer_or_blank(card, 2, 'T(K)')
self._cp_table = integer_or_blank(card, 3, 'T(CP)')
self._H_table = integer_or_blank(card, 5, 'T(H)')
self._mu_table = integer_or_blank(card, 6, 'T(mu)')
self._Hgen_table = integer_or_blank(card, 7, 'T(HGEN)')
assert len(card) <= 8, 'len(MATT4 card) = %i' % len(card)
else:
raise NotImplementedError()
def __init__(self, card=None, data=None, comment=''):
PointMassElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.pid = integer_or_blank(card, 2, 'pid', self.eid)
self.s1 = integer_or_blank(card, 3, 's1')
self.s2 = integer_or_blank(card, 4, 's2')
assert len(card) <= 5, 'len(CMASS3 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
self.s1 = data[2]
self.s2 = data[3]
assert self.s1 != self.s2
def loadCLAN(self, nRows, card):
for irow in range(nRows):
#NDJ_default = None
i = 9 + 8 * irow
self.alphaAjs.append(
double_or_blank(card, i, 'alpha' + str(irow), 0.0))
self.omegaAjs.append(
double_or_blank(card, i + 1, 'omega' + str(irow), 0.0))
self.mblkszs.append(
double_or_blank(card, i + 2, 'mblock' + str(irow), 7))
self.iblkszs.append(
integer_or_blank(card, i + 3, 'iblksz' + str(irow), 2))
self.ksteps.append(
integer_or_blank(card, i + 4, 'kstep' + str(irow), 5))
self.NJIs.append(integer(card, i + 6, 'NJI' + str(irow)))
def __init__(self, card=None, nPDAMP=0, data=None, comment=''):
DamperProperty.__init__(self, card, data)
if comment:
self._comment = comment
nOffset = nPDAMP * 2
if card:
# 3 PDAMP properties can be defined on 1 PDAMP card
#: Property ID
self.pid = integer(card, 1 + nOffset, 'pid')
# these are split into 2 separate cards
#: Force per unit velocity (Real)
self.b = double(card, 2 + nOffset, 'b')
else:
self.pid = data[0]
self.b = data[1]
