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 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 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=''):
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=''):
"""
+--------+-----------+------------+-------+------+--------+-------+-----+-------+
| DRESP1 | 1S1 | CSTRAIN | PCOMP | | | 1 | 1 | 10000 |
+--------+-----------+------------+-------+------+--------+-------+-----+-------+
"""
if comment:
self._comment = comment
if card:
self.oid = integer(card, 1, 'oid')
self.label = string(card, 2, 'label')
self.rtype = string(card, 3, 'rtype')
# elem, pbar, pshell, etc. (ELEM flag or Prop Name)
self.ptype = integer_string_or_blank(card, 4, 'ptype')
#if 1:
## incomplete
#assert self.ptype in ['ELEM', 'PSHELL', 'PBAR', 'PROD', 'PCOMP',
#'PSOLID', 'PELAS', 'PBARL', 'PBEAM',
#'PBEAML', 'PSHEAR', 'PTUBE',
#'PKNL',
#None], 'DRESP1 ptype=%s' % self.ptype
self.region = integer_or_blank(card, 5, 'region')
self.atta = integer_double_string_or_blank(card, 6, 'atta')
self.attb = integer_double_string_or_blank(card, 7, 'attb')
self.atti = []
for i in range(8, len(card)):
atti = integer_double_string_or_blank(card, i, 'atti_%i' % (i + 1))
self.atti.append(atti)
else:
raise RuntimeError(data)
def __init__(self, card=None, data=None, comment=''):
"""
::
DRESP1 1S1 CSTRAIN PCOMP 1 1 10000
"""
if comment:
self._comment = comment
self.oid = integer(card, 1, 'oid')
self.label = string(card, 2, 'label')
self.rtype = string(card, 3, 'rtype')
# elem, pbar, pshell, etc. (ELEM flag or Prop Name)
self.ptype = integer_string_or_blank(card, 4, 'ptype')
if 0:
assert self.ptype in ['ELEM', 'PSHELL', 'PBAR', 'PROD', 'PCOMP',
'PSOLID', 'PELAS', 'PBARL', 'PBEAM',
'PBEAML', 'PSHEAR', 'PTUBE',
'PKNL', #: .. todo:: is this correct?
None], 'DRESP1 ptype=%s' % self.ptype
self.region = integer_or_blank(card, 5, 'region')
self.atta = integer_double_string_or_blank(card, 6, 'atta')
self.attb = integer_double_string_or_blank(card, 7, 'attb')
self.atti = integer_double_string_or_blank(card, 8, 'atti')
self.others = [interpret_value(field) for field in card[9:] ]
def __init__(self, card=None, data=None, comment=''):
Set.__init__(self, card, data)
if comment:
self._comment = comment
#: Unique identification number. (Integer > 0)
self.sid = integer(card, 1, 'sid')
self.IDs = []
IDs = []
i = 1
for ifield in range(2, len(card)):
ID = integer_string_or_blank(card, ifield, 'ID%i' % i)
if ID:
i += 1
IDs.append(ID)
#IDs = fields(integer_or_string, card, 'ID', i=2, j=len(card))
self.isSkin = False
i = 0
if isinstance(IDs[0], str) and IDs[0] == 'SKIN':
self.isSkin = True
i += 1
#: List of structural grid point or element identification numbers.
#: (Integer > 0 or 'THRU'; for the 'THRU' option, ID1 < ID2 or 'SKIN';
#: in field 3)
self.IDs = expand_thru(IDs[i:])
self.cleanIDs()
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')
self.dphase = integer_double_or_blank(card, 4, 'dphase')
self.tc = integer_or_blank(card, 5, 'tc', 0)
self.td = integer_or_blank(card, 6, 'td', 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 RLOAD1 type Type=|%s|' % 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=''):
Set.__init__(self, card, data)
if comment:
self._comment = comment
#: Unique identification number. (Integer > 0)
self.sid = integer(card, 1, 'sid')
self.IDs = []
IDs = []
i = 1
for ifield in range(2, len(card)):
ID = integer_string_or_blank(card, ifield, 'ID%i' % i)
if ID:
i += 1
IDs.append(ID)
#IDs = fields(integer_or_string, card, 'ID', i=2, j=len(card))
self.isSkin = False
i = 0
if isinstance(IDs[0], str) and IDs[0] == 'SKIN':
self.isSkin = True
i += 1
#: List of structural grid point or element identification numbers.
#: (Integer > 0 or 'THRU'; for the 'THRU' option, ID1 < ID2 or 'SKIN';
#: in field 3)
self.IDs = expand_thru(IDs[i:])
self.cleanIDs()
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=''):
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 __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')
p1 = double_or_blank(card, 3, 'p1', 0.0)
p = [p1,
double_or_blank(card, 4, 'p2', p1),
double_or_blank(card, 5, 'p3', p1),
double_or_blank(card, 6, 'p4', p1)]
self.pressures = p
self.eids = [self.eid]
if (integer_string_or_blank(card, 7, 'g1/THRU') == 'THRU' and
integer_or_blank(card, 8, 'eid2')): # plates
eid2 = integer(card, 8, 'eid2')
if eid2:
self.eids = expand_thru([self.eid, 'THRU', eid2])
self.g1 = None
self.g34 = None
else:
#: used for CPENTA, CHEXA
self.eids = [self.eid]
#: used for solid element only
self.g1 = integer_or_blank(card, 7, 'g1')
#: g3/g4 - different depending on CHEXA/CPENTA or CTETRA
self.g34 = integer_or_blank(card, 8, 'g34')
#: Coordinate system identification number. See Remark 2.
#: (Integer >= 0;Default=0)
self.cid = integer_or_blank(card, 9, 'cid', 0)
#print "PLOAD4 cid = ",self.cid
self.NVector = array([double_or_blank(card, 10, 'N1', 0.0),
double_or_blank(card, 11, 'N2', 0.0),
double_or_blank(card, 12, 'N3', 0.0)])
self.sorl = string_or_blank(card, 13, 'sorl', 'SURF')
self.ldir = string_or_blank(card, 14, 'ldir', 'NORM')
assert len(card) <= 15, 'len(PLOAD4 card) = %i' % len(card)
else:
#print "PLOAD4 = ",data
self.sid = data[0]
self.eid = data[1]
self.pressures = data[2]
self.g1 = data[3]
self.g34 = data[4]
self.cid = data[5]
self.NVector = data[6]
self.sorl = data[7]
#self.ldir = data[8]
#assert len(data)==8
self.g1 = self.g1
self.g34 = self.g34
self.eids = [self.eid]
def __init__(self, card=None, data=None, comment=''):
TabularLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: load ID
#: SID must be unique for all TLOAD1, TLOAD2, RLOAD1, RLOAD2, and ACSRCE entries.
self.sid = integer(card, 1, 'sid')
self.exciteID = integer(card, 2, 'exciteID')
self.delay = integer_or_blank(card, 3, 'delay', 0)
#: Defines the type of the dynamic excitation. (Integer; character
#: or blank; Default = 0)
self.Type = integer_string_or_blank(card, 4, 'Type', 'LOAD')
#: Time constant. (Real >= 0.0)
self.T1 = double_or_blank(card, 5, 'T1', 0.0)
#if self.delay == 0:
#self.T1 = double_or_blank(card, 5, 'T1', 0.)
#else:
#self.T1 = blank(card, 5, 'T1')
#: Time constant. (Real; T2 > T1)
self.T2 = double_or_blank(card, 6, 'T2', self.T1)
#: Frequency in cycles per unit time. (Real >= 0.0; Default = 0.0)
self.frequency = double_or_blank(card, 7, 'frequency', 0.)
#: Phase angle in degrees. (Real; Default = 0.0)
self.phase = double_or_blank(card, 8, 'phase', 0.)
#: Exponential coefficient. (Real; Default = 0.0)
self.c = double_or_blank(card, 9, 'c', 0.)
#: Growth coefficient. (Real; Default = 0.0)
self.b = double_or_blank(card, 10, 'b', 0.)
#: Factor for initial displacements of the enforced degrees-of-freedom.
#: (Real; Default = 0.0)
self.us0 = double_or_blank(card, 11, 'us0', 0.)
#: Factor for initial velocities of the enforced degrees-of-freedom
#: (Real; Default = 0.0)
self.vs0 = double_or_blank(card, 12, 'vs0', 0.)
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'
elif self.Type in [5, 6, 7, 12, 13]:
pass
else:
msg = 'invalid TLOAD2 type Type=|%s|' % self.Type
raise RuntimeError(msg)
assert len(card) <= 13, 'len(TLOAD2 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
TabularLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: load ID
#: SID must be unique for all TLOAD1, TLOAD2, RLOAD1, RLOAD2, and ACSRCE entries.
self.sid = integer(card, 1, 'sid')
self.exciteID = integer(card, 2, 'exciteID')
self.delay = integer_or_blank(card, 3, 'delay', 0)
#: Defines the type of the dynamic excitation. (Integer; character
#: or blank; Default = 0)
self.Type = integer_string_or_blank(card, 4, 'Type', 'LOAD')
#: Time constant. (Real >= 0.0)
self.T1 = double_or_blank(card, 5, 'T1', 0.0)
#if self.delay == 0:
#self.T1 = double_or_blank(card, 5, 'T1', 0.)
#else:
#self.T1 = blank(card, 5, 'T1')
#: Time constant. (Real; T2 > T1)
self.T2 = double_or_blank(card, 6, 'T2', self.T1)
#: Frequency in cycles per unit time. (Real >= 0.0; Default = 0.0)
self.frequency = double_or_blank(card, 7, 'frequency', 0.)
#: Phase angle in degrees. (Real; Default = 0.0)
self.phase = double_or_blank(card, 8, 'phase', 0.)
#: Exponential coefficient. (Real; Default = 0.0)
self.c = double_or_blank(card, 9, 'c', 0.)
#: Growth coefficient. (Real; Default = 0.0)
self.b = double_or_blank(card, 10, 'b', 0.)
#: Factor for initial displacements of the enforced degrees-of-freedom.
#: (Real; Default = 0.0)
self.us0 = double_or_blank(card, 11, 'us0', 0.)
#: Factor for initial velocities of the enforced degrees-of-freedom
#: (Real; Default = 0.0)
self.vs0 = double_or_blank(card, 12, 'vs0', 0.)
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'
elif self.Type in [5, 6, 7, 12, 13]:
pass
else:
msg = 'invalid TLOAD2 type Type=|%s|' % self.Type
raise RuntimeError(msg)
assert len(card) <= 13, 'len(TLOAD2 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def add(self, card, comment=None):
#self._comments.append(comment)
self._load_id.append(integer(card, 1, 'load_id'))
self._p.append(double(card, 2, 'p'))
if integer_string_or_blank(card, 4, 'THRU') == 'THRU':
e1 = integer(card, 3, 'Element1')
e2 = integer(card, 5, 'Element1')
eids = [i for i in xrange(e1, e2 + 1)]
else:
eids = fields(integer, card, 'eid', i=3, j=len(card))
assert len(card) == 6, 'len(PLOAD2 card) = %i' % len(card)
self.n += len(eids)
self._element_ids.append(eids)
def __init__(self, card=None, data=None, comment=''):
TabularLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: load ID
self.sid = integer(card, 1, 'sid')
#: Identification number of DAREA or SPCD entry set or a thermal load
#: set (in heat transfer analysis) that defines {A}. (Integer > 0)
self.exciteID = integer(card, 2, 'exciteID')
#: If it is a non-zero integer, it represents the
#: identification number of DELAY Bulk Data entry that defines .
#: If it is real, then it directly defines the value of that will
#: be used for all degrees-of-freedom that are excited by this
#: dynamic load entry. See also Remark 9. (Integer >= 0,
#: real or blank)
self.delay = integer_double_or_blank(card, 3, 'delay')
#: Defines the type of the dynamic excitation. (LOAD,DISP, VELO, ACCE)
self.Type = integer_string_or_blank(card, 4, 'Type', 'LOAD')
#: Identification number of TABLEDi entry that gives F(t). (Integer > 0)
self.tid = integer(card, 5, 'tid')
#: Factor for initial displacements of the enforced degrees-of-freedom.
#: (Real; Default = 0.0)
self.us0 = double_or_blank(card, 6, 'us0', 0.0)
#: Factor for initial velocities of the enforced degrees-of-freedom.
#: (Real; Default = 0.0)
self.vs0 = double_or_blank(card, 7, 'vs0', 0.0)
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 TLOAD1 type Type=|%s|' % self.Type
raise RuntimeError(msg)
assert len(card) <= 8, 'len(TLOAD1 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
TabularLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: load ID
self.sid = integer(card, 1, 'sid')
#: Identification number of DAREA or SPCD entry set or a thermal load
#: set (in heat transfer analysis) that defines {A}. (Integer > 0)
self.exciteID = integer(card, 2, 'exciteID')
#: If it is a non-zero integer, it represents the
#: identification number of DELAY Bulk Data entry that defines .
#: If it is real, then it directly defines the value of that will
#: be used for all degrees-of-freedom that are excited by this
#: dynamic load entry. See also Remark 9. (Integer >= 0,
#: real or blank)
self.delay = integer_double_or_blank(card, 3, 'delay', 0)
#: Defines the type of the dynamic excitation. (LOAD,DISP, VELO, ACCE)
self.Type = integer_string_or_blank(card, 4, 'Type', 'LOAD')
#: Identification number of TABLEDi entry that gives F(t). (Integer > 0)
self.tid = integer(card, 5, 'tid')
#: Factor for initial displacements of the enforced degrees-of-freedom.
#: (Real; Default = 0.0)
self.us0 = double_or_blank(card, 6, 'us0', 0.0)
#: Factor for initial velocities of the enforced degrees-of-freedom.
#: (Real; Default = 0.0)
self.vs0 = double_or_blank(card, 7, 'vs0', 0.0)
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 TLOAD1 type Type=|%s|' % self.Type
raise RuntimeError(msg)
assert len(card) <= 8, 'len(TLOAD1 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.p = double(card, 2, 'p')
if integer_string_or_blank(card, 4, 'THRU') == 'THRU':
e1 = integer(card, 3, 'Element1')
e2 = integer(card, 5, 'Element1')
eids = [i for i in range(e1, e2 + 1)]
assert len(card) == 6, 'len(PLOAD2 card) = %i' % len(card)
else:
eids = fields(integer, card, 'eid', i=3, j=len(card))
self.eids = eids
else:
self.sid = data[0]
self.p = data[1]
self.eids = list(data[2:])
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
#: Set identification number. (Unique Integer > 0)
self.sid = integer(card, 1, 'sid')
#: Number (float)
nfields = card.nfields
i = 2
eid_data = []
while i < nfields:
d = integer_string_or_blank(card, i, 'field_%s' % i)
if d is not None:
eid_data.append(d)
i += 1
#: Element identification numbers of shell elements. (Integer > 0)
self.eids = expand_thru_by(eid_data)
else:
msg = '%s has not implemented data parsing' % self.type
raise NotImplementedError(msg)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
#: Set identification number. (Unique Integer > 0)
self.sid = integer(card, 1, 'sid')
#: Number (float)
n = card.nFields()
i = 2
eid_data = []
while i < n:
d = integer_string_or_blank(card, i, 'field_%s' % i)
if d is not None:
eid_data.append(d)
i += 1
#: Element identification numbers of shell elements. (Integer > 0)
self.eids = expand_thru_by(eid_data)
else:
msg = '%s has not implemented data parsing' % self.type
raise NotImplementedError(msg)
def __init__(self, card=None, data=None, comment=''):
Set.__init__(self, card, data)
if comment:
self._comment = comment
#: Component number. (Integer zero or blank for scalar points or any
#: unique combination of the Integers 1 through 6 for grid points with
#: no embedded blanks.)
self.components = components_or_blank(card, 1, 'components', 0)
nfields = len(card)
IDs = []
i = 1
for ifield in range(2, nfields):
ID = integer_string_or_blank(card, ifield, 'ID%i' % i)
if ID:
i += 1
IDs.append(ID)
#IDs = fields(integer_or_string, card, 'ID', i=2, j=nfields)
#: Identifiers of grids points. (Integer > 0)
self.IDs = expand_thru(IDs)
def __init__(self, card=None, data=None, comment=''):
Set.__init__(self, card, data)
if comment:
self._comment = comment
#: Component number. (Integer zero or blank for scalar points or any
#: unique combination of the Integers 1 through 6 for grid points with
#: no embedded blanks.)
self.components = components_or_blank(card, 1, 'components', 0)
nfields = len(card)
IDs = []
i = 1
for ifield in range(2, nfields):
ID = integer_string_or_blank(card, ifield, 'ID%i' % i)
if ID:
i += 1
IDs.append(ID)
#IDs = fields(integer_or_string, card, 'ID', i=2, j=nfields)
#: Identifiers of grids points. (Integer > 0)
self.IDs = expand_thru(IDs)
def __init__(self, card=None, data=None, comment=''):
"""
::
DRESP1 1S1 CSTRAIN PCOMP 1 1 10000
"""
if comment:
self._comment = comment
self.oid = integer(card, 1, 'oid')
self.label = string(card, 2, 'label')
self.rtype = string(card, 3, 'rtype')
# elem, pbar, pshell, etc. (ELEM flag or Prop Name)
self.ptype = integer_string_or_blank(card, 4, 'ptype')
if 0:
assert self.ptype in [
'ELEM',
'PSHELL',
'PBAR',
'PROD',
'PCOMP',
'PSOLID',
'PELAS',
'PBARL',
'PBEAM',
'PBEAML',
'PSHEAR',
'PTUBE',
'PKNL', #: .. todo:: is this correct?
None
], 'DRESP1 ptype=%s' % self.ptype
self.region = integer_or_blank(card, 5, 'region')
self.atta = integer_double_string_or_blank(card, 6, 'atta')
self.attb = integer_double_string_or_blank(card, 7, 'attb')
self.atti = integer_double_string_or_blank(card, 8, 'atti')
self.others = [interpret_value(field) for field in card[9:]]
def build(self):
"""
:param self: the PSOLID object
:param cards: the list of PSOLID cards
"""
cards = self._cards
ncards = len(cards)
self.n = ncards
print "N[%s] = %s" % (self.type, self.n)
if ncards:
float_fmt = self.model.float
#: Property ID
self.property_id = zeros(ncards, 'int32')
#: Material ID
self.material_id = zeros(ncards, 'int32')
self.cordm = zeros(ncards, 'int32')
self.integ = zeros(ncards, dtype='|S8')
self.stress = zeros(ncards, dtype='|S8')
self.isop = zeros(ncards, dtype='|S8')
self.fctn = zeros(ncards, dtype='|S8')
#print "isop", self.isop
for i, card in enumerate(cards):
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)
i = self.property_id.argsort()
self.property_id = self.property_id[i]
self.material_id = self.material_id[i]
self.cordm = self.cordm[i]
self.integ = self.integ[i]
self.stress = self.stress[i]
self.isop = self.isop[i]
self.fctn = self.fctn[i]
unique_pids = unique(self.property_id)
if len(unique_pids) != len(self.property_id):
raise RuntimeError('There are duplicate PROD IDs...')
self._cards = []
self._comments = []
def build(self):
"""
:param self: the PLOAD4 object
"""
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float
self.load_id = zeros(ncards, 'int32')
#: Element ID
self.element_id = zeros(ncards, 'int32')
#: Property ID
self.pressures = zeros((ncards, 4), 'int32')
element_ids = {}
for i in range(ncards):
element_ids[i] = []
self.g1 = full(ncards, nan, 'int32')
self.g34 = full(ncards, nan, 'int32')
self.ldir = full(ncards, nan, '|S4')
self.sorl = full(ncards, nan, '|S4')
self.cid = zeros(ncards, dtype='int32')
self.NVector = zeros((ncards, 3), dtype=float_fmt)
for i, card in enumerate(cards):
self.load_id[i] = integer(card, 1, 'load_id')
eid = integer(card, 2, 'element_id')
self.element_id[i] = eid
p1 = double_or_blank(card, 3, 'p1', 0.0)
p = [
p1,
double_or_blank(card, 4, 'p2', p1),
double_or_blank(card, 5, 'p3', p1),
double_or_blank(card, 6, 'p4', p1)
]
self.pressures[i, :] = p
self.element_ids[i] = [eid]
if (integer_string_or_blank(card, 7, 'g1/THRU') == 'THRU'
and integer_or_blank(card, 8, 'eid2')): # plates
eid2 = integer(card, 8, 'eid2')
if eid2:
self.element_ids[i] = list(
unique(
expand_thru([self.eid, 'THRU', eid2],
set_fields=False,
sort_fields=False)))
#self.g1 = None
#self.g34 = None
else:
#: used for CPENTA, CHEXA
self.element_ids[i] = [self.eid]
#: used for solid element only
self.g1[i] = integer_or_blank(card, 7, 'g1')
#: g3/g4 - different depending on CHEXA/CPENTA or CTETRA
self.g34[i] = integer_or_blank(card, 8, 'g34')
#: Coordinate system identification number. See Remark 2.
#: (Integer >= 0;Default=0)
self.cid[i] = integer_or_blank(card, 9, 'cid', 0)
self.NVector[i, :] = [
double_or_blank(card, 10, 'N1', 0.0),
double_or_blank(card, 11, 'N2', 0.0),
double_or_blank(card, 12, 'N3', 0.0),
]
self.sorl[i] = string_or_blank(card, 13, 'sorl', 'SURF')
self.ldir[i] = string_or_blank(card, 14, 'ldir', 'NORM')
assert len(card) <= 15, 'len(PLOAD4 card) = %i' % len(card)
i = self.load_id.argsort()
#self.element_id = self.element_id[i]
self.pressures = self.pressures[i, :]
#self.node_ids = self.node_ids[i, :]
#element_ids = {}
#for j in range(ncards):
#element_ids[j] = element_ids[i[j]]
self.g1 = self.g1[i]
self.g34 = self.g34[i]
self.ldir = self.ldir[i]
self.sorl = self.sorl[i]
self.cid = self.cid[i]
self.NVector = self.NVector[i, :]
self.n += len(eids)
self.load_cases = {}
self.load_ids = unique(self.load_id)
else:
self.load_id = array([], dtype='int32')
def build(self):
"""
:param self: the PLOAD4 object
"""
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float
self.load_id = zeros(ncards, 'int32')
#: Element ID
self.element_id = zeros(ncards, 'int32')
#: Property ID
self.pressures = zeros((ncards, 4), 'int32')
element_ids = {}
for i in range(ncards):
element_ids[i] = []
self.g1 = full(ncards, nan, 'int32')
self.g34 = full(ncards, nan, 'int32')
self.ldir = full(ncards, nan, '|S4')
self.sorl = full(ncards, nan, '|S4')
self.cid = zeros(ncards, dtype='int32')
self.NVector = zeros((ncards, 3), dtype=float_fmt)
for i, card in enumerate(cards):
self.load_id[i] = integer(card, 1, 'load_id')
eid = integer(card, 2, 'element_id')
self.element_id[i] = eid
p1 = double_or_blank(card, 3, 'p1', 0.0)
p = [p1,
double_or_blank(card, 4, 'p2', p1),
double_or_blank(card, 5, 'p3', p1),
double_or_blank(card, 6, 'p4', p1)]
self.pressures[i, :] = p
self.element_ids[i] = [eid]
if(integer_string_or_blank(card, 7, 'g1/THRU') == 'THRU' and
integer_or_blank(card, 8, 'eid2')): # plates
eid2 = integer(card, 8, 'eid2')
if eid2:
self.element_ids[i] = list(unique(expand_thru([self.eid, 'THRU', eid2],
set_fields=False, sort_fields=False)))
#self.g1 = None
#self.g34 = None
else:
#: used for CPENTA, CHEXA
self.element_ids[i] = [self.eid]
#: used for solid element only
self.g1[i] = integer_or_blank(card, 7, 'g1')
#: g3/g4 - different depending on CHEXA/CPENTA or CTETRA
self.g34[i] = integer_or_blank(card, 8, 'g34')
#: Coordinate system identification number. See Remark 2.
#: (Integer >= 0;Default=0)
self.cid[i] = integer_or_blank(card, 9, 'cid', 0)
self.NVector[i, :] = [
double_or_blank(card, 10, 'N1', 0.0),
double_or_blank(card, 11, 'N2', 0.0),
double_or_blank(card, 12, 'N3', 0.0), ]
self.sorl[i] = string_or_blank(card, 13, 'sorl', 'SURF')
self.ldir[i] = string_or_blank(card, 14, 'ldir', 'NORM')
assert len(card) <= 15, 'len(PLOAD4 card) = %i' % len(card)
i = self.load_id.argsort()
#self.element_id = self.element_id[i]
self.pressures = self.pressures[i, :]
#self.node_ids = self.node_ids[i, :]
#element_ids = {}
#for j in range(ncards):
#element_ids[j] = element_ids[i[j]]
self.g1 = self.g1[i]
self.g34 = self.g34[i]
self.ldir = self.ldir[i]
self.sorl = self.sorl[i]
self.cid = self.cid[i]
self.NVector = self.NVector[i, :]
self.n += len(eids)
self.load_cases = {}
self.load_ids = unique(self.load_id)
else:
self.load_id = array([], dtype='int32')
def build(self):
"""
:param self: the PSOLID object
:param cards: the list of PSOLID cards
"""
cards = self._cards
ncards = len(cards)
self.n = ncards
print "N[%s] = %s" % (self.type, self.n)
if ncards:
float_fmt = self.model.float
#: Property ID
self.property_id = zeros(ncards, 'int32')
#: Material ID
self.material_id = zeros(ncards, 'int32')
self.cordm = zeros(ncards, 'int32')
self.integ = zeros(ncards, dtype='|S8')
self.stress = zeros(ncards, dtype='|S8')
self.isop = zeros(ncards, dtype='|S8')
self.fctn = zeros(ncards, dtype='|S8')
#print "isop", self.isop
for i, card in enumerate(cards):
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)
i = self.property_id.argsort()
self.property_id = self.property_id[i]
self.material_id = self.material_id[i]
self.cordm = self.cordm[i]
self.integ = self.integ[i]
self.stress = self.stress[i]
self.isop = self.isop[i]
self.fctn = self.fctn[i]
unique_pids = unique(self.property_id)
if len(unique_pids) != len(self.property_id):
raise RuntimeError('There are duplicate PROD IDs...')
self._cards = []
self._comments = []
def test_integer_string_or_blank(self):
# integer
self.check_integer(integer_string_or_blank)
# float
#print type(integer_string_or_blank(BDFCard(['4.0']), 0, 'field'))
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard([3.0] ), 0, 'field')
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard(['4.0']), 0, 'field')
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard(['5.'] ), 0, 'field')
# string
self.assertEqual('LOAD', integer_string_or_blank(BDFCard(['load'] ), 0, 'field'))
# blank
integer_string_or_blank(BDFCard([' ']), 0, 'field')
integer_string_or_blank(BDFCard([None]), 0, 'field')
def test_integer_string_or_blank(self):
# integer
self.check_integer(integer_string_or_blank)
# float
# print type(integer_string_or_blank(BDFCard(['4.0']), 0, 'field'))
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard([3.0]), 0, "field")
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard(["4.0"]), 0, "field")
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard(["5."]), 0, "field")
# string
self.assertEqual("LOAD", integer_string_or_blank(BDFCard(["load"]), 0, "field"))
# blank
integer_string_or_blank(BDFCard([" "]), 0, "field")
integer_string_or_blank(BDFCard([None]), 0, "field")
