def _readPCOMP(self, data, n):
"""
PCOMP(2706,27,287) - the marker for Record 22
"""
nproperties = 0
n2 = n
s1 = Struct(b'2i3fi2f')
s2 = Struct(b'i2fi')
while n2 < n: #len(data) >= 32: # 8*4 - dynamic
#print("len(data) = %s" % len(data))
#print(self.print_block(data[0:200]))
isSymmetrical = 'NO'
eData = data[n:n + 32]
out = s1.unpack(eData)
self.binary_debug.write(' PCOMP=%s\n' % str(out))
(
pid,
nLayers,
z0,
nsm,
sb,
ft,
Tref,
ge,
) = out
eData = data[n:n + 16 * (nLayers)]
Mid = []
T = []
Theta = []
Sout = []
if nLayers < 0:
isSymmetrical = 'YES'
nLayers = abs(nLayers)
#print("nLayers = ",nLayers)
assert 0 < nLayers < 100, 'pid=%s nLayers=%s z0=%s nms=%s sb=%s ft=%s Tref=%s ge=%s' % (
pid, nLayers, z0, nsm, sb, ft, Tref, ge)
idata = 0
for ilayer in range(nLayers):
(mid, t, theta, sout) = s2.unpack(eData[idata:idata + 16])
Mid.append(mid)
T.append(t)
Theta.append(theta)
Sout.append(sout)
idata += 16
dataIn = [
pid, z0, nsm, sb, ft, Tref, ge, isSymmetrical, Mid, T, Theta,
Sout
]
#print("PCOMP = %s" % (dataIn))
prop = PCOMP(None, dataIn)
self.addOp2Property(prop)
nproperties += 1
self.card_count['PCOMP'] = nproperties
return n
def readPCOMP(self, data):
"""
PCOMP(2706,27,287) - the marker for Record 22
"""
#print "reading PCOMP"
while len(data) >= 32: # 8*4 - dynamic
#print "len(data) = ",len(data)
#print self.print_block(data[0:200])
isSymmetrical = 'NO'
eData = data[:32]
data = data[32:]
out = unpack('2i3fi2f', eData)
(
pid,
nLayers,
z0,
nsm,
sb,
ft,
Tref,
ge,
) = out
eData = data[:16 * (nLayers)]
data = data[16 * (nLayers):]
Mid = []
T = []
Theta = []
Sout = []
if nLayers < 0:
isSymmetrical = 'YES'
nLayers = abs(nLayers)
#print "nLayers = ",nLayers
assert 0 < nLayers < 100, 'pid=%s nLayers=%s z0=%s nms=%s sb=%s ft=%s Tref=%s ge=%s' % (
pid, nLayers, z0, nsm, sb, ft, Tref, ge)
for n in range(nLayers):
#print "len(eData) = ",len(eData)
(mid, t, theta, sout) = unpack('i2fi', eData[0:16])
Mid.append(mid)
T.append(t)
Theta.append(theta)
Sout.append(sout)
eData = eData[16:]
dataIn = [
pid, z0, nsm, sb, ft, Tref, ge, isSymmetrical, Mid, T, Theta,
Sout
]
#print "PCOMP = %s" %(dataIn)
prop = PCOMP(None, dataIn)
self.addOp2Property(prop)
def _read_pcomp(self, data, n):
"""
PCOMP(2706,27,287) - the marker for Record 22
"""
nproperties = 0
s1 = Struct(b(self._endian + '2i3fi2f'))
s2 = Struct(b(self._endian + 'i2fi'))
ndata = len(data)
while n < (ndata - 32):
out = s1.unpack(data[n:n+32])
(pid, nlayers, z0, nsm, sb, ft, Tref, ge) = out
if self.debug:
self.log.debug('PCOMP pid=%s nlayers=%s z0=%s nsm=%s sb=%s ft=%s Tref=%s ge=%s' % tuple(out))
assert isinstance(nlayers, int), out
n += 32
Mid = []
T = []
Theta = []
Sout = []
# None, 'SYM', 'MEM', 'BEND', 'SMEAR', 'SMCORE', 'NO'
is_symmetrical = 'NO'
if nlayers < 0:
is_symmetrical = 'SYM'
nlayers = abs(nlayers)
assert nlayers > 0, out
assert 0 < nlayers < 100, 'pid=%s nlayers=%s z0=%s nms=%s sb=%s ft=%s Tref=%s ge=%s' % (
pid, nlayers, z0, nsm, sb, ft, Tref, ge)
for ilayer in range(nlayers):
(mid, t, theta, sout) = s2.unpack(data[n:n+16])
Mid.append(mid)
T.append(t)
Theta.append(theta)
Sout.append(sout)
if self.is_debug_file:
self.binary_debug.write(' mid=%s t=%s theta=%s sout=%s' % (mid, t, theta, sout))
n += 16
data_in = [
pid, z0, nsm, sb, ft, Tref, ge,
is_symmetrical, Mid, T, Theta, Sout]
prop = PCOMP.add_op2_data(data_in)
self._add_op2_property(prop)
nproperties += 1
self.card_count['PCOMP'] = nproperties
return n
def test_pcomp_02(self):
"""
symmetrical, nsm=0.0 and nsm=1.0
"""
pid = 1
z0 = 0.
nsm = 0.
sb = 0.
ft = 0.
tref = 0.
ge = 0.
lam = 'SYM' # isSymmetrical SYM
Mid = [1, 2, 3]
theta = [0., 10., 20.]
T = [.1, .2, .3]
sout = [1, 1, 0] # 0-NO, 1-YES
data = [pid, z0, nsm, sb, ft, tref, ge, lam, Mid, T, theta, sout]
p = PCOMP.add_op2_data(data)
self.assertTrue(p.isSymmetrical())
self.assertEqual(p.nPlies(), 6)
self.assertAlmostEqual(p.Thickness(), 1.2)
self.assertAlmostEqual(p.Thickness(0), 0.1)
self.assertAlmostEqual(p.Thickness(1), 0.2)
self.assertAlmostEqual(p.Thickness(2), 0.3)
self.assertAlmostEqual(p.Thickness(3), 0.1)
self.assertAlmostEqual(p.Thickness(4), 0.2)
self.assertAlmostEqual(p.Thickness(5), 0.3)
with self.assertRaises(IndexError):
p.Thickness(6)
self.assertAlmostEqual(p.Theta(0), 0.)
self.assertAlmostEqual(p.Theta(1), 10.)
self.assertAlmostEqual(p.Theta(2), 20.)
self.assertAlmostEqual(p.Theta(3), 0.)
self.assertAlmostEqual(p.Theta(4), 10.)
self.assertAlmostEqual(p.Theta(5), 20.)
with self.assertRaises(IndexError):
p.Theta(6)
self.assertEqual(p.Mid(0), 1)
self.assertEqual(p.Mid(1), 2)
self.assertEqual(p.Mid(2), 3)
self.assertEqual(p.Mid(3), 1)
self.assertEqual(p.Mid(4), 2)
self.assertEqual(p.Mid(5), 3)
with self.assertRaises(IndexError):
p.Mid(6)
self.assertEqual(p.Mids(), [1, 2, 3, 1, 2, 3])
self.assertEqual(p.sout(0), 'YES')
self.assertEqual(p.sout(1), 'YES')
self.assertEqual(p.sout(2), 'NO')
self.assertEqual(p.sout(3), 'YES')
self.assertEqual(p.sout(4), 'YES')
self.assertEqual(p.sout(5), 'NO')
with self.assertRaises(IndexError):
p.sout(6)
mid = 1
E = None
G = None
nu = None
rho = 1.0
a = None
St = None
Sc = None
Ss = None
Mcsid = None
mat1 = [mid, E, G, nu, rho, a, tref, ge, St, Sc, Ss, Mcsid]
with self.assertRaises(ValueError):
m = MAT1.add_op2_data(mat1)
G = 42.
mat1 = [mid, E, G, nu, rho, a, tref, ge, St, Sc, Ss, Mcsid]
m = MAT1.add_op2_data(mat1)
for iply in range(len(p.plies)):
mid = p.plies[iply][0]
p.mids[iply] = m # MAT1
p.mids_ref = p.mids
#Rho
self.assertAlmostEqual(p.Rho(0), 1.0)
self.assertAlmostEqual(p.Rho(1), 1.0)
self.assertAlmostEqual(p.Rho(2), 1.0)
self.assertAlmostEqual(p.Rho(3), 1.0)
self.assertAlmostEqual(p.Rho(4), 1.0)
self.assertAlmostEqual(p.Rho(5), 1.0)
with self.assertRaises(IndexError):
p.Rho(6)
# MassPerArea
self.assertAlmostEqual(p.MassPerArea(), 1.2)
self.assertAlmostEqual(p.MassPerArea(0), 0.1)
self.assertAlmostEqual(p.MassPerArea(1), 0.2)
self.assertAlmostEqual(p.MassPerArea(2), 0.3)
self.assertAlmostEqual(p.MassPerArea(3), 0.1)
self.assertAlmostEqual(p.MassPerArea(4), 0.2)
self.assertAlmostEqual(p.MassPerArea(5), 0.3)
with self.assertRaises(IndexError):
p.MassPerArea(6)
self.assertEqual(p.Nsm(), 0.0)
#----------------------
# change the nsm to 1.0
p.nsm = 1.0
self.assertEqual(p.Nsm(), 1.0)
# MassPerArea
self.assertAlmostEqual(p.MassPerArea(), 2.2)
self.assertAlmostEqual(p.MassPerArea(0, method='nplies'), 0.1+1/6.)
self.assertAlmostEqual(p.MassPerArea(1, method='nplies'), 0.2+1/6.)
self.assertAlmostEqual(p.MassPerArea(2, method='nplies'), 0.3+1/6.)
self.assertAlmostEqual(p.MassPerArea(3, method='nplies'), 0.1+1/6.)
self.assertAlmostEqual(p.MassPerArea(4, method='nplies'), 0.2+1/6.)
self.assertAlmostEqual(p.MassPerArea(5, method='nplies'), 0.3+1/6.)
with self.assertRaises(IndexError):
p.MassPerArea(6)
def test_pcomp_01(self):
"""
asymmetrical, nsm=0.0 and nsm=1.0
"""
#self.pid = data[0]
#self.z0 = data[1]
#self.nsm = data[2]
#self.sb = data[3]
#self.ft = data[4]
#self.TRef = data[5]
#self.ge = data[6]
#self.lam = data[7]
#Mid = data[8]
#T = data[9]
#Theta = data[10]
#Sout = data[11]
pid = 1
z0 = 0.
nsm = 0.
sb = 0.
ft = 0.
tref = 0.
ge = 0.
lam = 'NO' # isSymmetrical YES/NO
Mid = [1, 2, 3]
theta = [0., 10., 20.]
T = [.1, .2, .3]
sout = [1, 1, 0] # 0-NO, 1-YES
data = [pid, z0, nsm, sb, ft, tref, ge, lam, Mid, T, theta, sout]
p = PCOMP.add_op2_data(data)
self.assertFalse(p.isSymmetrical())
self.assertEqual(p.nPlies(), 3)
self.assertAlmostEqual(p.Thickness(), 0.6)
self.assertAlmostEqual(p.Thickness(0), 0.1)
self.assertAlmostEqual(p.Thickness(1), 0.2)
self.assertAlmostEqual(p.Thickness(2), 0.3)
with self.assertRaises(IndexError):
p.Thickness(3)
self.assertAlmostEqual(p.Theta(0), 0.)
self.assertAlmostEqual(p.Theta(1), 10.)
self.assertAlmostEqual(p.Theta(2), 20.)
with self.assertRaises(IndexError):
p.Theta(3)
self.assertEqual(p.Mid(0), 1)
self.assertEqual(p.Mid(1), 2)
self.assertEqual(p.Mid(2), 3)
with self.assertRaises(IndexError):
p.Mid(3)
self.assertEqual(p.Mids(), [1, 2, 3])
self.assertEqual(p.sout(0), 'YES')
self.assertEqual(p.sout(1), 'YES')
self.assertEqual(p.sout(2), 'NO')
with self.assertRaises(IndexError):
p.sout(3)
# material...
#self.mid = data[0]
#self.e = data[1]
#self.g = data[2]
#self.nu = data[3]
#self.rho = data[4]
#self.a = data[5]
#self.TRef = data[6]
#self.ge = data[7]
#self.St = data[8]
#self.Sc = data[9]
#self.Ss = data[10]
#self.Mcsid = data[11]
mid = 1
E = None
G = None
nu = None
rho = 1.0
a = None
St = None
Sc = None
Ss = None
Mcsid = None
mat1 = [mid, E, G, nu, rho, a, tref, ge, St, Sc, Ss, Mcsid]
with self.assertRaises(ValueError):
m = MAT1.add_op2_data(mat1)
G = 42.
mat1 = [mid, E, G, nu, rho, a, tref, ge, St, Sc, Ss, Mcsid]
m = MAT1.add_op2_data(mat1)
for iply in range(len(p.plies)):
mid = p.plies[iply][0]
p.mids[iply] = m # MAT1
#p.mids = [m, m, m]
p.mids_ref = p.mids
#Rho
self.assertAlmostEqual(p.Rho(0), 1.0)
self.assertAlmostEqual(p.Rho(1), 1.0)
self.assertAlmostEqual(p.Rho(2), 1.0)
with self.assertRaises(IndexError):
p.Rho(3)
# MassPerArea
self.assertAlmostEqual(p.MassPerArea(), 0.6)
self.assertAlmostEqual(p.MassPerArea(0), 0.1)
self.assertAlmostEqual(p.MassPerArea(1), 0.2)
self.assertAlmostEqual(p.MassPerArea(2), 0.3)
with self.assertRaises(IndexError):
p.MassPerArea(3)
#----------------------
# change the nsm to 1.0
p.nsm = 1.0
self.assertEqual(p.Nsm(), 1.0)
# MassPerArea
self.assertAlmostEqual(p.MassPerArea(), 1.6)
self.assertAlmostEqual(p.MassPerArea(0, method='nplies'), 0.1+1/3.)
self.assertAlmostEqual(p.MassPerArea(1, method='nplies'), 0.2+1/3.)
self.assertAlmostEqual(p.MassPerArea(2, method='nplies'), 0.3+1/3.)
self.assertAlmostEqual(p.MassPerArea(0, method='rho*t'), 0.1+1/6.)
self.assertAlmostEqual(p.MassPerArea(1, method='rho*t'), 0.2+2/6.)
self.assertAlmostEqual(p.MassPerArea(2, method='rho*t'), 0.3+3/6.)
self.assertAlmostEqual(p.MassPerArea(0, method='t'), 0.1+1/6.)
self.assertAlmostEqual(p.MassPerArea(1, method='t'), 0.2+2/6.)
self.assertAlmostEqual(p.MassPerArea(2, method='t'), 0.3+3/6.)
with self.assertRaises(IndexError):
p.MassPerArea(3, method='nplies')
z = p.get_z_locations()
z_expected = array([0., T[0], T[0]+T[1], T[0]+T[1]+T[2]])
for za, ze in zip(z, z_expected):
self.assertAlmostEqual(za, ze)
#z0 =
p.z0 = 1.0
z_expected = 1.0 + z_expected
z = p.get_z_locations()
for za, ze in zip(z, z_expected):
self.assertAlmostEqual(za, ze)
def test_pcomp_02(self):
"""
symmetrical, nsm=0.0 and nsm=1.0
"""
pid = 1
z0 = 0.
nsm = 0.
sb = 0.
ft = 0.
tref = 0.
ge = 0.
lam = 'SYM' # is_symmetrical SYM
Mid = [1, 2, 3]
theta = [0., 10., 20.]
T = [.1, .2, .3]
sout = [1, 1, 0] # 0-NO, 1-YES
data = [pid, z0, nsm, sb, ft, tref, ge, lam, Mid, T, theta, sout]
p = PCOMP.add_op2_data(data)
self.assertTrue(p.is_symmetrical())
self.assertEqual(p.nplies, 6)
self.assertAlmostEqual(p.Thickness(), 1.2)
self.assertAlmostEqual(p.Thickness(0), 0.1)
self.assertAlmostEqual(p.Thickness(1), 0.2)
self.assertAlmostEqual(p.Thickness(2), 0.3)
self.assertAlmostEqual(p.Thickness(3), 0.1)
self.assertAlmostEqual(p.Thickness(4), 0.2)
self.assertAlmostEqual(p.Thickness(5), 0.3)
with self.assertRaises(IndexError):
p.Thickness(6)
self.assertAlmostEqual(p.Theta(0), 0.)
self.assertAlmostEqual(p.Theta(1), 10.)
self.assertAlmostEqual(p.Theta(2), 20.)
self.assertAlmostEqual(p.Theta(3), 0.)
self.assertAlmostEqual(p.Theta(4), 10.)
self.assertAlmostEqual(p.Theta(5), 20.)
with self.assertRaises(IndexError):
p.Theta(6)
self.assertEqual(p.Mid(0), 1)
self.assertEqual(p.Mid(1), 2)
self.assertEqual(p.Mid(2), 3)
self.assertEqual(p.Mid(3), 1)
self.assertEqual(p.Mid(4), 2)
self.assertEqual(p.Mid(5), 3)
with self.assertRaises(IndexError):
p.Mid(6)
self.assertEqual(p.Mids(), [1, 2, 3, 1, 2, 3])
self.assertEqual(p.sout(0), 'YES')
self.assertEqual(p.sout(1), 'YES')
self.assertEqual(p.sout(2), 'NO')
self.assertEqual(p.sout(3), 'YES')
self.assertEqual(p.sout(4), 'YES')
self.assertEqual(p.sout(5), 'NO')
with self.assertRaises(IndexError):
p.sout(6)
mid = 1
E = None
G = None
nu = None
rho = 1.0
a = None
St = None
Sc = None
Ss = None
mcsid = None
mat1 = [mid, E, G, nu, rho, a, tref, ge, St, Sc, Ss, mcsid]
with self.assertRaises(ValueError):
m = MAT1.add_op2_data(mat1)
G = 42.
mat1 = [mid, E, G, nu, rho, a, tref, ge, St, Sc, Ss, mcsid]
m = MAT1.add_op2_data(mat1)
for iply in range(len(p.plies)):
mid = p.plies[iply][0]
p.mids[iply] = m # MAT1
p.mids_ref = p.mids
#Rho
self.assertAlmostEqual(p.Rho(0), 1.0)
self.assertAlmostEqual(p.Rho(1), 1.0)
self.assertAlmostEqual(p.Rho(2), 1.0)
self.assertAlmostEqual(p.Rho(3), 1.0)
self.assertAlmostEqual(p.Rho(4), 1.0)
self.assertAlmostEqual(p.Rho(5), 1.0)
with self.assertRaises(IndexError):
p.Rho(6)
# MassPerArea
self.assertAlmostEqual(p.MassPerArea(), 1.2)
self.assertAlmostEqual(p.MassPerArea(0), 0.1)
self.assertAlmostEqual(p.MassPerArea(1), 0.2)
self.assertAlmostEqual(p.MassPerArea(2), 0.3)
self.assertAlmostEqual(p.MassPerArea(3), 0.1)
self.assertAlmostEqual(p.MassPerArea(4), 0.2)
self.assertAlmostEqual(p.MassPerArea(5), 0.3)
with self.assertRaises(IndexError):
p.MassPerArea(6)
self.assertEqual(p.Nsm(), 0.0)
#----------------------
# change the nsm to 1.0
p.nsm = 1.0
self.assertEqual(p.Nsm(), 1.0)
# MassPerArea
self.assertAlmostEqual(p.MassPerArea(), 2.2)
self.assertAlmostEqual(p.MassPerArea(0, method='nplies'), 0.1 + 1 / 6.)
self.assertAlmostEqual(p.MassPerArea(1, method='nplies'), 0.2 + 1 / 6.)
self.assertAlmostEqual(p.MassPerArea(2, method='nplies'), 0.3 + 1 / 6.)
self.assertAlmostEqual(p.MassPerArea(3, method='nplies'), 0.1 + 1 / 6.)
self.assertAlmostEqual(p.MassPerArea(4, method='nplies'), 0.2 + 1 / 6.)
self.assertAlmostEqual(p.MassPerArea(5, method='nplies'), 0.3 + 1 / 6.)
with self.assertRaises(IndexError):
p.MassPerArea(6)
def test_pcomp_01(self):
"""
asymmetrical, nsm=0.0 and nsm=1.0
"""
#self.pid = data[0]
#self.z0 = data[1]
#self.nsm = data[2]
#self.sb = data[3]
#self.ft = data[4]
#self.tref = data[5]
#self.ge = data[6]
#self.lam = data[7]
#Mid = data[8]
#T = data[9]
#Theta = data[10]
#Sout = data[11]
pid = 1
z0 = 0.
nsm = 0.
sb = 0.
ft = 0.
tref = 0.
ge = 0.
lam = 'NO' # is_symmetrical YES/NO
Mid = [1, 2, 3]
theta = [0., 10., 20.]
T = [.1, .2, .3]
sout = [1, 1, 0] # 0-NO, 1-YES
data = [pid, z0, nsm, sb, ft, tref, ge, lam, Mid, T, theta, sout]
p = PCOMP.add_op2_data(data)
self.assertFalse(p.is_symmetrical())
self.assertEqual(p.nplies, 3)
self.assertAlmostEqual(p.Thickness(), 0.6)
self.assertAlmostEqual(p.Thickness(0), 0.1)
self.assertAlmostEqual(p.Thickness(1), 0.2)
self.assertAlmostEqual(p.Thickness(2), 0.3)
with self.assertRaises(IndexError):
p.Thickness(3)
self.assertAlmostEqual(p.Theta(0), 0.)
self.assertAlmostEqual(p.Theta(1), 10.)
self.assertAlmostEqual(p.Theta(2), 20.)
with self.assertRaises(IndexError):
p.Theta(3)
self.assertEqual(p.Mid(0), 1)
self.assertEqual(p.Mid(1), 2)
self.assertEqual(p.Mid(2), 3)
with self.assertRaises(IndexError):
p.Mid(3)
self.assertEqual(p.Mids(), [1, 2, 3])
self.assertEqual(p.sout(0), 'YES')
self.assertEqual(p.sout(1), 'YES')
self.assertEqual(p.sout(2), 'NO')
with self.assertRaises(IndexError):
p.sout(3)
# material...
#self.mid = data[0]
#self.e = data[1]
#self.g = data[2]
#self.nu = data[3]
#self.rho = data[4]
#self.a = data[5]
#self.tref = data[6]
#self.ge = data[7]
#self.St = data[8]
#self.Sc = data[9]
#self.Ss = data[10]
#self.mcsid = data[11]
mid = 1
E = None
G = None
nu = None
rho = 1.0
a = None
St = None
Sc = None
Ss = None
mcsid = None
mat1 = [mid, E, G, nu, rho, a, tref, ge, St, Sc, Ss, mcsid]
with self.assertRaises(ValueError):
m = MAT1.add_op2_data(mat1)
G = 42.
mat1 = [mid, E, G, nu, rho, a, tref, ge, St, Sc, Ss, mcsid]
m = MAT1.add_op2_data(mat1)
for iply in range(len(p.plies)):
mid = p.plies[iply][0]
p.mids[iply] = m # MAT1
#p.mids = [m, m, m]
p.mids_ref = p.mids
#Rho
self.assertAlmostEqual(p.Rho(0), 1.0)
self.assertAlmostEqual(p.Rho(1), 1.0)
self.assertAlmostEqual(p.Rho(2), 1.0)
with self.assertRaises(IndexError):
p.Rho(3)
# MassPerArea
self.assertAlmostEqual(p.MassPerArea(), 0.6)
self.assertAlmostEqual(p.MassPerArea(0), 0.1)
self.assertAlmostEqual(p.MassPerArea(1), 0.2)
self.assertAlmostEqual(p.MassPerArea(2), 0.3)
with self.assertRaises(IndexError):
p.MassPerArea(3)
#----------------------
# change the nsm to 1.0
p.nsm = 1.0
self.assertEqual(p.Nsm(), 1.0)
# MassPerArea
self.assertAlmostEqual(p.MassPerArea(), 1.6)
self.assertAlmostEqual(p.MassPerArea(0, method='nplies'), 0.1 + 1 / 3.)
self.assertAlmostEqual(p.MassPerArea(1, method='nplies'), 0.2 + 1 / 3.)
self.assertAlmostEqual(p.MassPerArea(2, method='nplies'), 0.3 + 1 / 3.)
self.assertAlmostEqual(p.MassPerArea(0, method='rho*t'), 0.1 + 1 / 6.)
self.assertAlmostEqual(p.MassPerArea(1, method='rho*t'), 0.2 + 2 / 6.)
self.assertAlmostEqual(p.MassPerArea(2, method='rho*t'), 0.3 + 3 / 6.)
self.assertAlmostEqual(p.MassPerArea(0, method='t'), 0.1 + 1 / 6.)
self.assertAlmostEqual(p.MassPerArea(1, method='t'), 0.2 + 2 / 6.)
self.assertAlmostEqual(p.MassPerArea(2, method='t'), 0.3 + 3 / 6.)
with self.assertRaises(IndexError):
p.MassPerArea(3, method='nplies')
z = p.get_z_locations()
z_expected = array([0., T[0], T[0] + T[1], T[0] + T[1] + T[2]])
for za, ze in zip(z, z_expected):
self.assertAlmostEqual(za, ze)
#z0 =
p.z0 = 1.0
z_expected = 1.0 + z_expected
z = p.get_z_locations()
for za, ze in zip(z, z_expected):
self.assertAlmostEqual(za, ze)
