def _write_f06_springs_transient(f, stress, header, words, name):
raise RuntimeError('is this used?')
for dt, datai in sorted(iteritems(data)):
header[1] = ' %s = %10.4E\n' % (name, dt)
msg += header + words
f.write(''.join(msg))
eids = []
stresses = []
for eid, stress in sorted(iteritems(datai)):
eids.append(eid)
stresses.append(stress)
if len(stresses) == 4:
stresses = write_floats_13e(stresses)
f.write(' %10i %13s %10i %13s %10i %13s %10i %13s\n' % (
eids[0], stresses[0],
eids[1], stresses[1],
eids[2], stresses[2],
eids[3], stresses[3]))
eids = []
stresses = []
if stresses:
line = ' '
stresses = write_floats_13e(stresses)
for eid, stress in zip(eids, stresses):
line += '%10i %13s ' % (eid, stress)
f.write(line.rstrip() + '\n')
msg.append(page_stamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def _write_sort2_as_sort2(self, f, page_num, page_stamp, header, words):
nodes = self.node_gridtype[:, 0]
gridtypes = self.node_gridtype[:, 1]
times = self._times
for inode, (node_id, gridtypei) in enumerate(zip(nodes, gridtypes)):
t1 = self.data[inode, :, 0]
t2 = self.data[inode, :, 1]
t3 = self.data[inode, :, 2]
r1 = self.data[inode, :, 3]
r2 = self.data[inode, :, 4]
r3 = self.data[inode, :, 5]
header[1] = ' POINT-ID = %10i\n' % node_id
f.write(''.join(header + words))
for dt, t1i, t2i, t3i, r1i, r2i, r3i in zip(times, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
if sgridtype == 'G':
f.write('%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
write_float_12e(dt), sgridtype, dx, dy, dz, rx, ry, rz))
elif sgridtype == 'S':
f.write('%14s %6s %s\n' % (node_id, sgridtype, dx))
elif sgridtype == 'H':
f.write('%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
write_float_12e(dt), sgridtype, dx, dy, dz, rx, ry, rz))
elif sgridtype == 'L':
f.write('%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
write_float_12e(dt), sgridtype, dx, dy, dz, rx, ry, rz))
else:
raise NotImplementedError(sgridtype)
f.write(page_stamp % page_num)
page_num += 1
return page_num
def _write_sort1_as_sort1(self, header, page_stamp, page_num, f, msg_temp):
ntimes = self.data.shape[0]
eids = self.element
is_odd = False
nwrite = len(eids)
if len(eids) % 2 == 1:
nwrite -= 1
is_odd = True
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
axial = self.data[itime, :, 0]
SMa = self.data[itime, :, 1]
torsion = self.data[itime, :, 2]
SMt = self.data[itime, :, 3]
out = []
for eid, axiali, SMai, torsioni, SMti in zip(eids, axial, SMa, torsion, SMt):
[axiali, torsioni, SMai, SMti] = write_floats_13e([axiali, torsioni, SMai, SMti])
out.append([eid, axiali, SMai, torsioni, SMti])
for i in range(0, nwrite, 2):
out_line = ' %8i %-13s %-13s %-13s %-13s %-8i %-13s %-13s %-13s %-s\n' % (tuple(out[i] + out[i + 1]))
f.write(out_line)
if is_odd:
out_line = ' %8i %-13s %-13s %-13s %13s\n' % (tuple(out[-1]))
f.write(out_line)
f.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
words = [' APPLIED LOADS VECTOR\n',
'\n',
' EID SOURCE FX FY FZ MX MY MZ\n']
ntimes, ntotal, size = self.data.shape
for itime, dt in enumerate(self._times):
if self.nonlinear_factor is not None:
if isinstance(dt, float):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f.write(''.join(header + words))
f1 = self.data[itime, :, 0]
f2 = self.data[itime, :, 1]
f3 = self.data[itime, :, 2]
m1 = self.data[itime, :, 3]
m2 = self.data[itime, :, 4]
m3 = self.data[itime, :, 5]
for f1i, f2i, f3i, m1i, m2i, m3i in zip(f1, f2, f3, m1, m2, m3):
vals = [f1i, f2i, f3i, m1i, m2i, m3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
node_id, eid, source, dx, dy, dz, rx, ry, rz))
f.write(page_stamp % page_num)
page_num += 1
return page_num-1
def _write_sort1_as_sort1(self, header, page_stamp, page_num, f, msg_temp):
ntimes = self.data.shape[0]
eids = self.element
is_odd = False
nwrite = len(eids)
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
axial = self.data[itime, :, 0]
eqs = self.data[itime, :, 1]
total = self.data[itime, :, 2]
epcs = self.data[itime, :, 3]
ecs = self.data[itime, :, 4]
lts = self.data[itime, :, 5]
#print "dt=%s axials=%s eqs=%s ts=%s epcs=%s ecs=%s lts=%s" %(dt,axial,eqs,ts,epcs,ecs,lts)
#msgE[eid] = ' ELEMENT-ID = %8i\n' % (eid)
#if eid not in msgT:
#msgT[eid] = []
#msgT[eid].append(' %9.3E %13.6E %13.6E %13.6E %13.6E %13.6E %13.6E\n' % (dt, axial, eqs, ts, epcs, ecs, lts))
for eid, axiali, eqsi, totali, epcsi, ecsi, ltsi in zip(eids, axial, eqs, total, epcs, ecs, lts):
([saxial, seqs, stotal, sepcs, secs, slts]) = write_floats_13e(
[axiali, eqsi, totali, epcsi, ecsi, ltsi])
f.write(' %8i %-13s %-13s %-13s %-13s %-13s %s\n' % (
eid, saxial, seqs, stotal, sepcs, secs, slts))
f.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg))
#[radial, azimuthal, axial, shear, omax, oms, ovm]
radial = self.data[itime, :, 0]
azimuthal = self.data[itime, :, 1]
axial = self.data[itime, :, 2]
shear = self.data[itime, :, 3]
omax = self.data[itime, :, 4]
oms = self.data[itime, :, 5]
ovm = self.data[itime, :, 6]
for (i, eid, nid, radiali, azimuthali, axiali, sheari, omaxi, omsi, ovmi) in zip(
count(), eids, nids, radial, azimuthal, axial, shear, omax, oms, ovm):
vals = [radiali, azimuthali, axiali, sheari, omaxi, omsi, ovmi]
vals2 = write_floats_13e(vals)
[radiali, azimuthali, axiali, sheari, omaxi, omsi, ovmi] = vals2
f.write('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, nid, radiali, azimuthali, axiali, sheari, omaxi, omsi, ovmi))
f.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor is None:
page_num -= 1
return page_num
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg))
compX, shearY, shearZ, axialU, shearV, shearW, slipV, slipW
compX = self.data[itime, :, 0]
shearY = self.data[itime, :, 1]
shearZ = self.data[itime, :, 2]
axialU = self.data[itime, :, 3]
shearV = self.data[itime, :, 4]
shearW = self.data[itime, :, 5]
slipV = self.data[itime, :, 6]
slipW = self.data[itime, :, 7]
for (i, eid, compXi, shearYi, shearZi, axialUi, shearVi, shearWi, slipVi, slipWi) in zip(
count(), eids, compX, shearY, shearZ, axialU, shearV, shearW, slipV, slipW):
vals = [compXi, shearYi, shearZi, axialUi, shearVi, shearWi, slipVi, slipWi]
vals2 = write_floats_13e(vals)
[compXi, shearYi, shearZi, axialUi, shearVi, shearWi, slipVi, slipWi] = vals2
f.write('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, compXi, shearYi, shearZi, axialUi, shearVi, shearWi, slipVi, slipWi))
f.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor is None:
page_num -= 1
return page_num
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg))
#[element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed]
element_force = self.data[itime, :, 0]
axial_displacement = self.data[itime, :, 1]
axial_velocity = self.data[itime, :, 2]
axial_stress = self.data[itime, :, 3]
axial_strain = self.data[itime, :, 4]
plastic_strain = self.data[itime, :, 5]
is_failed = self.is_failed[itime, :, 0]
for (i, eid, element_forcei, axial_displacementi, axial_velocityi, axial_stressi, axial_straini, plastic_straini, is_failedi) in zip(
count(), eids, element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed):
vals = [element_forcei, axial_displacementi, axial_velocityi, axial_stressi, axial_straini, plastic_straini, is_failedi]
vals2 = write_floats_13e(vals)
[element_forcei, axial_displacementi, axial_velocityi, axial_stressi, axial_straini, plastic_straini, is_failedi] = vals2
f.write('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, element_forcei, axial_displacementi, axial_velocityi, axial_stressi, axial_straini, plastic_straini, is_failedi))
f.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor is None:
page_num -= 1
return page_num
def _write_sort1_as_sort1(self, f, page_num, page_stamp, header, words):
element = self.element
element_type = self.element_data_type
times = self._times
for itime in range(self.ntimes):
dt = self._times[itime]
t1 = self.data[itime, :, 0]
t2 = self.data[itime, :, 1]
t3 = self.data[itime, :, 2]
r1 = self.data[itime, :, 3]
r2 = self.data[itime, :, 4]
r3 = self.data[itime, :, 5]
if isinstance(dt, (float, float32)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f.write(''.join(header + words))
for element_id, etypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(element, element_type, t1, t2, t3, r1, r2, r3):
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (element_id, etypei, dx, dy, dz, rx, ry, rz))
f.write(page_stamp % page_num)
page_num += 1
return page_num
def _write_f06_transient(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False, is_sort1=True):
f.write('GridPointStressesVolume _write_f06_transient is not implemented...\n')
return page_num
#raise NotImplementedError()
msg = header + [' S T R E S S E S A T G R I D P O I N T S - - S U R F A C E 5\n',
'0 SURFACE X-AXIS X NORMAL(Z-AXIS) Z REFERENCE COORDINATE SYSTEM FOR SURFACE DEFINITION CID 0\n',
' GRID ELEMENT STRESSES IN SURFACE SYSTEM PRINCIPAL STRESSES MAX \n',
' ID ID FIBRE NORMAL-X NORMAL-Y SHEAR-XY ANGLE MAJOR MINOR SHEAR VON MISES\n']
#'0 13683 3736 TRIAX6 4.996584E+00 0.0 1.203093E+02 0.0 0.0 0.0'
#' 13683 3737 TRIAX6 -4.996584E+00 0.0 -1.203093E+02 0.0 0.0 0.0'
#' 13683 *TOTALS* 6.366463E-12 0.0 -1.364242E-12 0.0 0.0 0.0'
for dt, Forces in sorted(iteritems(self.forces)):
for ekey, force in sorted(iteritems(Forces)):
zero = '0'
for iLoad, f in enumerate(force):
(f1, f2, f3) = f
(m1, m2, m3) = self.moments[dt][ekey][iLoad]
(elemName) = self.elemName[ekey][iLoad]
eid = self.eids[ekey][iLoad]
vals = [f1, f2, f3, m1, m2, m3]
vals2 = write_floats_13e(vals)
[f1, f2, f3, m1, m2, m3] = vals2
if eid == 0:
eid = ''
msg.append('%s %8s %10s %8s %s %s %s %s %s %-s\n' % (zero, ekey, eid, elemName, f1, f2, f3, m1, m2, m3))
zero = ' '
msg.append(page_stamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def _write_sort1_as_sort1(self, f, page_num, page_stamp, header, words):
nodes = self.node_gridtype[:, 0]
gridtypes = self.node_gridtype[:, 1]
#times = self._times
for itime in range(self.ntimes):
dt = self._times[itime]
t1 = self.data[itime, :, 0]
if isinstance(dt, (float, float32)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f.write(''.join(header + words))
for node_id, gridtypei, t1i in zip(nodes, gridtypes, t1):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i]
vals2 = write_floats_13e(vals)
dx = vals2[0]
if sgridtype == 'G':
f.write('%14i %6s %s\n' % (node_id, sgridtype, dx))
elif sgridtype == 'S':
f.write('%14i %6s %s\n' % (node_id, sgridtype, dx))
elif sgridtype == 'H':
f.write('%14i %6s %s\n' % (node_id, sgridtype, dx))
elif sgridtype == 'L':
f.write('%14i %6s %s\n' % (node_id, sgridtype, dx))
else:
raise NotImplementedError(sgridtype)
f.write(page_stamp % page_num)
page_num += 1
return page_num
def _write_sort1_as_sort2(self, f, page_num, page_stamp, header, words):
element = self.element
element_type = self.element_data_type
times = self._times
node_id = 0 ## TODO: fix the node id
for inode, (eid, etypei) in enumerate(zip(element, element_type)):
t1 = self.data[:, inode, 0].ravel()
t2 = self.data[:, inode, 1].ravel()
t3 = self.data[:, inode, 2].ravel()
r1 = self.data[:, inode, 3].ravel()
r2 = self.data[:, inode, 4].ravel()
r3 = self.data[:, inode, 5].ravel()
header[1] = ' POINT-ID = %10i\n' % node_id
f.write(''.join(header + words))
for dt, t1i, t2i, t3i, r1i, r2i, r3i in zip(times, t1, t2, t3, r1, r2, r3):
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f.write('%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
write_float_12E(dt), etypei, dx, dy, dz, rx, ry, rz))
f.write(page_stamp % page_num)
page_num += 1
return page_num
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg))
#[tx, ty, tz, rx, ry, rz]
tx = self.data[itime, :, 0]
ty = self.data[itime, :, 1]
tz = self.data[itime, :, 2]
rx = self.data[itime, :, 3]
ry = self.data[itime, :, 4]
rz = self.data[itime, :, 5]
for eid, txi, tyi, tzi, rxi, ryi, rzi in zip(
eids, tx, ty, tz, rx, ry, rz):
vals = [txi, tyi, tzi, rxi, ryi, rzi]
vals2 = write_floats_13e(vals)
[txi, tyi, tzi, rxi, ryi, rzi] = vals2
f.write('0 %8i %-13s %-13s %-13s %-13s %-13s %s\n' % (
eid, txi, tyi, tzi, rxi, ryi, rzi))
f.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor is None:
page_num -= 1
return page_num
def _write_sort2_as_sort2(self, f, page_num, page_stamp, header, words):
nodes = self.node_gridtype[:, 0]
gridtypes = self.node_gridtype[:, 1]
times = self._times
for inode, (node_id, gridtypei) in enumerate(zip(nodes, gridtypes)):
t1 = self.data[inode, :, 0]
header[1] = ' POINT-ID = %10i\n' % node_id
f.write(''.join(header + words))
for dt, t1i in zip(times, t1):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i]
vals2 = write_floats_13e(vals)
dx = vals2[0]
if sgridtype == 'G':
f.write('%14s %6s %s\n' % (write_float_12e(dt), sgridtype, dx))
elif sgridtype == 'S':
f.write('%14s %6s %s\n' % (node_id, sgridtype, dx))
elif sgridtype == 'H':
f.write('%14s %6s %s\n' % (write_float_12e(dt), sgridtype, dx))
elif sgridtype == 'L':
f.write('%14s %6s %s\n' % (write_float_12e(dt), sgridtype, dx))
else:
raise NotImplementedError(sgridtype)
f.write(page_stamp % page_num)
page_num += 1
return page_num
def _write_sort1_as_sort1(self, f06_file, header, page_stamp, msg, page_num):
(ntimes, ntotal) = self.data.shape[:2]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
sd = self.data[itime, :, 0]
sxc = self.data[itime, :, 1]
sxd = self.data[itime, :, 2]
sxe = self.data[itime, :, 3]
sxf = self.data[itime, :, 4]
axial = self.data[itime, :, 5]
smax = self.data[itime, :, 6]
smin = self.data[itime, :, 7]
MS = self.data[itime, :, 8]
for (i, eid, sdi, sxci, sxdi, sxei, sxfi, axiali, smaxi, smini, MSi) in zip(
count(), eids, sd, sxc, sxd, sxe, sxf, axial, smax, smin, MS):
vals = [sdi, sxci, sxdi, sxei, sxfi, axiali, smaxi, smini, MSi]
vals2 = write_floats_13e(vals)
[sdi, sxci, sxdi, sxei, sxfi, axiali, smaxi, smini, MSi] = vals2
f06_file.write('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s %s\n'
% (eid, sdi, sxci, sxdi, sxei, sxfi, axiali, smaxi, smini, MSi))
f06_file.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor is None:
page_num -= 1
return page_num
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg, nnodes, cen = _get_plate_msg(self)
# write the f06
ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
#cen_word = 'CEN/%i' % nnodes
cen_word = cen
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
#[fiber_dist, oxx, oyy, txy, angle, majorP, minorP, ovm]
fiber_dist = self.data[itime, :, 0]
oxx = self.data[itime, :, 1]
oyy = self.data[itime, :, 2]
txy = self.data[itime, :, 3]
angle = self.data[itime, :, 4]
majorP = self.data[itime, :, 5]
minorP = self.data[itime, :, 6]
ovm = self.data[itime, :, 7]
for (i, eid, nid, fdi, oxxi, oyyi, txyi, anglei, major, minor, ovmi) in zip(
count(), eids, nids, fiber_dist, oxx, oyy, txy, angle, majorP, minorP, ovm):
[fdi, oxxi, oyyi, txyi, major, minor, ovmi] = write_floats_13e(
[fdi, oxxi, oyyi, txyi, major, minor, ovmi])
ilayer = i % 2
# tria3
if self.element_type in [33, 74]: # CQUAD4, CTRIA3
if ilayer == 0:
f.write('0 %6i %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n' % (eid, fdi, oxxi, oyyi, txyi, anglei, major, minor, ovmi))
else:
f.write(' %6s %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n' % ('', fdi, oxxi, oyyi, txyi, anglei, major, minor, ovmi))
elif self.element_type in [64, 70, 75, 82, 144]: # CQUAD8, CTRIAR, CTRIA6, CQUADR, CQUAD4
# bilinear
if nid == 0 and ilayer == 0: # CEN
f.write('0 %8i %8s %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n' % (eid, cen_word, fdi, oxxi, oyyi, txyi, anglei, major, minor, ovmi))
elif ilayer == 0:
f.write(' %8s %8i %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n' % ('', nid, fdi, oxxi, oyyi, txyi, anglei, major, minor, ovmi))
elif ilayer == 1:
f.write(' %8s %8s %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n\n' % ('', '', fdi, oxxi, oyyi, txyi, anglei, major, minor, ovmi))
else:
raise NotImplementedError('element_name=%s self.element_type=%s' % (self.element_name, self.element_type))
f.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.element
#print('CBAR ntimes=%s ntotal=%s' % (ntimes, ntotal))
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg))
s1a = self.data[itime, :, 0]
s2a = self.data[itime, :, 1]
s3a = self.data[itime, :, 2]
s4a = self.data[itime, :, 3]
axial = self.data[itime, :, 4]
smaxa = self.data[itime, :, 5]
smina = self.data[itime, :, 6]
MSt = self.data[itime, :, 7]
s1b = self.data[itime, :, 8]
s2b = self.data[itime, :, 9]
s3b = self.data[itime, :, 10]
s4b = self.data[itime, :, 11]
smaxb = self.data[itime, :, 12]
sminb = self.data[itime, :, 13]
MSc = self.data[itime, :, 14]
for (i, eid, s1ai, s2ai, s3ai, s4ai, axiali, smaxai, sminai, MSti,
s1bi, s2bi, s3bi, s4bi, smaxbi, sminbi, MSci) in zip(
count(), eids, s1a, s2a, s3a, s4a, axial, smaxa, smina, MSt,
s1b, s2b, s3b, s4b, smaxb, sminb, MSc):
vals = [s1ai, s2ai, s3ai, s4ai, axiali, smaxai, sminai, MSti,
s1bi, s2bi, s3bi, s4bi, smaxbi, sminbi, MSci]
vals2 = write_floats_13e(vals)
[s1ai, s2ai, s3ai, s4ai, axiali, smaxai, sminai, MSti,
s1bi, s2bi, s3bi, s4bi, smaxbi, sminbi, MSci] = vals2
f.write('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
' %8s %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, s1ai, s2ai, s3ai, s4ai, axiali, smaxai, sminai, MSti,
'', s1bi, s2bi, s3bi, s4bi, '', smaxbi, sminbi, MSci))
f.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor is None:
page_num -= 1
return page_num
def _write_f06_springs(f, data):
raise RuntimeError('is this used?')
eids = []
stresses = []
for eid, stress in sorted(iteritems(data)):
eids.append(eid)
stresses.append(stress)
if len(stresses) == 4:
stresses = write_floats_13e(stresses)
f.write(' %10i %13s %10i %13s %10i %13s %10i %13s\n' % (
eids[0], stresses[0],
eids[1], stresses[1],
eids[2], stresses[2],
eids[3], stresses[3]))
eids = []
stresses = []
if stresses:
line = ' '
stresses = write_floats_13e(stresses)
for eid, stress in zip(eids, stresses):
line += '%10i %13s ' % (eid, stress)
f.write(line.rstrip() + '\n')
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
locs = self.element_node[:, 2]
#xxbs = self.xxb
#print('CBEAM ntimes=%s ntotal=%s' % (ntimes, ntotal))
loc_map = ['C', 'D', 'E', 'F',
'C', 'D', 'E', 'F',]
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg))
longs = self.data[itime, :, 0]
eqSs = self.data[itime, :, 1]
tEs = self.data[itime, :, 2]
epss = self.data[itime, :, 3]
ecss = self.data[itime, :, 4]
#msg = [' N O N L I N E A R S T R E S S E S I N B E A M E L E M E N T S ( C B E A M )\n',
#' \n',
#' ELEMENT GRID POINT STRESS EQUIVALENT TOTAL STRAIN EFF. STRAIN EFF. CREEP\n',
#' ID ID STRESS PLASTIC/NLELAST STRAIN\n',]
#'0 1 1 C 1.738817E+03 1.738817E+03 5.796055E-05 0.0 0.0\n',
#' D 1.229523E+03 1.229523E+03 4.098411E-05 0.0 0.0\n',
eid_old = None
for (i, eid, nid, loc, longi, eqS, tE, eps, ecs) in zip(
count(), eids, nids, locs, longs, eqSs, tEs, epss, ecss):
vals = [longi, eqS, tE, eps, ecs]
vals2 = write_floats_13e(vals)
[longi, eqS, tE, eps, ecs] = vals2
if loc == 0:
f.write('0 %14i %8i %4s %13s %13s %13s %13s %s\n' % (eid, nid, 'C', longi, eqS, tE, eps, ecs.rstrip()))
elif loc == 4:
f.write(' %14s %8i %4s %13s %13s %13s %13s %s\n' % ('', nid, 'C', longi, eqS, tE, eps, ecs.rstrip()))
else:
loci = loc_map[loc]
f.write(' %14s %8s %4s %13s %13s %13s %13s %s\n' % ('', '', loci, longi, eqS, tE, eps, ecs.rstrip()))
f.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor is None:
page_num -= 1
return page_num
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
xxbs = self.xxb
#print('CBEAM ntimes=%s ntotal=%s' % (ntimes, ntotal))
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f.write(''.join(header + msg))
sxcs = self.data[itime, :, 0]
sxds = self.data[itime, :, 1]
sxes = self.data[itime, :, 2]
sxfs = self.data[itime, :, 3]
smaxs = self.data[itime, :, 4]
smins = self.data[itime, :, 5]
SMts = self.data[itime, :, 6]
SMcs = self.data[itime, :, 7]
eid_old = None
xxb_old = None
for (i, eid, nid, xxb, sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc) in zip(
count(), eids, nids, xxbs, sxcs, sxds, sxes, sxfs, smaxs, smins, SMts, SMcs):
if eid != eid_old:
f.write('0 %8i\n' % eid)
if xxb == xxb_old:
continue
# #if eid != eid_old and xxb != xxb_old:
#continue
vals = [sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc]
vals2 = write_floats_13e(vals)
[sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc] = vals2
f.write('%19s %4.3f %12s %12s %12s %12s %12s %12s %12s %s\n' % (nid, xxb, sxc, sxd, sxe, sxf,
sMax, sMin, SMt, SMc.strip()))
eid_old = eid
xxb_old = xxb
f.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor is None:
page_num -= 1
return page_num
def _write_f06_transient(self,
header,
page_stamp,
page_num=1,
f=None,
is_mag_phase=False,
is_sort1=True):
f.write(
'GridPointStressesVolume _write_f06_transient is not implemented...\n'
)
return page_num
#raise NotImplementedError()
msg = header + [
' S T R E S S E S A T G R I D P O I N T S - - S U R F A C E 5\n',
'0 SURFACE X-AXIS X NORMAL(Z-AXIS) Z REFERENCE COORDINATE SYSTEM FOR SURFACE DEFINITION CID 0\n',
' GRID ELEMENT STRESSES IN SURFACE SYSTEM PRINCIPAL STRESSES MAX \n',
' ID ID FIBRE NORMAL-X NORMAL-Y SHEAR-XY ANGLE MAJOR MINOR SHEAR VON MISES\n'
]
#'0 13683 3736 TRIAX6 4.996584E+00 0.0 1.203093E+02 0.0 0.0 0.0'
#' 13683 3737 TRIAX6 -4.996584E+00 0.0 -1.203093E+02 0.0 0.0 0.0'
#' 13683 *TOTALS* 6.366463E-12 0.0 -1.364242E-12 0.0 0.0 0.0'
for dt, Forces in sorted(iteritems(self.forces)):
for ekey, force in sorted(iteritems(Forces)):
zero = '0'
for iLoad, f in enumerate(force):
(f1, f2, f3) = f
(m1, m2, m3) = self.moments[dt][ekey][iLoad]
(elemName) = self.elemName[ekey][iLoad]
eid = self.eids[ekey][iLoad]
vals = [f1, f2, f3, m1, m2, m3]
vals2 = write_floats_13e(vals)
[f1, f2, f3, m1, m2, m3] = vals2
if eid == 0:
eid = ''
msg.append(
'%s %8s %10s %8s %s %s %s %s %s %-s\n'
% (zero, ekey, eid, elemName, f1, f2, f3, m1, m2, m3))
zero = ' '
msg.append(page_stamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self,
f06_file,
header=None,
page_stamp='PAGE %s',
page_num=1,
is_mag_phase=False,
is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
(ntimes, unused_ntotal) = self.data.shape[:2]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
#[radial, azimuthal, axial, shear, omax, oms, ovm]
radial = self.data[itime, :, 0]
azimuthal = self.data[itime, :, 1]
axial = self.data[itime, :, 2]
shear = self.data[itime, :, 3]
omax = self.data[itime, :, 4]
oms = self.data[itime, :, 5]
ovm = self.data[itime, :, 6]
for (eid, nid, radiali, azimuthali, axiali, sheari, omaxi, omsi,
ovmi) in zip(eids, nids, radial, azimuthal, axial, shear,
omax, oms, ovm):
vals = [radiali, azimuthali, axiali, sheari, omaxi, omsi, ovmi]
vals2 = write_floats_13e(vals)
[radiali, azimuthali, axiali, sheari, omaxi, omsi,
ovmi] = vals2
f06_file.write(
'0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, nid, radiali, azimuthali, axiali, sheari, omaxi,
omsi, ovmi))
f06_file.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor in (None, np.nan):
page_num -= 1
return page_num
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s', page_num=1,
is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
xxbs = self.xxb
#print('CBEAM ntimes=%s ntotal=%s' % (ntimes, ntotal))
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
sxcs = self.data[itime, :, 0]
sxds = self.data[itime, :, 1]
sxes = self.data[itime, :, 2]
sxfs = self.data[itime, :, 3]
eid_old = None
xxb_old = None
for (eid, nid, xxb, sxc, sxd, sxe, sxf) in zip(
eids, nids, xxbs, sxcs, sxds, sxes, sxfs):
if eid != eid_old:
f06_file.write('0 %8i\n' % eid)
if xxb == xxb_old:
continue
# #if eid != eid_old and xxb != xxb_old:
#continue
vals = [sxc, sxd, sxe, sxf]
vals2 = write_floats_13e(vals)
[sxc, sxd, sxe, sxf] = vals2
f06_file.write('%19s %4.3f %12s %12s %12s %s\n' % (
nid, xxb, sxc, sxd, sxe, sxf.strip()))
eid_old = eid
xxb_old = xxb
f06_file.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor in (None, np.nan):
page_num -= 1
return page_num
def _write_f06_block(self, words, header, page_stamp, page_num, f, write_words,
is_mag_phase=False, is_sort1=True):
if write_words:
words += [' \n', ' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
#words += self.getTableMarker()
f.write(''.join(header + words))
node = self.node_gridtype[:, 0]
gridtype = self.node_gridtype[:, 1]
t1 = self.data[0, :, 0]
for node_id, gridtypei, t1i in zip(node, gridtype, t1):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i]
vals2 = write_floats_13e(vals)
dx = vals2[0]
f.write('%14i %6s %s\n' % (node_id, sgridtype, dx))
f.write(page_stamp % page_num)
return page_num
def _write_f06_block(self, words, header, page_stamp, page_num, f06_file, write_words,
is_mag_phase=False, is_sort1=True):
if write_words:
words += [' \n', ' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
#words += self.getTableMarker()
f06_file.write(''.join(header + words))
node = self.node_gridtype[:, 0]
gridtype = self.node_gridtype[:, 1]
t1 = self.data[0, :, 0]
for node_id, gridtypei, t1i in zip(node, gridtype, t1):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i]
vals2 = write_floats_13e(vals)
dx = vals2[0]
f06_file.write('%14i %6s %s\n' % (node_id, sgridtype, dx))
f06_file.write(page_stamp % page_num)
return page_num
def _write_sort1_as_sort1(self, f, page_num, page_stamp, header, words):
nodes = self.node_gridtype[:, 0]
gridtypes = self.node_gridtype[:, 1]
times = self._times
for itime in range(self.ntimes):
dt = self._times[itime]
t1 = self.data[itime, :, 0]
t2 = self.data[itime, :, 1]
t3 = self.data[itime, :, 2]
r1 = self.data[itime, :, 3]
r2 = self.data[itime, :, 4]
r3 = self.data[itime, :, 5]
if isinstance(dt, (float, float32)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f.write(''.join(header + words))
for node_id, gridtypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(
nodes, gridtypes, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
if sgridtype == 'G':
f.write(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n'
% (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
elif sgridtype == 'S':
f.write('%14i %6s %s\n' % (node_id, sgridtype, dx))
elif sgridtype == 'H':
f.write(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n'
% (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
elif sgridtype == 'L':
f.write(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n'
% (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
else:
raise NotImplementedError(sgridtype)
f.write(page_stamp % page_num)
page_num += 1
return page_num
def _write_sort1_as_sort2(self, f, page_num, page_stamp, header, words):
nodes = self.node_gridtype[:, 0]
gridtypes = self.node_gridtype[:, 1]
times = self._times
for inode, (node_id, gridtypei) in enumerate(zip(nodes, gridtypes)):
t1 = self.data[:, inode, 0].ravel()
t2 = self.data[:, inode, 1].ravel()
t3 = self.data[:, inode, 2].ravel()
r1 = self.data[:, inode, 3].ravel()
r2 = self.data[:, inode, 4].ravel()
r3 = self.data[:, inode, 5].ravel()
header[1] = ' POINT-ID = %10i\n' % node_id
f.write(''.join(header + words))
for dt, t1i, t2i, t3i, r1i, r2i, r3i in zip(
times, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
if sgridtype == 'G':
f.write(
'%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n'
% (write_float_12e(dt), sgridtype, dx, dy, dz, rx, ry,
rz))
elif sgridtype == 'S':
f.write('%14s %6s %s\n' % (node_id, sgridtype, dx))
elif sgridtype == 'H':
f.write(
'%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n'
% (write_float_12e(dt), sgridtype, dx, dy, dz, rx, ry,
rz))
elif sgridtype == 'L':
f.write(
'%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n'
% (write_float_12e(dt), sgridtype, dx, dy, dz, rx, ry,
rz))
else:
raise NotImplementedError(sgridtype)
f.write(page_stamp % page_num)
page_num += 1
return page_num
def _write_f06_block(self, words, header, page_stamp, page_num, f,
is_mag_phase=False, is_sort1=True):
#words += self.getTableMarker()
f.write(''.join(header + words))
element = self.element
element_type = self.element_data_type
t1 = self.data[0, :, 0]
t2 = self.data[0, :, 1]
t3 = self.data[0, :, 2]
r1 = self.data[0, :, 3]
r2 = self.data[0, :, 4]
r3 = self.data[0, :, 5]
for element_id, etypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(element, element_type, t1, t2, t3, r1, r2, r3):
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
(dx, dy, dz, rx, ry, rz) = write_floats_13e(vals)
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (element_id, etypei, dx, dy, dz, rx, ry, rz))
f.write(page_stamp % page_num)
return page_num
def _write_f06_block(self, words, header, page_stamp, page_num, f,
is_mag_phase=False, is_sort1=True):
#words += self.getTableMarker()
f.write(''.join(header + words))
element = self.element
element_type = self.element_data_type
t1 = self.data[0, :, 0]
t2 = self.data[0, :, 1]
t3 = self.data[0, :, 2]
r1 = self.data[0, :, 3]
r2 = self.data[0, :, 4]
r3 = self.data[0, :, 5]
for element_id, etypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(element, element_type, t1, t2, t3, r1, r2, r3):
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
(dx, dy, dz, rx, ry, rz) = write_floats_13e(vals)
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
element_id, etypei, dx, dy, dz, rx, ry, rz))
f.write(page_stamp % page_num)
return page_num
def write_f06(self,
f06,
header=None,
page_stamp='PAGE %s',
page_num=1,
is_mag_phase=False,
is_sort1=True):
if header is None:
header = []
words = [
' APPLIED LOADS VECTOR\n', '\n',
' EID SOURCE FX FY FZ MX MY MZ\n'
]
#ntimes, ntotal, size = self.data.shape
for itime, dt in enumerate(self._times):
if self.nonlinear_factor is not None:
if isinstance(dt, float):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f06.write(''.join(header + words))
f1 = self.data[itime, :, 0]
f2 = self.data[itime, :, 1]
f3 = self.data[itime, :, 2]
m1 = self.data[itime, :, 3]
m2 = self.data[itime, :, 4]
m3 = self.data[itime, :, 5]
source = ''
for f1i, f2i, f3i, m1i, m2i, m3i in zip(f1, f2, f3, m1, m2, m3):
vals = [f1i, f2i, f3i, m1i, m2i, m3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f06.write(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n'
'%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n' %
(node_id, eid, source, dxr, dyr, dzr, rxr, ryr, rzr, '',
'', '', '', dxi, dyi, dzi, rxi, ryi, rzi))
f06.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self,
f06_file,
header=None,
page_stamp='PAGE %s',
page_num=1,
is_mag_phase=False,
is_sort1=True):
if header is None:
header = []
msg_temp = [
' F I N I T E E L E M E N T T E M P E R A T U R E G R A D I E N T S A N D F L U X E S \n'
' \n'
' ELEMENT-ID EL-TYPE X-GRADIENT Y-GRADIENT Z-GRADIENT X-FLUX Y-FLUX Z-FLUX\n'
#' 10 ROD -1.889713E+02 3.779427E+04'
]
ntimes = self.data.shape[0]
eids = self.element
etype = self.element_data_type
for itime in range(ntimes):
dt = self._times[itime] # TODO: rename this...
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
xgrad = self.data[itime, :, 0]
#ygrad = self.data[itime, :, 1]
#zgrad = self.data[itime, :, 2]
xflux = self.data[itime, :, 1]
#yflux = self.data[itime, :, 4]
#zflux = self.data[itime, :, 5]
for (eid, etypei, xgradi, xfluxi) in zip(eids, etype, xgrad,
xflux):
(sxgradi, sxfluxi) = write_floats_13e([xgradi, xfluxi])
# TODO: hopa is probably the wrong type
f06_file.write(' %8i %8s %-13s %-13s %-13s %s\n' %
(eid, etypei, sxgradi, '', '', sxfluxi))
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
#if self.nonlinear_factor is not None:
#return self._write_f06_transient(header, page_stamp, page_num, f06_file,
#is_mag_phase=is_mag_phase, is_sort1=is_sort1)
# modes get added
words = ' R E A L E I G E N V E C T O R N O . %10i\n \n' \
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n'
#if not len(header) >= 3:
#header.append('')
for itime in range(self.ntimes):
node = self.node_gridtype[:, 0]
gridtype = self.node_gridtype[:, 1]
t1 = self.data[itime, :, 0]
t2 = self.data[itime, :, 1]
t3 = self.data[itime, :, 2]
r1 = self.data[itime, :, 3]
r2 = self.data[itime, :, 4]
r3 = self.data[itime, :, 5]
dt = self._times[itime]
#if isinstance(dt, float):
#header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
#else:
#header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f06_file.write(''.join(header + [words % dt]))
for node_id, gridtypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(node, gridtype, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f06_file.write(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
node_id, sgridtype, dx, dy, dz, rx, ry, rz))
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self, f, header, page_stamp, page_num=1): # not proper msg start
title = ''
if self.title is not None:
title = '%s' % str(self.title).center(124).rstrip() + '\n'
msg = header + [' R E A L E I G E N V A L U E S\n', title,
' MODE EXTRACTION EIGENVALUE RADIANS CYCLES GENERALIZED GENERALIZED\n',
' NO. ORDER MASS STIFFNESS\n']
for (imode, order) in sorted(iteritems(self.extraction_order)):
eigr = self.eigenvalues[imode]
freq = self.freqs[imode]
omega = self.omegas[imode]
mass = self.generalized_mass[imode]
stiff = self.generalized_stiffness[imode]
[eigr, freq, omega, mass, stiff] = write_floats_13e([eigr, freq, omega, mass, stiff])
# i ord eig ome f m k
msg.append(' %8s%10s%20s%20s%20s%20s %s\n' % (
imode, order, eigr, omega, freq, mass, stiff))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self, f, header, page_stamp, page_num=1):
title = ''
if self.title is not None:
title = '%s' % str(self.title).center(124).rstrip() + '\n'
msg = header + [' R E A L E I G E N V A L U E S\n', title,
' MODE EXTRACTION EIGENVALUE RADIANS CYCLES GENERALIZED GENERALIZED\n',
' NO. ORDER MASS STIFFNESS\n']
for (imode, order) in sorted(iteritems(self.extraction_order)):
eigenvalue = self.eigenvalues[imode]
#cycle = sqrt(abs(eigenvalue)) / (2. * pi)
omega = self.radians[imode]
freq = self.cycles[imode]
mass = self.generalized_mass[imode]
stiff = self.generalized_stiffness[imode]
[eigen, omega, freq, mass, stiff] = write_floats_13e([eigenvalue, omega, freq, mass, stiff])
msg.append(' %8s %8s %-13s %-13s %-13s %-13s %s\n' % (
imode, order, eigen, omega, freq, mass, stiff))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self, f, header, page_stamp, page_num=1):
title = ''
if self.title is not None:
title = '%s' % str(self.title).center(124).rstrip() + '\n'
msg = header + [' R E A L E I G E N V A L U E S\n', title,
' MODE EXTRACTION EIGENVALUE RADIANS CYCLES GENERALIZED GENERALIZED\n',
' NO. ORDER MASS STIFFNESS\n']
for (imode, order) in sorted(iteritems(self.extraction_order)):
eigenvalue = self.eigenvalues[imode]
#cycle = sqrt(abs(eigenvalue)) / (2. * pi)
omega = self.radians[imode]
freq = self.cycles[imode]
mass = self.generalized_mass[imode]
stiff = self.generalized_stiffness[imode]
[eigen, omega, freq, mass, stiff] = write_floats_13e([eigenvalue, omega, freq, mass, stiff])
msg.append(' %8s %8s %-13s %-13s %-13s %-13s %s\n' % (
imode, order, eigen, omega, freq, mass, stiff))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self, f, header, page_stamp, page_num=1): # not proper msg start
title = ''
if self.title is not None:
title = '%s' % str(self.title).center(124).rstrip() + '\n'
msg = header + [' R E A L E I G E N V A L U E S\n', title,
' MODE EXTRACTION EIGENVALUE RADIANS CYCLES GENERALIZED GENERALIZED\n',
' NO. ORDER MASS STIFFNESS\n']
for (imode, order) in sorted(iteritems(self.extraction_order)):
eigr = self.eigenvalues[imode]
freq = self.freqs[imode]
omega = self.omegas[imode]
mass = self.generalized_mass[imode]
stiff = self.generalized_stiffness[imode]
[eigr, freq, omega, mass, stiff] = write_floats_13e([eigr, freq, omega, mass, stiff])
# i ord eig ome f m k
msg.append(' %8s%10s%20s%20s%20s%20s %s\n' % (
imode, order, eigr, omega, freq, mass, stiff))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def _write_sort1_as_sort1(self, header, page_stamp, page_num, f06,
msg_temp):
ntimes = self.data.shape[0]
eids = self.element
is_odd = False
nwrite = len(eids)
if len(eids) % 2 == 1:
nwrite -= 1
is_odd = True
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
axial = self.data[itime, :, 0]
SMa = self.data[itime, :, 1]
torsion = self.data[itime, :, 2]
SMt = self.data[itime, :, 3]
out = []
for eid, axiali, SMai, torsioni, SMti in zip(
eids, axial, SMa, torsion, SMt):
[axiali, torsioni, SMai,
SMti] = write_floats_13e([axiali, torsioni, SMai, SMti])
out.append([eid, axiali, SMai, torsioni, SMti])
for i in range(0, nwrite, 2):
out_line = ' %8i %-13s %-13s %-13s %-13s %-8i %-13s %-13s %-13s %-s\n' % (
tuple(out[i] + out[i + 1]))
f06.write(out_line)
if is_odd:
out_line = ' %8i %-13s %-13s %-13s %13s\n' % (tuple(
out[-1]))
f06.write(out_line)
f06.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def _write_sort1_as_sort1(self, f06_file, page_num, page_stamp, header,
words):
nodes = self.node_gridtype[:, 0]
gridtypes = self.node_gridtype[:, 1]
unused_times = self._times
for itime in range(self.ntimes):
dt = self._times[itime]
t1 = self.data[itime, :, 0]
t2 = self.data[itime, :, 1]
t3 = self.data[itime, :, 2]
r1 = self.data[itime, :, 3]
r2 = self.data[itime, :, 4]
r3 = self.data[itime, :, 5]
if isinstance(dt, float_types):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f06_file.write(''.join(header + words))
for node_id, gridtypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(
nodes, gridtypes, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
if sgridtype in ['G', 'H', 'L']:
f06_file.write(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n'
% (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
elif sgridtype in ['S', 'M', 'E']:
f06_file.write('%14i %6s %s\n' %
(node_id, sgridtype, dx))
else: # pragma: no cover
raise NotImplementedError(
f'node_id={node_id} sgridtype={sgridtype} vals={vals2}'
)
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
#if self.nonlinear_factor is not None:
#return self._write_f06_transient(header, page_stamp, page_num, f, is_mag_phase=is_mag_phase, is_sort1=is_sort1)
# modes get added
words = ' R E A L E I G E N V E C T O R N O . %10i\n \n' \
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n'
msg = []
#if not len(header) >= 3:
#header.append('')
for itime in range(self.ntimes):
node = self.node_gridtype[:, 0]
gridtype = self.node_gridtype[:, 1]
t1 = self.data[itime, :, 0]
t2 = self.data[itime, :, 1]
t3 = self.data[itime, :, 2]
r1 = self.data[itime, :, 3]
r2 = self.data[itime, :, 4]
r3 = self.data[itime, :, 5]
dt = self._times[itime]
#if isinstance(dt, float):
#header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
#else:
#header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
msg += header + [words % dt]
for node_id, gridtypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(node, gridtype, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
msg.append('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self, f, header, page_stamp, page_num=1): # not proper msg start
title = ''
if self.title is not None:
title = '%s' % str(self.title).center(124).rstrip() + '\n'
msg = header + [' C O M P L E X E I G E N V A L U E S U M M A R Y\n', title,
'0 ROOT EXTRACTION EIGENVALUE FREQUENCY DAMPING\n',
' NO. ORDER (REAL) (IMAG) (CYCLES) COEFFICIENT\n']
for (imode, order) in sorted(iteritems(self.extraction_order)):
eigr = self.eigenvalues[imode].real
eigi = self.eigenvalues[imode].imag
freq = self.cycles[imode]
damping = self.damping[imode]
[eigr, eigi, freq, damping] = write_floats_13e([eigr, eigi, freq, damping])
# imode order eigr eigi freq damping
msg.append(' %22s %10s %-15s %-13s %-13s %s\n' % (
imode, order, eigr, eigi, freq, damping))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self, f, header, page_stamp, page_num=1): # not proper msg start
title = ''
if self.title is not None:
title = '%s' % str(self.title).center(124).rstrip() + '\n'
msg = header + [' C O M P L E X E I G E N V A L U E S U M M A R Y\n', title,
'0 ROOT EXTRACTION EIGENVALUE FREQUENCY DAMPING\n',
' NO. ORDER (REAL) (IMAG) (CYCLES) COEFFICIENT\n']
for (imode, order) in sorted(iteritems(self.extraction_order)):
eigr = self.eigenvalues[imode].real
eigi = self.eigenvalues[imode].imag
freq = self.cycles[imode]
damping = self.damping[imode]
[eigr, eigi, freq, damping] = write_floats_13e([eigr, eigi, freq, damping])
# imode order eigr eigi freq damping
msg.append(' %22s %10s %-15s %-13s %-13s %s\n' % (
imode, order, eigr, eigi, freq, damping))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self,
f06_file,
header=None,
page_stamp='PAGE %s',
page_num=1,
is_mag_phase=False,
is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
#[tx, ty, tz, rx, ry, rz]
tx = self.data[itime, :, 0]
ty = self.data[itime, :, 1]
tz = self.data[itime, :, 2]
rx = self.data[itime, :, 3]
ry = self.data[itime, :, 4]
rz = self.data[itime, :, 5]
for eid, txi, tyi, tzi, rxi, ryi, rzi in zip(
eids, tx, ty, tz, rx, ry, rz):
vals = [txi, tyi, tzi, rxi, ryi, rzi]
vals2 = write_floats_13e(vals)
[txi, tyi, tzi, rxi, ryi, rzi] = vals2
f06_file.write(
'0 %8i %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, txi, tyi, tzi, rxi, ryi, rzi))
f06_file.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor in (None, np.nan):
page_num -= 1
return page_num
def _write_sort1_as_sort1(self, f06_file, header, page_stamp, msg,
page_num):
ntimes = self.data.shape[0]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
sd = self.data[itime, :, 0]
sxc = self.data[itime, :, 1]
sxd = self.data[itime, :, 2]
sxe = self.data[itime, :, 3]
sxf = self.data[itime, :, 4]
axial = self.data[itime, :, 5]
smax = self.data[itime, :, 6]
smin = self.data[itime, :, 7]
MS = self.data[itime, :, 8]
for (i, eid, sdi, sxci, sxdi, sxei, sxfi, axiali, smaxi, smini,
MSi) in zip(count(), eids, sd, sxc, sxd, sxe, sxf, axial,
smax, smin, MS):
vals = [sdi, sxci, sxdi, sxei, sxfi, axiali, smaxi, smini, MSi]
vals2 = write_floats_13e(vals)
[sdi, sxci, sxdi, sxei, sxfi, axiali, smaxi, smini,
MSi] = vals2
f06_file.write(
'0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s %s\n'
% (eid, sdi, sxci, sxdi, sxei, sxfi, axiali, smaxi, smini,
MSi))
f06_file.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor in (None, np.nan):
page_num -= 1
return page_num
def _write_sort2_as_sort2(self, f, page_num, page_stamp, header, words):
element = self.element
element_type = self.element_data_type
times = self._times
for ieid, (element_id, etypei) in enumerate(zip(element, element_type)):
t1 = self.data[inode, :, 0]
t2 = self.data[inode, :, 1]
t3 = self.data[inode, :, 2]
r1 = self.data[inode, :, 3]
r2 = self.data[inode, :, 4]
r3 = self.data[inode, :, 5]
header[1] = ' POINT-ID = %10i\n' % node_id
f.write(''.join(header + words))
for dt, t1i, t2i, t3i, r1i, r2i, r3i in zip(times, t1, t2, t3, r1, r2, r3):
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f.write('%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (write_float_12E(dt),
etypei, dx, dy, dz, rx, ry, rz))
f.write(page_stamp % page_num)
page_num += 1
return page_num
def _write_sort2_as_sort2(self, f06_file, page_num, page_stamp, header, words):
element = self.element
element_type = self.element_data_type
times = self._times
for ieid, (element_id, etypei) in enumerate(zip(element, element_type)):
t1 = self.data[ieid, :, 0]
t2 = self.data[ieid, :, 1]
t3 = self.data[ieid, :, 2]
r1 = self.data[ieid, :, 3]
r2 = self.data[ieid, :, 4]
r3 = self.data[ieid, :, 5]
header[1] = ' ELEMENT-ID = %10i\n' % element_id
f06_file.write(''.join(header + words))
for dt, t1i, t2i, t3i, r1i, r2i, r3i in zip(times, t1, t2, t3, r1, r2, r3):
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f06_file.write('%14s %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
write_float_12e(dt), etypei, dx, dy, dz, rx, ry, rz))
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num
def _write_f06_block(self, words, header, page_stamp, page_num, f, write_words,
is_mag_phase=False, is_sort1=True):
if write_words:
words += [' \n', ' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
#words += self.getTableMarker()
f.write(''.join(header + words))
node = self.node_gridtype[:, 0]
gridtype = self.node_gridtype[:, 1]
t1 = self.data[0, :, 0]
t2 = self.data[0, :, 1]
t3 = self.data[0, :, 2]
r1 = self.data[0, :, 3]
r2 = self.data[0, :, 4]
r3 = self.data[0, :, 5]
for node_id, gridtypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(node, gridtype, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
f.write(page_stamp % page_num)
return page_num
def _write_sort1_as_sort1(self, header, page_stamp, page_num, f06_file,
msg_temp):
ntimes = self.data.shape[0]
eids = self.element
#is_odd = False
#nwrite = len(eids)
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
axial = self.data[itime, :, 0]
eqs = self.data[itime, :, 1]
total = self.data[itime, :, 2]
epcs = self.data[itime, :, 3]
ecs = self.data[itime, :, 4]
lts = self.data[itime, :, 5]
#print "dt=%s axials=%s eqs=%s ts=%s epcs=%s ecs=%s lts=%s" %(dt,axial,eqs,ts,epcs,ecs,lts)
#msgE[eid] = ' ELEMENT-ID = %8i\n' % (eid)
#if eid not in msgT:
#msgT[eid] = []
#msgT[eid].append(' %9.3E %13.6E %13.6E %13.6E %13.6E %13.6E %13.6E\n' % (dt, axial, eqs, ts, epcs, ecs, lts))
for eid, axiali, eqsi, totali, epcsi, ecsi, ltsi in zip(
eids, axial, eqs, total, epcs, ecs, lts):
([saxial, seqs, stotal, sepcs, secs, slts]) = write_floats_13e(
[axiali, eqsi, totali, epcsi, ecsi, ltsi])
f06_file.write(
' %8i %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, saxial, seqs, stotal, sepcs, secs, slts))
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def _write_sort1_as_sort1(self, f, page_num, page_stamp, header, words):
nodes = self.node_gridtype[:, 0]
gridtypes = self.node_gridtype[:, 1]
times = self._times
for itime in range(self.ntimes):
dt = self._times[itime]
t1 = self.data[itime, :, 0]
t2 = self.data[itime, :, 1]
t3 = self.data[itime, :, 2]
r1 = self.data[itime, :, 3]
r2 = self.data[itime, :, 4]
r3 = self.data[itime, :, 5]
if isinstance(dt, (float, float32)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f.write(''.join(header + words))
for node_id, gridtypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(nodes, gridtypes, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
if sgridtype == 'G':
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
elif sgridtype == 'S':
f.write('%14i %6s %s\n' % (node_id, sgridtype, dx))
elif sgridtype == 'H':
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
elif sgridtype == 'L':
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (node_id, sgridtype, dx, dy, dz, rx, ry, rz))
else:
raise NotImplementedError(sgridtype)
f.write(page_stamp % page_num)
page_num += 1
return page_num
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s', page_num=1,
is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
#comp_x, shear_y, shear_z, axial_u, shear_v, shear_w, slip_v, slip_w
comp_x = self.data[itime, :, 0]
shear_y = self.data[itime, :, 1]
shear_z = self.data[itime, :, 2]
axial_u = self.data[itime, :, 3]
shear_v = self.data[itime, :, 4]
shear_w = self.data[itime, :, 5]
slip_v = self.data[itime, :, 6]
slip_w = self.data[itime, :, 7]
for (i, eid, comp_xi, shear_yi, shear_zi, axial_ui, shear_vi, shear_wi, slip_vi, slip_wi) in zip(
count(), eids, comp_x, shear_y, shear_z, axial_u, shear_v, shear_w, slip_v, slip_w):
vals = [comp_xi, shear_yi, shear_zi, axial_ui, shear_vi, shear_wi, slip_vi, slip_wi]
vals2 = write_floats_13e(vals)
[comp_xi, shear_yi, shear_zi, axial_ui,
shear_vi, shear_wi, slip_vi, slip_wi] = vals2
f06_file.write(
'0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, comp_xi, shear_yi, shear_zi, axial_ui,
shear_vi, shear_wi, slip_vi, slip_wi))
f06_file.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor in (None, np.nan):
page_num -= 1
return page_num
def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
ntimes = self.data.shape[0]
eids = self.element
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
#[element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed]
element_force = self.data[itime, :, 0]
axial_displacement = self.data[itime, :, 1]
axial_velocity = self.data[itime, :, 2]
axial_stress = self.data[itime, :, 3]
axial_strain = self.data[itime, :, 4]
plastic_strain = self.data[itime, :, 5]
is_failed = self.is_failed[itime, :, 0]
for (i, eid, element_forcei, axial_displacementi, axial_velocityi, axial_stressi, axial_straini, plastic_straini, is_failedi) in zip(
count(), eids, element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed):
vals = [element_forcei, axial_displacementi, axial_velocityi, axial_stressi, axial_straini, plastic_straini, is_failedi]
vals2 = write_floats_13e(vals)
[element_forcei, axial_displacementi, axial_velocityi, axial_stressi, axial_straini, plastic_straini, is_failedi] = vals2
f06_file.write(
'0%8i %-13s %-13s %-13s %-13s %-13s %-13s %s\n'
% (eid, element_forcei, axial_displacementi, axial_velocityi, axial_stressi,
axial_straini, plastic_straini, is_failedi))
f06_file.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor in (None, np.nan):
page_num -= 1
return page_num
def _write_f06_block(self,
words,
header,
page_stamp,
page_num,
f06_file,
write_words,
is_mag_phase=False,
is_sort1=True):
if write_words:
words += [
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n'
]
#words += self.getTableMarker()
f06_file.write(''.join(header + words))
node = self.node_gridtype[:, 0]
gridtype = self.node_gridtype[:, 1]
t1 = self.data[0, :, 0]
t2 = self.data[0, :, 1]
t3 = self.data[0, :, 2]
r1 = self.data[0, :, 3]
r2 = self.data[0, :, 4]
r3 = self.data[0, :, 5]
for node_id, gridtypei, t1i, t2i, t3i, r1i, r2i, r3i in zip(
node, gridtype, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
vals2 = write_floats_13e(vals)
(dx, dy, dz, rx, ry, rz) = vals2
f06_file.write(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' %
(node_id, sgridtype, dx, dy, dz, rx, ry, rz))
f06_file.write(page_stamp % page_num)
return page_num
def _write_sort1_as_sort1(self, f06_file, page_num, page_stamp, header,
words):
nodes = self.node_gridtype[:, 0]
gridtypes = self.node_gridtype[:, 1]
#times = self._times
for itime in range(self.ntimes):
dt = self._times[itime]
t1 = self.data[itime, :, 0]
if isinstance(dt, (float, float32)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
f06_file.write(''.join(header + words))
for node_id, gridtypei, t1i in zip(nodes, gridtypes, t1):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i]
vals2 = write_floats_13e(vals)
dx = vals2[0]
if sgridtype == 'G':
f06_file.write('%14i %6s %s\n' %
(node_id, sgridtype, dx))
elif sgridtype == 'S':
f06_file.write('%14i %6s %s\n' %
(node_id, sgridtype, dx))
elif sgridtype == 'H':
f06_file.write('%14i %6s %s\n' %
(node_id, sgridtype, dx))
elif sgridtype == 'L':
f06_file.write('%14i %6s %s\n' %
(node_id, sgridtype, dx))
else:
raise NotImplementedError(sgridtype)
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num
def write_f06(self, f, header=None, page_stamp="PAGE %s", page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg_start = [
" ELEMENT-ID = 129\n"
" N O N L I N E A R S T R E S S E S I N Q U A D R I L A T E R A L E L E M E N T S ( Q U A D 4 )\n"
" \n",
" TIME FIBER STRESSES/ TOTAL STRAINS EQUIVALENT EFF. STRAIN EFF. CREEP\n"
" DISTANCE X Y Z XY STRESS PLASTIC/NLELAST STRAIN\n",
]
# 0 5.000E-05 -5.000000E-01 -4.484895E+01 -1.561594E+02 -2.008336E-02 1.392609E+02 0.0 0.0
msg_element = {}
msg_time = {}
for (dt, Oxxs) in sorted(iteritems(self.oxx)):
header[1] = " %s = %10.4E\n" % (self.data_code["name"], dt)
for (eid, oxxs) in sorted(iteritems(Oxxs)):
msg_element[eid] = header + [" ELEMENT-ID = %8i\n" % (eid)]
if eid not in msg_time:
msg_time[eid] = []
for i, oxx in enumerate(oxxs):
fd = self.fiberDistance[dt][eid][i]
oxx = self.oxx[dt][eid][i]
oyy = self.oyy[dt][eid][i]
ozz = self.ozz[dt][eid][i]
txy = self.txy[dt][eid][i]
exx = self.exx[dt][eid][i]
eyy = self.eyy[dt][eid][i]
ezz = self.ezz[dt][eid][i]
exy = self.exy[dt][eid][i]
es = self.es[dt][eid][i]
eps = self.eps[dt][eid][i]
ecs = self.ecs[dt][eid][i]
[oxx, oyy, ozz, txy, exx, eyy, es, eps, ecs, exx, eyy, ezz, exy] = write_floats_13e(
[oxx, oyy, ozz, txy, exx, eyy, es, eps, ecs, exx, eyy, ezz, exy]
)
if i == 0:
msg_time[eid].append(
"0 %9.3E %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n"
% (dt, fd, oxx, oyy, ozz, txy, es, eps, ecs)
)
else:
msg_time[eid].append(
" %9s %-13s %-13s %-13s %-13s %-13s\n" % ("", "", exx, eyy, ezz, exy)
)
msg = []
for eid, e in sorted(iteritems(msg_element)):
msg += header + e + msg_start + msg_time[eid]
msg.append(page_stamp % page_num)
page_num += 1
f.write("".join(msg))
return page_num - 1
def write_f06(self,
f06_file,
header=None,
page_stamp: str = 'PAGE %s',
page_num: int = 1,
is_mag_phase: bool = False,
is_sort1: bool = True):
if header is None:
header = []
nnodes, msg_temp = _get_f06_header_nnodes(self, is_mag_phase)
# write the f06
ntimes = self.data.shape[0]
eids2 = self.element_node[:, 0]
nodes = self.element_node[:, 1]
eids3 = self.element_cid[:, 0]
cids3 = self.element_cid[:, 1]
nnodes_expected = self.nnodes
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
oxx = self.data[itime, :, 0]
oyy = self.data[itime, :, 1]
ozz = self.data[itime, :, 2]
txy = self.data[itime, :, 3]
tyz = self.data[itime, :, 4]
txz = self.data[itime, :, 5]
#o1 = self.data[itime, :, 6]
#o2 = self.data[itime, :, 7]
#o3 = self.data[itime, :, 8]
ovm = self.data[itime, :, 6]
#p = (o1 + o2 + o3) / -3.
ennodes = nnodes_expected
for i, deid, node_id, doxx, doyy, dozz, dtxy, dtyz, dtxz, dovm in zip(
count(), eids2, nodes, oxx, oyy, ozz, txy, tyz, txz, ovm):
# o1-max
# o2-mid
# o3-min
#assert do1 >= do2 >= do3, 'o1 >= o2 >= o3; eid=%s o1=%e o2=%e o3=%e' % (deid, do1, do2, do3)
[oxxi, oyyi, ozzi, txyi, tyzi, txzi, ovmi] = write_floats_13e(
[doxx, doyy, dozz, dtxy, dtyz, dtxz, dovm])
assert node_id > 0, node_id
if i % ennodes == 0:
j = where(eids3 == deid)[0][0]
cid = cids3[j]
f06_file.write('0 %8s %8iGRID CS %i GP\n' %
(deid, cid, nnodes))
f06_file.write(
'0 %8s X %-13s XY %-13s %s\n'
' %8s Y %-13s YZ %-13s\n'
' %8s Z %-13s ZX %-13s\n' %
(node_id, oxxi, txyi, ovmi, '', oyyi, tyzi, '', ozzi,
txzi))
else:
f06_file.write(
'0 %8s X %-13s XY %-13s %s\n'
' %8s Y %-13s YZ %-13s\n'
' %8s Z %-13s ZX %-13s\n' % (
node_id,
oxxi,
txyi,
ovmi,
'',
oyyi,
tyzi,
'',
ozzi,
txzi,
))
i += 1
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self,
f06,
header=None,
page_stamp='PAGE %s',
page_num=1,
is_mag_phase=False,
is_sort1=True):
if header is None:
header = []
nnodes, msg_temp = _get_f06_header_nnodes(self, is_mag_phase)
# write the f06
ntimes = self.data.shape[0]
eids2 = self.element_node[:, 0]
nodes = self.element_node[:, 1]
eids3 = self.element_cid[:, 0]
cids3 = self.element_cid[:, 1]
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06.write(''.join(header + msg_temp))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
oxx = self.data[itime, :, 0]
oyy = self.data[itime, :, 1]
ozz = self.data[itime, :, 2]
txy = self.data[itime, :, 3]
tyz = self.data[itime, :, 4]
txz = self.data[itime, :, 5]
o1 = self.data[itime, :, 6]
o2 = self.data[itime, :, 7]
o3 = self.data[itime, :, 8]
ovm = self.data[itime, :, 9]
p = (o1 + o2 + o3) / -3.
cnnodes = nnodes + 1
for i, deid, node_id, doxx, doyy, dozz, dtxy, dtyz, dtxz, do1, do2, do3, dp, dovm in zip(
count(), eids2, nodes, oxx, oyy, ozz, txy, tyz, txz, o1,
o2, o3, p, ovm):
j = where(eids3 == deid)[0]
cid = cids3[j]
A = [[doxx, dtxy, dtxz], [dtxy, doyy, dtyz],
[dtxz, dtyz, dozz]]
(Lambda,
v) = eigh(A) # a hermitian matrix is a symmetric-real matrix
# o1-max
# o2-mid
# o3-min
assert do1 >= do2 >= do3, 'o1 >= o2 >= o3; eid=%s o1=%e o2=%e o3=%e' % (
deid, do1, do2, do3)
[oxxi, oyyi, ozzi, txyi, tyzi, txzi, o1i, o2i, o3i, pi,
ovmi] = write_floats_13e([
doxx, doyy, dozz, dtxy, dtyz, dtxz, do1, do2, do3, dp,
dovm
])
if i % cnnodes == 0:
f06.write('0 %8s %8iGRID CS %i GP\n' %
(deid, cid, nnodes))
f06.write(
'0 %8s X %-13s XY %-13s A %-13s LX%5.2f%5.2f%5.2f %-13s %s\n'
' %8s Y %-13s YZ %-13s B %-13s LY%5.2f%5.2f%5.2f\n'
' %8s Z %-13s ZX %-13s C %-13s LZ%5.2f%5.2f%5.2f\n'
% ('CENTER', oxxi, txyi, o1i, v[0, 1], v[0, 2],
v[0, 0], pi, ovmi, '', oyyi, tyzi, o2i, v[1, 1],
v[1, 2], v[1, 0], '', ozzi, txzi, o3i, v[2, 1],
v[2, 2], v[2, 0]))
else:
f06.write(
'0 %8s X %-13s XY %-13s A %-13s LX%5.2f%5.2f%5.2f %-13s %s\n'
' %8s Y %-13s YZ %-13s B %-13s LY%5.2f%5.2f%5.2f\n'
' %8s Z %-13s ZX %-13s C %-13s LZ%5.2f%5.2f%5.2f\n'
% (node_id, oxxi, txyi, o1i, v[0, 1], v[0, 2], v[0, 0],
pi, ovmi, '', oyyi, tyzi, o2i, v[1, 1], v[1, 2],
v[1, 0], '', ozzi, txzi, o3i, v[2, 1], v[2, 2],
v[2, 0]))
i += 1
f06.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_op2(self, op2_file, op2_ascii, itable, new_result, date,
is_mag_phase=False, endian='>'):
"""writes an OP2"""
import inspect
from struct import Struct, pack
frame = inspect.currentframe()
call_frame = inspect.getouterframes(frame, 2)
op2_ascii.write(f'{self.__class__.__name__}.write_op2: {call_frame[1][3]}\n')
if itable == -1:
self._write_table_header(op2_file, op2_ascii, date)
itable = -3
#if isinstance(self.nonlinear_factor, float):
#op2_format = '%sif' % (7 * self.ntimes)
#raise NotImplementedError()
#else:
#op2_format = 'i21f'
#s = Struct(op2_format)
eids = self.element
# table 4 info
#ntimes = self.data.shape[0]
#nnodes = self.data.shape[1]
nelements = self.data.shape[1]
# 21 = 1 node, 3 principal, 6 components, 9 vectors, 2 p/ovm
#ntotal = ((nnodes * 21) + 1) + (nelements * 4)
ntotali = self.num_wide
ntotal = ntotali * nelements
#print('shape = %s' % str(self.data.shape))
#assert self.ntimes == 1, self.ntimes
#device_code = self.device_code
op2_ascii.write(f' ntimes = {self.ntimes}\n')
eids_device = self.element * 10 + self.device_code
#fmt = '%2i %6f'
#print('ntotal=%s' % (ntotal))
#assert ntotal == 193, ntotal
if not self.is_sort1:
raise NotImplementedError('SORT2')
struct1 = Struct(endian + b'i6f')
fdtype = self.data.dtype
if self.size == 4:
pass
else:
print(f'downcasting {self.class_name}...')
#cen_word_bytes = b'CEN/ '
idtype = np.int32(1)
fdtype = np.float32(1.0)
use_numpy = True
data_out = np.empty((nelements, 7), dtype=fdtype)
data_out[:, 0] = eids_device.view(fdtype)
op2_ascii.write(f'nelements={nelements:d}\n')
for itime in range(self.ntimes):
#print('3, %s' % itable)
self._write_table_3(op2_file, op2_ascii, new_result, itable, itime)
# record 4
#print('stress itable = %s' % itable)
itable -= 1
#print('4, %s' % itable)
header = [4, itable, 4,
4, 1, 4,
4, 0, 4,
4, ntotal, 4,
4 * ntotal]
op2_file.write(pack('%ii' % len(header), *header))
op2_ascii.write('r4 [4, 0, 4]\n')
op2_ascii.write(f'r4 [4, {itable:d}, 4]\n')
op2_ascii.write(f'r4 [4, {4 * ntotal:d}, 4]\n')
if use_numpy:
# [eid_device, txi, tyi, tzi, rxi, ryi, rzi]
data_out[:, 1:] = self.data[itime, :, :]
assert data_out.size == ntotal, f'data_out.shape={data_out.shape} size={data_out.size}; ntotal={ntotal}'
op2_file.write(data_out)
else:
tx = self.data[itime, :, 0]
ty = self.data[itime, :, 1]
tz = self.data[itime, :, 2]
rx = self.data[itime, :, 3]
ry = self.data[itime, :, 4]
rz = self.data[itime, :, 5]
for eid, eid_device, txi, tyi, tzi, rxi, ryi, rzi in zip(
eids, eids_device, tx, ty, tz, rx, ry, rz):
data = [eid_device, txi, tyi, tzi, rxi, ryi, rzi]
vals = [txi, tyi, tzi, rxi, ryi, rzi]
vals2 = write_floats_13e(vals)
[txi, tyi, tzi, rxi, ryi, rzi] = vals2
op2_ascii.write('0 %8i %-13s %-13s %-13s %-13s %-13s %s\n' % (
eid, txi, tyi, tzi, rxi, ryi, rzi))
op2_file.write(struct1.pack(*data))
#for eid, axiali, SMai, torsioni, SMti in zip(eids_device, axial, SMa, torsion, SMt):
#data = [eid, axiali, SMai, torsioni, SMti]
#op2_ascii.write(' eid=%s axial=%s SMa=%s torsion=%s SMt=%s\n' % tuple(data))
#op2_file.write(struct1.pack(*data))
itable -= 1
header = [4 * ntotal,]
op2_file.write(pack('i', *header))
op2_ascii.write('footer = %s\n' % header)
new_result = False
return itable
def write_f06(self, f, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True):
if header is None:
header = []
msg_start = [
' ELEMENT-ID = 129\n'
' N O N L I N E A R S T R E S S E S I N Q U A D R I L A T E R A L E L E M E N T S ( Q U A D 4 )\n'
' \n',
' TIME FIBER STRESSES/ TOTAL STRAINS EQUIVALENT EFF. STRAIN EFF. CREEP\n'
' DISTANCE X Y Z XY STRESS PLASTIC/NLELAST STRAIN\n'
]
#0 5.000E-05 -5.000000E-01 -4.484895E+01 -1.561594E+02 -2.008336E-02 1.392609E+02 0.0 0.0
msg_element = {}
msg_time = {}
for (dt, Oxxs) in sorted(iteritems(self.oxx)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
for (eid, oxxs) in sorted(iteritems(Oxxs)):
msg_element[eid] = header + [' ELEMENT-ID = %8i\n' % (eid)]
if eid not in msg_time:
msg_time[eid] = []
for i, oxx in enumerate(oxxs):
fd = self.fiberDistance[dt][eid][i]
oxx = self.oxx[dt][eid][i]
oyy = self.oyy[dt][eid][i]
ozz = self.ozz[dt][eid][i]
txy = self.txy[dt][eid][i]
exx = self.exx[dt][eid][i]
eyy = self.eyy[dt][eid][i]
ezz = self.ezz[dt][eid][i]
exy = self.exy[dt][eid][i]
es = self.es[dt][eid][i]
eps = self.eps[dt][eid][i]
ecs = self.ecs[dt][eid][i]
[oxx, oyy, ozz, txy, exx, eyy, es, eps, ecs, exx, eyy, ezz, exy] = write_floats_13e([oxx, oyy, ozz, txy, exx, eyy, es, eps, ecs, exx, eyy, ezz, exy])
if i == 0:
msg_time[eid].append('0 %9.3E %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (dt, fd, oxx, oyy, ozz, txy, es, eps, ecs))
else:
msg_time[eid].append(' %9s %-13s %-13s %-13s %-13s %-13s\n' % ('', '', exx, eyy, ezz, exy))
msg = []
for eid, e in sorted(iteritems(msg_element)):
msg += header + e + msg_start + msg_time[eid]
msg.append(page_stamp % page_num)
page_num += 1
f.write(''.join(msg))
return page_num - 1
def write_f06(self,
f06_file,
header=None,
page_stamp='PAGE %s',
page_num=1,
is_mag_phase=False,
is_sort1=True):
"""
' S T R A I N S I N B E N D E L E M E N T S ( C B E N D )'
' CIRC.'
' ELEMENT-ID GRID END ANG. SXC SXD SXE SXF S-MAX S-MIN M.S.-T M.S.-C'
'0 6901 6901 A 0 4.372282E-16 -5.960465E-15 0.0 0.0 4.372282E-16 -5.960465E-15 '
' 6902 B 0 -6.533992E-15 5.000001E-07 -5.000000E-13 -5.000000E-13 5.000001E-07 -5.000000E-13 -6.0E-01 6.0E+05'
"""
#raise NotImplementedError('CBEND.stress/strain.real write_f06')
msg_temp = _get_cbend_msg(self.is_stress, is_mag_phase, is_sort1)
ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
counter = cycle([0, 1])
if self.is_sort1:
if is_sort1:
for itime in range(ntimes):
dt = self._times[itime]
if self.nonlinear_factor in (None, np.nan):
dt_line = ''
else:
dt_line = ' %14s = %12.5E\n' % (self.data_code['name'],
dt)
header[1] = dt_line
msg = header + msg_temp
f06_file.write('\n'.join(msg))
# [angle, sc, sd, se, sf]
angles = self.data[itime, :, 0]
scs = self.data[itime, :, 1]
sds = self.data[itime, :, 2]
ses = self.data[itime, :, 3]
sfs = self.data[itime, :, 4]
maxs = self.data[itime, :, 5]
mins = self.data[itime, :, 6]
msts = self.data[itime, :, 7]
mscs = self.data[itime, :, 8]
assert len(eids) == len(angles)
assert len(angles) > 0, angles
for i, eid, nid, anglei, sci, sdi, sei, sfi, maxi, mini, msti, msci in zip(
counter, eids, nids, angles, scs, sds, ses, sfs,
maxs, mins, msts, mscs):
assert isinstance(
eid,
integer_types), 'eid=%s type=%s' % (eid, type(eid))
[angle, sc, sd, se, sf, omax, omin] = write_floats_13e(
[anglei, sci, sdi, sei, sfi, maxi, mini])
[mst, msc] = write_floats_8p1e([msti, msci])
#f.write(' 28 0.0 / 0.0 0.0 / 0.0\n')
#' ELEMENT-ID = 6901'
#' C O M P L E X S T R E S S E S I N B E N D E L E M E N T S ( C B E N D ) '
#' (REAL/IMAGINARY)'
#' CIRC. LOCATION LOCATION LOCATION LOCATION'
#' FREQUENCY GRID END ANG. C D E F'
#'0 0.0 6901 A 0 1.384767E+01 6.258920E-01 -1.217803E+01 1.043753E+00'
#' -4.615430E-01 -2.086098E-02 4.058937E-01 -3.478828E-02'
if i == 0:
f06_file.write(
'0 %9i%8i A %.2f %-13s %-13s %-13s %-13s %-13s %-13s %s %s\n'
% (
eid,
nid,
anglei,
sc,
sd,
se,
sf,
omax,
omin,
mst,
msc,
))
else:
f06_file.write(
' %9s%8i B %.2f %-13s %-13s %-13s %-13s %-13s %-13s %s %s\n'
% (
'',
nid,
anglei,
sc,
sd,
se,
sf,
omax,
omin,
mst,
msc,
))
f06_file.write(page_stamp % page_num)
page_num += 1
else:
raise NotImplementedError('RealBendArray-sort2')
else:
raise NotImplementedError('RealBendArray-sort2')
return page_num - 1
def write_f06(self,
f06_file,
header=None,
page_stamp='PAGE %s',
page_num=1,
is_mag_phase=False,
is_sort1=True):
if header is None:
header = []
msg, nnodes, cen = _get_plate_msg(self)
# write the f06
ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
#cen_word = 'CEN/%i' % nnodes
cen_word = cen
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
#print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
#[fiber_dist, oxx, oyy, txy, angle, majorP, minorP, ovm]
fiber_dist = self.data[itime, :, 0]
oxx = self.data[itime, :, 1]
oyy = self.data[itime, :, 2]
txy = self.data[itime, :, 3]
angle = self.data[itime, :, 4]
major_principal = self.data[itime, :, 5]
minor_principal = self.data[itime, :, 6]
ovm = self.data[itime, :, 7]
is_linear = self.element_type in {33, 74, 227, 228, 83}
is_bilinear = self.element_type in {64, 70, 75, 82, 144}
for (i, eid, nid, fdi, oxxi, oyyi, txyi, anglei, major, minor,
ovmi) in zip(count(), eids, nids, fiber_dist, oxx, oyy, txy,
angle, major_principal, minor_principal, ovm):
[fdi, oxxi, oyyi, txyi, major, minor, ovmi] = write_floats_13e(
[fdi, oxxi, oyyi, txyi, major, minor, ovmi])
ilayer = i % 2
# tria3
if is_linear: # CQUAD4, CTRIA3, CTRIAR linear, CQUADR linear
if ilayer == 0:
f06_file.write(
'0 %6i %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n'
% (eid, fdi, oxxi, oyyi, txyi, anglei, major,
minor, ovmi))
else:
f06_file.write(
' %6s %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n'
% ('', fdi, oxxi, oyyi, txyi, anglei, major, minor,
ovmi))
elif is_bilinear: # CQUAD8, CTRIAR, CTRIA6, CQUADR, CQUAD4
# bilinear
if nid == 0 and ilayer == 0: # CEN
f06_file.write(
'0 %8i %8s %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n'
% (eid, cen_word, fdi, oxxi, oyyi, txyi, anglei,
major, minor, ovmi))
elif ilayer == 0:
f06_file.write(
' %8s %8i %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n'
% ('', nid, fdi, oxxi, oyyi, txyi, anglei, major,
minor, ovmi))
elif ilayer == 1:
f06_file.write(
' %8s %8s %-13s %-13s %-13s %-13s %8.4f %-13s %-13s %s\n\n'
% ('', '', fdi, oxxi, oyyi, txyi, anglei, major,
minor, ovmi))
else: # pragma: no cover
msg = 'element_name=%s self.element_type=%s' % (
self.element_name, self.element_type)
raise NotImplementedError(msg)
f06_file.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self,
f06_file,
header=None,
page_stamp='PAGE %s',
page_num=1,
is_mag_phase=False,
is_sort1=True):
if header is None:
header = []
msg = self._get_msgs()
ntimes = self.data.shape[0]
eids = self.element_node[:, 0]
nids = self.element_node[:, 1]
locs = self.element_node[:, 2]
#xxbs = self.xxb
#print('CBEAM ntimes=%s ntotal=%s' % (ntimes, ntotal))
loc_map = [
'C',
'D',
'E',
'F',
'C',
'D',
'E',
'F',
]
for itime in range(ntimes):
dt = self._times[itime]
header = _eigenvalue_header(self, header, itime, ntimes, dt)
f06_file.write(''.join(header + msg))
longs = self.data[itime, :, 0]
eqss = self.data[itime, :, 1]
tes = self.data[itime, :, 2]
epss = self.data[itime, :, 3]
ecss = self.data[itime, :, 4]
#msg = [' N O N L I N E A R S T R E S S E S I N B E A M E L E M E N T S ( C B E A M )\n',
#' \n',
#' ELEMENT GRID POINT STRESS EQUIVALENT TOTAL STRAIN EFF. STRAIN EFF. CREEP\n',
#' ID ID STRESS PLASTIC/NLELAST STRAIN\n',]
#'0 1 1 C 1.738817E+03 1.738817E+03 5.796055E-05 0.0 0.0\n',
#' D 1.229523E+03 1.229523E+03 4.098411E-05 0.0 0.0\n',
for (eid, nid, loc, longi, eqs, te, eps,
ecs) in zip(eids, nids, locs, longs, eqss, tes, epss, ecss):
vals = [longi, eqs, te, eps, ecs]
vals2 = write_floats_13e(vals)
[longi, eqs, te, eps, ecs] = vals2
if loc == 0:
f06_file.write(
'0 %14i %8i %4s %13s %13s %13s %13s %s\n'
% (eid, nid, 'C', longi, eqs, te, eps, ecs.rstrip()))
elif loc == 4:
f06_file.write(
' %14s %8i %4s %13s %13s %13s %13s %s\n'
% ('', nid, 'C', longi, eqs, te, eps, ecs.rstrip()))
else:
loci = loc_map[loc]
f06_file.write(
' %14s %8s %4s %13s %13s %13s %13s %s\n'
% ('', '', loci, longi, eqs, te, eps, ecs.rstrip()))
f06_file.write(page_stamp % page_num)
page_num += 1
if self.nonlinear_factor in (None, np.nan):
page_num -= 1
return page_num
