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=''):
Constraint.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.conid = integer(card, 1, 'sid')
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)]
# reduce the size if there are duplicate Nones
nConstraints = max(len(self.gids),
len(self.constraints),
len(self.enforced))
self.gids = self.gids[0:nConstraints]
self.constraints = self.constraints[0:nConstraints]
self.enforced = self.enforced[0:nConstraints]
else:
self.conid = data[0]
self.gids = [data[1]]
self.constraints = [data[2]]
self.enforced = [data[3]]
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=''):
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 __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')
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)]
# reduce the size if there are duplicate Nones
nConstraints = max(len(self.gids),
len(self.constraints),
len(self.enforced))
self.gids = self.gids[0:nConstraints]
self.constraints = self.constraints[0:nConstraints]
self.enforced = self.enforced[0:nConstraints]
else:
self.conid = data[0]
self.gids = [data[1]]
self.constraints = [data[2]]
self.enforced = [data[3]]
def __init__(self, card=None, data=None, comment=''):
Constraint.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Set identification number. (Integer > 0)
self.conid = integer(card, 1, 'conid')
#: Identification number of grid or scalar point. (Integer > 0)
self.gids = []
#: Component number. (Any one of the Integers 1 through 6 for grid
#: points; blank or zero for scalar points.)
self.constraints = []
#: Coefficient. (Real; Default = 0.0 except A1 must be nonzero.)
self.enforced = []
fields = card.fields(0)
nfields = len(fields)
i = 1
for ifield in range(2, nfields, 8):
grid = integer(card, ifield, 'G%i' % i)
component = components_or_blank(card, ifield + 1, 'constraint%i' % i, 0) # scalar point
if i == 1:
value = double(card, ifield + 2, 'enforced%i' % i)
if value == 0.0:
raise RuntimeError('enforced1 must be nonzero; value=%r' % value)
else:
value = double_or_blank(card, ifield + 2, 'enforced%i' % i, 0.0)
self.gids.append(grid)
self.constraints.append(component)
self.enforced.append(value)
i += 1
if ifield + 4 > nfields and i != 2:
# if G2 is empty (it's ifield+4 because nfields is length based and not loop friendly)
break
grid = integer(card, ifield + 3, 'G%i' % i)
component = components_or_blank(card, ifield + 4, 'constraint%i' % i, 0) # scalar point
value = double_or_blank(card, ifield + 5, 'enforced%i' % i)
self.gids.append(grid)
self.constraints.append(component)
self.enforced.append(value)
i += 1
# reduce the size if there are duplicate Nones
#nConstraints = max(len(self.gids ),
# len(self.constraints),
# len(self.enforced ))
#self.gids = self.gids[ 0:nConstraints]
#self.constraints = self.constraints[0:nConstraints]
#self.enforced = self.enforced[ 0:nConstraints]
else:
msg = '%s has not implemented data parsing' % self.type
raise NotImplementedError(msg)
def get_spc_constraint(card, i):
if i == 0:
constraint_id = integer(card, 1, 'sid')
node_id = integer(card, 2, 'G1')
dofs = components_or_blank(card, 3, 'C1', 0)
enforced_motion = double_or_blank(card, 4, 'D1', 0.0)
elif i == 1:
constraint_id = integer(card, 1, 'sid')
node_id = integer_or_blank(card, 5, 'G2')
dofs = components_or_blank(card, 6, 'C2', 0)
enforced_motion = double_or_blank(card, 7, 'D2', 0.0)
else:
raise RuntimeError('i =', i)
return constraint_id, node_id, dofs, enforced_motion
def get_spc_constraint(card, i):
if i == 0:
constraint_id = integer(card, 1, 'sid')
node_id = integer(card, 2, 'G1')
dofs = components_or_blank(card, 3, 'C1', 0)
enforced_motion = double_or_blank(card, 4, 'D1', 0.0)
elif i == 1:
constraint_id = integer(card, 1, 'sid')
node_id = integer_or_blank(card, 5, 'G2')
dofs = components_or_blank(card, 6, 'C2', 0)
enforced_motion = double_or_blank(card, 7, 'D2', 0.0)
else:
raise RuntimeError('i =', i)
return constraint_id, node_id, dofs, enforced_motion
def add(self, card, comment=''):
#self.model.log.debug('RBE2.add')
i = self.i
#if comment:
#self._comment = comment
eid = integer(card, 1, 'element_id')
gn = integer(card, 2, 'gn')
cm = components_or_blank(card, 3, 'cm')
#assert gn is not None, 'gn=%s' % self.gn
#assert cm is not None, 'cm=%s' % self.cm
self.element_id[i] = eid
self.gn[i] = gn
self.cm[i] = cm
alpha = integer_or_double(card, len(card) - 1, 'alpha')
if isinstance(alpha, float):
# the last field is not part of Gmi
self.alpha[i] = alpha
n = 1
else:
# the last field is part of Gmi
n = 0
#self.alpha[i] = 0.0 # we don't need to set alpha
j = 4
gmis = []
for k in range(len(card) - 4 - n):
gmi = integer(card, j + k, 'Gm%i' % (k + 1))
#print('GM%i = %s' % (k + 1, gmi))
gmis.append(gmi)
self.gmi[i] = gmis
self.i += 1
def __init__(self, card=None, data=None, comment=''):
Constraint.__init__(self, card, data)
if comment:
self._comment = comment
self.IDs = [] ## TODO: IDs reference nodes???
self.Cs = []
if card:
# TODO: remove fields...
fields = card.fields(1)
nfields = len(card)
assert len(card) > 1, card
nterms = int(nfields / 2.)
n = 1
for i in range(nterms):
nstart = 1 + 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:
fields = data
for i in range(0, len(fields), 2):
self.IDs.append(fields[i])
self.Cs.append(fields[i + 1])
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)
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
self.IDs = []
self.Cs = []
if card:
fields = card.fields(1)
nfields = len(card)
assert len(card) > 1, card
nterms = int(nfields / 2.)
n = 1
for i in range(nterms):
nstart = 1 + 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:
fields = data
for i in range(0, len(fields), 2):
self.IDs.append(fields[i])
self.Cs.append(fields[i + 1])
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)
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 add(self, card, comment=''):
#self.model.log.debug('RBE2.add')
i = self.i
#if comment:
#self._comment = comment
eid = integer(card, 1, 'element_id')
gn = integer(card, 2, 'gn')
cm = components_or_blank(card, 3, 'cm')
#assert gn is not None, 'gn=%s' % self.gn
#assert cm is not None, 'cm=%s' % self.cm
self.element_id[i] = eid
self.gn[i] = gn
self.cm[i] = cm
alpha = integer_or_double(card, len(card) - 1, 'alpha')
if isinstance(alpha, float):
# the last field is not part of Gmi
self.alpha[i] = alpha
n = 1
else:
# the last field is part of Gmi
n = 0
#self.alpha[i] = 0.0 # we don't need to set alpha
j = 4
Gmi = []
for k in range(len(card) - 4 - n):
gmi = integer(card, j + k, 'Gm%i' % (k + 1))
#print('GM%i = %s' % (k + 1, gmi))
Gmi.append(gmi)
self.gmi[i] = Gmi
self.i += 1
def __init__(self, card=None, data=None, comment=''):
"""
+-------+-----+-----+-----+------+-------+-----+-----+-----+
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+-------+-----+-----+-----+------+-------+-----+-----+-----+
| RBE2 | EID | GN | CM | GM1 | GM2 | GM3 | GM4 | GM5 |
+-------+-----+-----+-----+------+-------+-----+-----+-----+
| | GM6 | GM7 | GM8 | etc. | ALPHA |
+-------+-----+-----+-----+------+-------+
"""
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element identification number
self.eid = integer(card, 1, 'eid')
#: Identification number of grid point to which all six independent
#: degrees-of-freedom for the element are assigned. (Integer > 0)
self.gn = integer(card, 2, 'gn')
#: Component numbers of the dependent degrees-of-freedom in the
#: global coordinate system at grid points GMi. (Integers 1 through
#: 6 with no embedded blanks.)
self.cm = components_or_blank(card, 3, 'cm')
alpha = integer_or_double(card, len(card) - 1, 'alpha')
if isinstance(alpha, float):
#: Grid point identification numbers at which dependent
#: degrees-of-freedom are assigned. (Integer > 0)
self.alpha = alpha
# the last field is not part of Gmi
n = 1
else:
# the last field is part of Gmi
n = 0
self.alpha = 0.0
j = 4
self.Gmi = []
for i in range(len(card)-4-n):
gmi = integer(card, j + i, 'Gm%i' % (i + 1))
#print('gm%i = %s' % (i + 1, gmi))
self.Gmi.append(gmi)
else:
self.eid = data[0]
self.gn = data[1]
self.cm = data[2]
self.Gmi = data[3]
self.alpha = data[4]
print("eid=%s gn=%s cm=%s Gmi=%s alpha=%s"
% (self.eid, self.gn, self.cm, self.Gmi, self.alpha))
#raise NotImplementedError('RBE2 data...')
assert self.gn is not None, 'gn=%s' % self.gn
assert self.cm is not None, 'cm=%s' % self.cm
self.gn = str(self.gn)
self.cm = str(self.cm)
def __init__(self, card=None, data=None, comment=''):
"""
+-------+-----+-----+-----+------+-------+-----+-----+-----+
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+-------+-----+-----+-----+------+-------+-----+-----+-----+
| RBE2 | EID | GN | CM | GM1 | GM2 | GM3 | GM4 | GM5 |
+-------+-----+-----+-----+------+-------+-----+-----+-----+
| | GM6 | GM7 | GM8 | etc. | ALPHA |
+-------+-----+-----+-----+------+-------+
"""
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element identification number
self.eid = integer(card, 1, 'eid')
#: Identification number of grid point to which all six independent
#: degrees-of-freedom for the element are assigned. (Integer > 0)
self.gn = integer(card, 2, 'gn')
#: Component numbers of the dependent degrees-of-freedom in the
#: global coordinate system at grid points GMi. (Integers 1 through
#: 6 with no embedded blanks.)
self.cm = components_or_blank(card, 3, 'cm')
alpha = integer_or_double(card, len(card) - 1, 'alpha')
if isinstance(alpha, float):
#: Grid point identification numbers at which dependent
#: degrees-of-freedom are assigned. (Integer > 0)
self.alpha = alpha
# the last field is not part of Gmi
n = 1
else:
# the last field is part of Gmi
n = 0
self.alpha = 0.0
j = 4
self.Gmi = []
for i in range(len(card) - 4 - n):
gmi = integer(card, j + i, 'Gm%i' % (i + 1))
#print('gm%i = %s' % (i + 1, gmi))
self.Gmi.append(gmi)
else:
self.eid = data[0]
self.gn = data[1]
self.cm = data[2]
self.Gmi = data[3]
self.alpha = data[4]
print("eid=%s gn=%s cm=%s Gmi=%s alpha=%s" %
(self.eid, self.gn, self.cm, self.Gmi, self.alpha))
#raise NotImplementedError('RBE2 data...')
assert self.gn is not None, 'gn=%s' % self.gn
assert self.cm is not None, 'cm=%s' % self.cm
self.gn = str(self.gn)
self.cm = str(self.cm)
def __init__(self, card=None, data=None, comment=''):
Constraint.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Set identification number. (Integer > 0)
self.conid = integer(card, 1, 'conid')
#: Identification number of grid or scalar point. (Integer > 0)
self.gids = []
#: Component number. (Any one of the Integers 1 through 6 for grid
#: points; blank or zero for scalar points.)
self.constraints = []
#: Coefficient. (Real; Default = 0.0 except A1 must be nonzero.)
self.enforced = []
fields = card.fields(0)
nFields = len(fields) - 1
for iField in xrange(2, nFields, 8):
grid = integer(card, iField, 'gid'),
component = components_or_blank(card, iField + 1, 'constraint', 0) # scalar point
value = double_or_blank(card, iField + 2, 'enforced', 0.0)
self.gids.append(grid)
self.constraints.append(component)
self.enforced.append(value)
if iField + 3 > nFields:
break
grid = integer(card, iField + 3, 'gid')
component = components_or_blank(card, iField + 4, 'constraint', 0) # scalar point
value = double_or_blank(card, iField + 5, 'enforced')
self.gids.append(grid)
self.constraints.append(component)
self.enforced.append(value)
# reduce the size if there are duplicate Nones
#nConstraints = max(len(self.gids ),
# len(self.constraints),
# len(self.enforced ))
#self.gids = self.gids[ 0:nConstraints]
#self.constraints = self.constraints[0:nConstraints]
#self.enforced = self.enforced[ 0:nConstraints]
else:
msg = '%s has not implemented data parsing' % self.type
raise NotImplementedError(msg)
def __init__(self, card=None, data=None, comment=''):
Constraint.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Set identification number. (Integer > 0)
self.conid = integer(card, 1, 'conid')
#: Identification number of grid or scalar point. (Integer > 0)
self.gids = []
#: Component number. (Any one of the Integers 1 through 6 for grid
#: points; blank or zero for scalar points.)
self.constraints = []
#: Coefficient. (Real; Default = 0.0 except A1 must be nonzero.)
self.enforced = []
fields = card.fields(0)
nFields = len(fields) - 1
for iField in range(2, nFields, 8):
grid = integer(card, iField, 'gid'),
component = components_or_blank(card, iField + 1, 'constraint', 0) # scalar point
value = double_or_blank(card, iField + 2, 'enforced', 0.0)
self.gids.append(grid)
self.constraints.append(component)
self.enforced.append(value)
if iField + 3 > nFields:
break
grid = integer(card, iField + 3, 'gid')
component = components_or_blank(card, iField + 4, 'constraint', 0) # scalar point
value = double_or_blank(card, iField + 5, 'enforced')
self.gids.append(grid)
self.constraints.append(component)
self.enforced.append(value)
# reduce the size if there are duplicate Nones
#nConstraints = max(len(self.gids ),
# len(self.constraints),
# len(self.enforced ))
#self.gids = self.gids[ 0:nConstraints]
#self.constraints = self.constraints[0:nConstraints]
#self.enforced = self.enforced[ 0:nConstraints]
else:
msg = '%s has not implemented data parsing' % self.type
raise NotImplementedError(msg)
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 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, nOffset=0, data=None, comment=''):
if comment:
self._comment = comment
if card:
nOffset *= 3
self.sid = integer(card, 1, 'sid')
self.p = integer(card, 2 + nOffset, 'p')
self.c = components_or_blank(card, 3 + nOffset, 'c', 0)
self.scale = double(card, 4 + nOffset, 'scale')
else:
self.sid = data[0]
self.p = data[1]
self.c = data[2]
self.scale = data[3]
assert len(data) == 4, 'data = %s' % data
def __init__(self, card=None, data=None, comment=''):
"""
::
RBE2 EID GN CM GM1 GM2 GM3 GM4 GM5
GM6 GM7 GM8 -etc.- ALPHA
"""
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element identification number
self.eid = integer(card, 1, 'eid')
#: Identification number of grid point to which all six independent
#: degrees-of-freedom for the element are assigned. (Integer > 0)
self.gn = integer(card, 2, 'gn')
#: Component numbers of the dependent degrees-of-freedom in the
#: global coordinate system at grid points GMi. (Integers 1 through
#: 6 with no embedded blanks.)
self.cm = components_or_blank(card, 3, 'cm')
#: Grid point identification numbers at which dependent
#: degrees-of-freedom are assigned. (Integer > 0)
self.Gmi = fields(integer, card, 'Gm', i=4, j=len(card))
if len(self.Gmi) > 0 and isinstance(self.Gmi[-1], float):
#: Thermal expansion coefficient. See Remark 11.
#: (Real > 0.0 or blank)
self.alpha = self.Gmi.pop() # the last field is not part of
# Gmi
else:
self.alpha = 0.0
else:
self.eid = data[0]
self.gn = data[1]
self.cm = data[2]
self.Gmi = data[3]
self.alpha = data[4]
print("eid=%s gn=%s cm=%s Gmi=%s alpha=%s" %
(self.eid, self.gn, self.cm, self.Gmi, self.alpha))
raise NotImplementedError('RBE2 data...')
assert self.gn is not None, 'gm=%s' % self.gm
assert self.cm is not None, 'cm=%s' % self.cm
self.gn = str(self.gn)
self.cm = str(self.cm)
def __init__(self, card=None, data=None, comment=''):
"""
::
RBE2 EID GN CM GM1 GM2 GM3 GM4 GM5
GM6 GM7 GM8 -etc.- ALPHA
"""
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element identification number
self.eid = integer(card, 1, 'eid')
#: Identification number of grid point to which all six independent
#: degrees-of-freedom for the element are assigned. (Integer > 0)
self.gn = integer(card, 2, 'gn')
#: Component numbers of the dependent degrees-of-freedom in the
#: global coordinate system at grid points GMi. (Integers 1 through
#: 6 with no embedded blanks.)
self.cm = components_or_blank(card, 3, 'cm')
#: Grid point identification numbers at which dependent
#: degrees-of-freedom are assigned. (Integer > 0)
self.Gmi = fields(integer, card, 'Gm', i=4, j=len(card))
if len(self.Gmi) > 0 and isinstance(self.Gmi[-1], float):
#: Thermal expansion coefficient. See Remark 11.
#: (Real > 0.0 or blank)
self.alpha = self.Gmi.pop() # the last field is not part of
# Gmi
else:
self.alpha = 0.0
else:
self.eid = data[0]
self.gn = data[1]
self.cm = data[2]
self.Gmi = data[3]
self.alpha = data[4]
print("eid=%s gn=%s cm=%s Gmi=%s alpha=%s"
% (self.eid, self.gn, self.cm, self.Gmi, self.alpha))
raise NotImplementedError('RBE2 data...')
assert self.gn is not None, 'gm=%s' % self.gm
assert self.cm is not None, 'cm=%s' % self.cm
self.gn = str(self.gn)
self.cm = str(self.cm)
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')
#: Method of eigenvalue extraction. (Character: 'INV' for inverse
#: power method or 'SINV' for enhanced inverse power method.)
#: apparently it can also be blank...
self.method = string_or_blank(card, 2, 'method')
if self.method not in ['INV', 'SINV', None]:
msg = 'method must be INV or SINV. method=|%s|' % self.method
raise RuntimeError(msg)
#: Eigenvalue range of interest. (Real, L1 < L2)
self.L1 = double(card, 3, 'L1')
self.L2 = double(card, 4, 'L2')
if not self.L1 < self.L2:
msg = 'L1=%s L2=%s; L1<L2 is requried' % (self.L1, self.L2)
raise RuntimeError(msg)
#: Estimate of number of roots in positive range not used for
#: METHOD = 'SINV'. (Integer > 0)
self.nep = integer_or_blank(card, 5, 'nep', 0)
#: Desired number of positive and negative roots.
#: (Integer>0; Default = 3*NEP)
self.ndp = integer_or_blank(card, 6, 'ndp', 3 * self.nep)
self.ndn = integer_or_blank(card, 7, 'ndn', 3 * self.nep)
#: Method for normalizing eigenvectors.
#: ('MAX' or 'POINT';Default='MAX')
self.norm = string_or_blank(card, 9, 'norm', 'MAX')
if self.norm == 'POINT':
self.G = integer(card, 10, 'G')
self.C = components(card, 11, 'C')
else:
self.G = integer_or_blank(card, 10, 'G')
self.C = components_or_blank(card, 11, 'C')
assert len(card) <= 12, 'len(EIGB card) = %i' % len(card)
else:
raise NotImplementedError('EIGB')
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')
#: Method of eigenvalue extraction. (Character: 'INV' for inverse
#: power method or 'SINV' for enhanced inverse power method.)
self.method = string(card, 2, 'method')
if self.method not in ['INV', 'SINV']:
msg = 'method must be INV or SINV. method=|%s|' % self.method
raise RuntimeError(msg)
#: Eigenvalue range of interest. (Real, L1 < L2)
self.L1 = double(card, 3, 'L1')
self.L2 = double(card, 4, 'L2')
if not (self.L1 < self.L2):
msg = 'L1=%s L2=%s; L1<L2 is requried' % (self.L1, self.L2)
raise RuntimeError(msg)
#: Estimate of number of roots in positive range not used for
#: METHOD = 'SINV'. (Integer > 0)
self.nep = integer_or_blank(card, 5, 'nep', 0)
#: Desired number of positive and negative roots.
#: (Integer>0; Default = 3*NEP)
self.ndp = integer_or_blank(card, 6, 'ndp', 3 * self.nep)
self.ndn = integer_or_blank(card, 7, 'ndn', 3 * self.nep)
#: Method for normalizing eigenvectors.
#: ('MAX' or 'POINT';Default='MAX')
self.norm = string_or_blank(card, 9, 'norm', 'MAX')
if self.norm == 'POINT':
self.G = integer(card, 10, 'G')
self.C = components(card, 11, 'C')
else:
self.G = integer_or_blank(card, 10, 'G')
self.C = components_or_blank(card, 11, 'C')
assert len(card) <= 12, 'len(EIGB card) = %i' % len(card)
else:
raise NotImplementedError('EIGB')
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=''):
"""
::
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=''):
"""
::
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=''):
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
self.eid = integer(card, 1, 'eid')
self.Gni = []
self.Cni = []
#fields = card[2:]
iUm = card.index('UM')
if iUm > 0:
assert string(card, iUm, 'UM') == 'UM'
if isinstance(card[-1], float):
self.alpha = card.fields[-1].pop() # the last field is not part of fields
#nfields = len(card) - 1
else:
#nfields = len(card)
self.alpha = 0.
# loop till UM, no field9,field10
#print("iUm = %s" % iUm)
n = 1
i = 0
offset = 2
while offset + i < iUm - 1:
#print('field(%s) = %s' % (offset + i, card.field(offset + i)))
gni = integer_or_blank(card, offset + i, 'gn%i' % n)
cni = components_or_blank(card, offset + i + 1, 'cn%i' % n)
if gni:
#print("gni=%s cni=%s" % (gni ,cni))
self.Gni.append(gni)
self.Cni.append(cni)
n += 1
else:
assert cni is None
i += 2
#print('Gni =', self.Gni)
#print('Cni =', self.Cni)
self.Gmi = []
self.Cmi = []
# loop till alpha, no field9,field10
n = 1
offset = iUm + 1
i = 0
while offset + i < len(card): # dont grab alpha
gmi = integer_or_blank(card, offset + i, 'gm%i' % n)
cmi = components_or_blank(card, offset + i + 1, 'cm%i' % n)
if gmi:
#print("gmi=%s cmi=%s" % (gmi ,cmi))
self.Gmi.append(gmi)
self.Cmi.append(cmi)
n += 1
else:
assert cmi is None
i += 2
def __init__(self, card=None, data=None, comment=''):
"""
eid
refgrid
refc
WtCG_groups = [wt,ci,Gij]
Gmi
Cmi
alpha
"""
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
self.eid = integer(card, 1, 'eid')
blank(card, 2, 'blank')
self.refgrid = integer(card, 3, 'refgrid')
self.refc = components_or_blank(card, 4, 'refc')
#iUM = fields.index('UM')
fields = [field.upper() if isinstance(field, string_types) else field for field in card[5:]]
iOffset = 5
iWtMax = len(fields) + iOffset
try:
iAlpha = fields.index('ALPHA') + iOffset
iWtMax = iAlpha # the index to start parsing UM
iUmStop = iAlpha # the index to stop parsing UM
except ValueError:
iAlpha = None
iUmStop = iWtMax
#print("iAlpha = %s" % iAlpha)
try:
iUm = fields.index('UM') + iOffset
iWtMax = iUm
except ValueError:
iUm = None
#print("iAlpha=%s iUm=%s" % (iAlpha, iUm))
#print("iAlpha=%s iWtMax=%s" % (iAlpha, iWtMax))
#print("iUM = ", iUM)
self.WtCG_groups = []
i = iOffset
n = 1
while i < iWtMax:
Gij = []
wtname = 'wt' + str(n)
wt = double_or_blank(card, i, wtname)
if wt is not None:
cname = 'c'+str(n)
ci = components_or_blank(card, i + 1, cname)
#print("%s=%s %s=%s" % (wtname, wt, cname, ci))
i += 2
gij = 0
j = 0
while isinstance(gij, int) and i < iWtMax:
j += 1
gij_name = 'g%s,%s' % (n, j)
gij = integer_double_or_blank(card, i, gij_name)
if isinstance(gij, float):
break
#print("%s = %s" % (gij_name, gij))
if gij is not None:
Gij.append(gij)
i += 1
wtCG_group = [wt, ci, Gij]
self.WtCG_groups.append(wtCG_group)
#print('----finished a group=%r----' % wtCG_group)
else:
i += 1
self.Gmi = []
self.Cmi = []
#print("")
if iUm:
#print('UM = %s' % card.field(iUm)) # UM
i = iUm + 1
n = 1
#print("i=%s iUmStop=%s" % (i, iUmStop))
for j in range(i, iUmStop, 2):
gm_name = 'gm' + str(n)
cm_name = 'cm' + str(n)
gmi = integer_or_blank(card, j, gm_name)
if gmi is not None:
cmi = components(card, j + 1, cm_name)
#print "gmi=%s cmi=%s" % (gmi, cmi)
self.Gmi.append(gmi)
self.Cmi.append(cmi)
if iAlpha:
self.alpha = double_or_blank(card, iAlpha + 1, 'alpha')
else:
#: thermal expansion coefficient
self.alpha = 0.0
def __init__(self, card=None, data=None, comment=''):
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
self.eid = integer(card, 1, 'eid')
self.Gni = []
self.Cni = []
#fields = [interpret_value(field) for field in card[2:] ]
iUm = card.index('UM')
if iUm > 0:
assert string(card, iUm, 'UM') == 'UM'
#assert isinstance(card[-1], str), 'card[-1]=%r type=%s' %(card[-1], type(card[-1]))
alpha_last = integer_double_or_string(card, -1, 'alpha_last')
if isinstance(alpha_last, float):
self.alpha = alpha_last
card.pop() # remove the last field so len(card) will not include alpha
else:
self.alpha = 0.
# loop till UM, no field9,field10
#print("iUm = %s" % iUm)
n = 1
i = 0
offset = 2
while offset + i < iUm - 1:
#print('field(%s) = %s' % (offset + i, card.field(offset + i)))
gni = integer_or_blank(card, offset + i, 'gn%i' % n)
cni = components_or_blank(card, offset + i + 1, 'cn%i' % n)
if gni:
#print("gni=%s cni=%s" % (gni ,cni))
self.Gni.append(gni)
self.Cni.append(cni)
n += 1
else:
assert cni is None
i += 2
#print('Gni =', self.Gni)
#print('Cni =', self.Cni)
self.Gmi = []
self.Cmi = []
# loop till alpha, no field9,field10
n = 1
offset = iUm + 1
i = 0
while offset + i < len(card): # dont grab alpha
gmi = integer_or_blank(card, offset + i, 'gm%i' % n)
cmi = components_or_blank(card, offset + i + 1, 'cm%i' % n)
if gmi:
#print("gmi=%s cmi=%s" % (gmi ,cmi))
self.Gmi.append(gmi)
self.Cmi.append(cmi)
n += 1
else:
assert cmi is None
i += 2
def add(self, card, comment=''):
#self.model.log.debug('RBE2.add')
i = self.i
#if comment:
#self._comment = comment
eid = integer(card, 1, 'element_id')
#if comment:
#self._comment = comment
self.element_id[i] = integer(card, 1, 'eid')
blank(card, 2, 'blank')
self.refgrid[i] = integer(card, 3, 'refgrid')
self.refc[i] = components_or_blank(card, 4, 'refc', 0)
#iUM = fields.index('UM')
fields = [field.upper() if isinstance(field, string_types) else field for field in card[5:]]
iOffset = 5
iWtMax = len(fields) + iOffset
try:
iAlpha = fields.index('ALPHA') + iOffset
iWtMax = iAlpha # the index to start parsing UM
iUmStop = iAlpha # the index to stop parsing UM
except ValueError:
iAlpha = None
iUmStop = iWtMax
#print("iAlpha = %s" % iAlpha)
try:
iUm = fields.index('UM') + iOffset
iWtMax = iUm
except ValueError:
iUm = None
#print("iAlpha=%s iUm=%s" % (iAlpha, iUm))
#print("iAlpha=%s iWtMax=%s" % (iAlpha, iWtMax))
#print("iUM = %s" % iUM)
WtCG_groups = []
i = iOffset
n = 1
while i < iWtMax:
Gij = []
wtname = 'wt' + str(n)
wt = double_or_blank(card, i, wtname)
if wt is not None:
cname = 'c'+str(n)
ci = components_or_blank(card, i + 1, cname)
#print("%s=%s %s=%s" % (wtname, wt, cname, ci))
i += 2
gij = 0
j = 0
while isinstance(gij, int) and i < iWtMax:
j += 1
gij_name = 'g%s,%s' % (n, j)
gij = integer_double_or_blank(card, i, gij_name)
if isinstance(gij, float):
break
#print("%s = %s" % (gij_name, gij))
if gij is not None:
Gij.append(gij)
i += 1
wtCG_group = [wt, ci, Gij]
WtCG_groups.append(wtCG_group)
#print('----finished a group=%r----' % wtCG_group)
else:
i += 1
self.WtCG_groups[i] = WtCG_groups
Gmi = []
Cmi = []
#print("")
if iUm:
#print('UM = %s' % card.field(iUm)) # UM
i = iUm + 1
n = 1
#print("i=%s iUmStop=%s" % (i, iUmStop))
for j in range(i, iUmStop, 2):
gm_name = 'gm' + str(n)
cm_name = 'cm' + str(n)
gmi = integer_or_blank(card, j, gm_name)
if gmi is not None:
cmi = components(card, j + 1, cm_name)
#print("gmi=%s cmi=%s" % (gmi, cmi))
Gmi.append(gmi)
Cmi.append(cmi)
self.Gmi[i] = Gmi
self.Cmi[i] = Cmi
if iAlpha:
alpha = double_or_blank(card, iAlpha + 1, 'alpha', 0.0)
else:
alpha = 0.0
self.alpha[i] = alpha
def test_components_or_blank_02(self):
# single ints
val = components_or_blank(BDFCard([0]), 0, "field", "default")
self.assertEqual(val, "0")
val = components_or_blank(BDFCard([1]), 0, "field", "default")
self.assertEqual(val, "1")
# single strings
val = components_or_blank(BDFCard(["0"]), 0, "field", "default")
self.assertEqual(val, "0")
val = components_or_blank(BDFCard(["1"]), 0, "field", "default")
self.assertEqual(val, "1")
# double ints
val = components_or_blank(BDFCard(["123"]), 0, "field", "default")
self.assertEqual(val, "123")
val = components_or_blank(BDFCard([123]), 0, "field", "default")
self.assertEqual(val, "123")
val = components_or_blank(BDFCard([321]), 0, "field", "default")
self.assertEqual(val, "123")
# embedded whiteshape
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["12 3"]), 0, "field", "default")
# all numbers
val = components_or_blank(BDFCard(["123456"]), 0, "field", "default")
self.assertEqual(val, "123456")
# invalid 0's defined with numbers
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["0123456"]), 0, "field", "default")
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["01"]), 0, "field", "default")
# doubles
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["4524"]), 0, "field", "default")
# only 0 to 6
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["7"]), 0, "field", "default")
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard([7]), 0, "field", "default")
# dumb input
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["4.0"]), 0, "field", "default")
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["-4.0"]), 0, "field", "default")
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["asdf"]), 0, "field", "default")
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(["-1"]), 0, "field", "default")
# blank
val = components_or_blank(BDFCard([" "]), 0, "field", "default")
self.assertEqual(val, "default")
val = components_or_blank(BDFCard([None]), 0, "field", "default")
self.assertEqual(val, "default")
def __init__(self, card=None, data=None, comment=''):
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
self.eid = integer(card, 1, 'eid')
self.Gni = []
self.Cni = []
#fields = [interpret_value(field) for field in card[2:] ]
iUm = card.index('UM')
if iUm > 0:
assert string(card, iUm, 'UM') == 'UM'
#assert isinstance(card[-1], str), 'card[-1]=%r type=%s' %(card[-1], type(card[-1]))
alpha_last = integer_double_or_string(card, -1, 'alpha_last')
if isinstance(alpha_last, float):
self.alpha = alpha_last
card.pop(
) # remove the last field so len(card) will not include alpha
else:
self.alpha = 0.
# loop till UM, no field9,field10
#print("iUm = %s" % iUm)
n = 1
i = 0
offset = 2
while offset + i < iUm - 1:
#print('field(%s) = %s' % (offset + i, card.field(offset + i)))
gni = integer_or_blank(card, offset + i, 'gn%i' % n)
cni = components_or_blank(card, offset + i + 1, 'cn%i' % n)
if gni:
#print("gni=%s cni=%s" % (gni ,cni))
self.Gni.append(gni)
self.Cni.append(cni)
n += 1
else:
assert cni is None
i += 2
#print('Gni =', self.Gni)
#print('Cni =', self.Cni)
self.Gmi = []
self.Cmi = []
# loop till alpha, no field9,field10
n = 1
offset = iUm + 1
i = 0
while offset + i < len(card): # dont grab alpha
gmi = integer_or_blank(card, offset + i, 'gm%i' % n)
cmi = components_or_blank(card, offset + i + 1, 'cm%i' % n)
if gmi:
#print("gmi=%s cmi=%s" % (gmi ,cmi))
self.Gmi.append(gmi)
self.Cmi.append(cmi)
n += 1
else:
assert cmi is None
i += 2
def __init__(self, card=None, data=None, comment=''):
Constraint.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Set identification number. (Integer > 0)
self.conid = integer(card, 1, 'conid')
#: Identification number of grid or scalar point. (Integer > 0)
self.gids = []
#: Component number. (Any one of the Integers 1 through 6 for grid
#: points; blank or zero for scalar points.)
self.constraints = []
#: Coefficient. (Real; Default = 0.0 except A1 must be nonzero.)
self.enforced = []
fields = card.fields(0)
nfields = len(fields)
i = 1
for ifield in range(2, nfields, 8):
grid = integer(card, ifield, 'G%i' % i)
component = components_or_blank(card, ifield + 1,
'constraint%i' % i,
0) # scalar point
if i == 1:
value = double(card, ifield + 2, 'enforced%i' % i)
if value == 0.0:
raise RuntimeError(
'enforced1 must be nonzero; value=%r' % value)
else:
value = double_or_blank(card, ifield + 2, 'enforced%i' % i,
0.0)
self.gids.append(grid)
self.constraints.append(component)
self.enforced.append(value)
i += 1
if ifield + 4 > nfields and i != 2:
# if G2 is empty (it's ifield+4 because nfields is length based and not loop friendly)
break
grid = integer(card, ifield + 3, 'G%i' % i)
component = components_or_blank(card, ifield + 4,
'constraint%i' % i,
0) # scalar point
value = double_or_blank(card, ifield + 5, 'enforced%i' % i)
self.gids.append(grid)
self.constraints.append(component)
self.enforced.append(value)
i += 1
# reduce the size if there are duplicate Nones
#nConstraints = max(len(self.gids ),
# len(self.constraints),
# len(self.enforced ))
#self.gids = self.gids[ 0:nConstraints]
#self.constraints = self.constraints[0:nConstraints]
#self.enforced = self.enforced[ 0:nConstraints]
else:
msg = '%s has not implemented data parsing' % self.type
raise NotImplementedError(msg)
def __init__(self, card=None, data=None, comment=''):
"""
eid
refgrid
refc
WtCG_groups = [wt,ci,Gij]
Gmi
Cmi
alpha
"""
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
self.eid = integer(card, 1, 'eid')
blank(card, 2, 'blank')
self.refgrid = integer(card, 3, 'refgrid')
self.refc = components_or_blank(card, 4, 'refc')
#iUM = fields.index('UM')
fields = [
field.upper() if isinstance(field, string_types) else field
for field in card[5:]
]
iOffset = 5
iWtMax = len(fields) + iOffset
try:
iAlpha = fields.index('ALPHA') + iOffset
iWtMax = iAlpha # the index to start parsing UM
iUmStop = iAlpha # the index to stop parsing UM
except ValueError:
iAlpha = None
iUmStop = iWtMax
#print("iAlpha = %s" % iAlpha)
try:
iUm = fields.index('UM') + iOffset
iWtMax = iUm
except ValueError:
iUm = None
#print("iAlpha=%s iUm=%s" % (iAlpha, iUm))
#print("iAlpha=%s iWtMax=%s" % (iAlpha, iWtMax))
#print("iUM = ", iUM)
self.WtCG_groups = []
i = iOffset
n = 1
while i < iWtMax:
Gij = []
wtname = 'wt' + str(n)
wt = double_or_blank(card, i, wtname)
if wt is not None:
cname = 'c' + str(n)
ci = components_or_blank(card, i + 1, cname)
#print("%s=%s %s=%s" % (wtname, wt, cname, ci))
i += 2
gij = 0
j = 0
while isinstance(gij, int) and i < iWtMax:
j += 1
gij_name = 'g%s,%s' % (n, j)
gij = integer_double_or_blank(card, i, gij_name)
if isinstance(gij, float):
break
#print("%s = %s" % (gij_name, gij))
if gij is not None:
Gij.append(gij)
i += 1
wtCG_group = [wt, ci, Gij]
self.WtCG_groups.append(wtCG_group)
#print('----finished a group=%r----' % wtCG_group)
else:
i += 1
self.Gmi = []
self.Cmi = []
#print("")
if iUm:
#print('UM = %s' % card.field(iUm)) # UM
i = iUm + 1
n = 1
#print("i=%s iUmStop=%s" % (i, iUmStop))
for j in range(i, iUmStop, 2):
gm_name = 'gm' + str(n)
cm_name = 'cm' + str(n)
gmi = integer_or_blank(card, j, gm_name)
if gmi is not None:
cmi = components(card, j + 1, cm_name)
#print "gmi=%s cmi=%s" % (gmi, cmi)
self.Gmi.append(gmi)
self.Cmi.append(cmi)
if iAlpha:
self.alpha = double_or_blank(card, iAlpha + 1, 'alpha')
else:
#: thermal expansion coefficient
self.alpha = 0.0
def __init__(self, card=None, data=None, comment=''):
RigidElement.__init__(self, card, data)
if comment:
self._comment = comment
self.eid = integer(card, 1, 'eid')
self.Gni = []
self.Cni = []
#fields = card[2:]
iUm = card.index('UM')
if iUm > 0:
assert string(card, iUm, 'UM') == 'UM'
if isinstance(card[-1], float):
self.alpha = card.fields[-1].pop(
) # the last field is not part of fields
#nfields = len(card) - 1
else:
#nfields = len(card)
self.alpha = 0.
# loop till UM, no field9,field10
#print("iUm = %s" % iUm)
n = 1
i = 0
offset = 2
while offset + i < iUm - 1:
#print('field(%s) = %s' % (offset + i, card.field(offset + i)))
gni = integer_or_blank(card, offset + i, 'gn%i' % n)
cni = components_or_blank(card, offset + i + 1, 'cn%i' % n)
if gni:
#print("gni=%s cni=%s" % (gni ,cni))
self.Gni.append(gni)
self.Cni.append(cni)
n += 1
else:
assert cni is None
i += 2
#print('Gni =', self.Gni)
#print('Cni =', self.Cni)
self.Gmi = []
self.Cmi = []
# loop till alpha, no field9,field10
n = 1
offset = iUm + 1
i = 0
while offset + i < len(card): # dont grab alpha
gmi = integer_or_blank(card, offset + i, 'gm%i' % n)
cmi = components_or_blank(card, offset + i + 1, 'cm%i' % n)
if gmi:
#print("gmi=%s cmi=%s" % (gmi ,cmi))
self.Gmi.append(gmi)
self.Cmi.append(cmi)
n += 1
else:
assert cmi is None
i += 2
def test_components_or_blank_02(self):
# single ints
val = components_or_blank(BDFCard([0]), 0, 'field', 'default')
self.assertEquals(val, '0')
val = components_or_blank(BDFCard([1]), 0, 'field', 'default')
self.assertEquals(val, '1')
# single strings
val = components_or_blank(BDFCard(['0']), 0, 'field', 'default')
self.assertEquals(val, '0')
val = components_or_blank(BDFCard(['1']), 0, 'field', 'default')
self.assertEquals(val, '1')
# double ints
val = components_or_blank(BDFCard(['123']), 0, 'field', 'default')
self.assertEquals(val, '123')
val = components_or_blank(BDFCard([123]), 0, 'field', 'default')
self.assertEquals(val, '123')
val = components_or_blank(BDFCard([321]), 0, 'field', 'default')
self.assertEquals(val, '123')
# embedded whiteshape
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['12 3']), 0, 'field', 'default')
# all numbers
val = components_or_blank(BDFCard(['123456']), 0, 'field', 'default')
self.assertEquals(val, '123456')
# invalid 0's defined with numbers
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['0123456']), 0, 'field', 'default')
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['01']), 0, 'field', 'default')
# doubles
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['4524']), 0, 'field', 'default')
# only 0 to 6
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['7']), 0, 'field', 'default')
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard([7]), 0, 'field', 'default')
# dumb input
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['4.0']), 0, 'field', 'default')
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['-4.0']), 0, 'field', 'default')
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['asdf']), 0, 'field', 'default')
with self.assertRaises(SyntaxError):
val = components_or_blank(BDFCard(['-1']), 0, 'field', 'default')
# blank
val = components_or_blank(BDFCard([' ']), 0, 'field', 'default')
self.assertEquals(val, 'default')
val = components_or_blank(BDFCard([None]), 0, 'field', 'default')
self.assertEquals(val, 'default')
