def _write_f06_springs_transient(f, stress, header, words, name):
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, is_all_zeros = writeFloats13E(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, is_all_zeros = writeFloats13E(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_f06_springs_transient(f, stress, header, words, name):
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, is_all_zeros = writeFloats13E(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, is_all_zeros = writeFloats13E(stresses)
for eid, stress in zip(eids, stresses):
line += '%10i %13s ' % (eid, stress)
f.write(line.rstrip() + '\n')
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def _write_f06_transient(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False):
words = [' C O M P L E X L O A D V E C T O R\n',
' (REAL/IMAGINARY)\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
#return self.__write_f06_transient_block(words,header,page_stamp,page_num,f,is_mag_phase)
for dt, translations in sorted(iteritems(self.translations)):
header[2] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
f.write(''.join(header + words))
for nodeID, translation in sorted(iteritems(translations)):
rotation = self.rotations[dt][nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
if is_mag_phase:
dxr = abs(dx)
dxi = angle(dx, deg=True)
dyr = abs(dy)
dyi = angle(dy, deg=True)
dzr = abs(dz)
dzi = angle(dz, deg=True)
rxr = abs(rx)
rxi = angle(rx, deg=True)
ryr = abs(ry)
ryi = angle(ry, deg=True)
rzr = abs(rz)
rzi = angle(rz, deg=True)
else:
dxr = dx.real
dyr = dy.real
dzr = dz.real
dxi = dx.imag
dyi = dy.imag
dzi = dz.imag
rxr = rx.real
ryr = ry.real
rzr = rz.real
rxi = rx.imag
ryi = ry.imag
rzi = rz.imag
vals = [dxr, dyr, dzr, rxr, ryr, rzr,
dxi, dyi, dzi, rxi, ryi, rzi]
(vals2, is_all_zeros) = writeFloats13E(vals)
[dxr, dyr, dzr, rxr, ryr, rzr,
dxi, dyi, dzi, rxi, ryi, rzi] = vals2
#if not is_all_zeros:
f.write('0 %12i %6s %-13s %-13s %-13s %-13s %-13s %s\n'
' %12s %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
nodeID, grid_type, dxr, dyr, dzr, rxr, ryr, rzr,
'', '', dxi, dyi, dzi, rxi, ryi, rzi))
f.write(page_stamp % page_num)
page_num += 1
return page_num - 1
def _write_f06_transient(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
words = [
' S T R A I N S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRAIN SB-MAX SB-MIN M.S.-C\n',
]
msg = []
for dt, E1s in sorted(self.e1.iteritems()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for eid, e1s in sorted(E1s.iteritems()):
eType = self.eType[eid]
axial = self.axial[eid]
e1 = self.e1[eid]
e2 = self.e2[eid]
e3 = self.e3[eid]
e4 = self.e4[eid]
vals = [e1[0], e2[0], e3[0], e4[0], axial,
e1[1], e2[1], e3[1], e4[1]]
(vals2, is_all_zeros) = writeFloats13E(vals)
[e10, e20, e30, e40,
e11, e21, e31, e41] = vals2
msg.append('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (eid, e10, e20, e30, e40, axial))
msg.append(' %8s %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % ('', e11, e21, e31, e41))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def _write_f06_transient(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
words = [' S T R E S S E S I N R O D E L E M E N T S ( C R O D )\n',
' ELEMENT AXIAL SAFETY TORSIONAL SAFETY ELEMENT AXIAL SAFETY TORSIONAL SAFETY\n',
' ID. STRESS MARGIN STRESS MARGIN ID. STRESS MARGIN STRESS MARGIN\n']
msg = []
for dt, axials in sorted(self.axial.iteritems()):
dtLine = '%14s = %12.5E\n' % (self.data_code['name'], dt)
header[2] = dtLine
msg += header + words
out = []
for eid in sorted(axials):
axial = self.axial[dt][eid]
MSa = self.MS_axial[dt][eid]
torsion = self.torsion[dt][eid]
MSt = self.MS_torsion[dt][eid]
(vals2, is_all_zeros) = writeFloats13E([axial, torsion])
(axial, torsion) = vals2
out.append([eid, axial, MSa, torsion, MSt])
nOut = len(out)
nWrite = nOut
if nOut % 2 == 1:
nWrite = nOut - 1
for i in xrange(0, nWrite, 2):
outLine = ' %8i %13s %10.4E %13s %10.4E %8i %13s %10.4E %13s %10.4E\n' % (tuple(out[i] + out[i + 1]))
msg.append(outLine)
if nOut % 2 == 1:
outLine = ' %8i %13s %10.4E %13s %10.4E\n' % (tuple(out[-1]))
msg.append(outLine)
msg.append(pageStamp % page_num)
f.write(''.join(msg))
page_num += 1
return page_num - 1
def write_f06(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, page_num, f)
msg = header + [' S T R A I N S I N B E A M E L E M E N T S ( C B E A M )\n',
' STAT DIST/\n',
' ELEMENT-ID GRID LENGTH SXC SXD SXE SXF S-MAX S-MIN M.S.-T M.S.-C\n']
for eid in sorted(self.smax):
msg.append('0 %8i\n' % eid)
#print self.xxb[eid]
#print("self.grids =", self.grids)
#print("eid =", eid)
for i, nid in enumerate(self.grids[eid]):
xxb = self.xxb[eid][i]
sxc = self.sxc[eid][i]
sxd = self.sxd[eid][i]
sxe = self.sxe[eid][i]
sxf = self.sxf[eid][i]
sMax = self.smax[eid][i]
sMin = self.smin[eid][i]
SMt = self.MS_tension[eid][i]
SMc = self.MS_compression[eid][i]
(vals2, is_all_zeros) = writeFloats13E([
sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc])
(sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc) = vals2
msg.append('%19s %4.3f %12s %12s %12s %12s %12s %12s %12s %s\n' % (nid, xxb, sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self,
header,
pageStamp,
page_num=1,
f=None,
is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, page_num, f)
msg = header + [
' L O A D V E C T O R\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n'
]
f.write(''.join(msg))
for nodeID, translation in sorted(iteritems(self.translations)):
rotation = self.rotations[nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
#if not is_all_zeros:
[dx, dy, dz, rx, ry, rz] = vals2
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' %
(nodeID, grid_type, dx, dy, dz, rx, ry, rz))
f.write(pageStamp % page_num)
return page_num
def write_f06(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False):
assert f is not None
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, page_stamp, page_num, f, is_mag_phase)
msg = header + [' F O R C E S O F M U L T I - P O I N T C O N S T R A I N T\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
raise RuntimeError('is this valid...')
for nodeID, translation in sorted(iteritems(self.translations)):
rotation = self.rotations[nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
#dxr=dx.real; dyr=dy.real; dzr=dz.real;
#dxi=dx.imag; dyi=dy.imag; dzi=dz.imag
(rx, ry, rz) = rotation
#rxr=rx.real; ryr=ry.real; rzr=rz.real
#rxi=rx.imag; ryi=ry.imag; rzi=rz.imag
#vals = [dxr,dyr,dzr,rxr,ryr,rzr,dxi,dyi,dzi,rxi,ryi,rzi]
vals = list(translation) + list(rotation)
(vals2, is_all_zeros) = writeFloats13E(vals)
#if not is_all_zeros:
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (nodeID, grid_type, dx, dy, dz, rx, ry, rz))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self,
f,
header,
pageStamp,
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.extractionOrder)):
eigr = self.eigenvalues[iMode]
omega = self.omegas[iMode]
freq = self.freqs[iMode]
mass = self.generalized_mass[iMode]
stiff = self.generalized_stiffness[iMode]
([eigr, freq, omega, mass, stiff],
is_all_zeros) = writeFloats13E([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(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def _write_f06_transient(self, header, pageStamp,
page_num=1, f=None, is_mag_phase=False):
words = [' S T R E S S E S I N T R I A X 6 E L E M E N T S\n',
' ELEMENT GRID ID STRESSES IN MATERIAL COORD SYSTEM MAX MAG MAX VON MISES \n',
' ID RADIAL AZIMUTHAL AXIAL SHEAR PRINCIPAL SHEAR\n', ]
#' 5351 0 -9.726205E+02 -1.678908E+03 -1.452340E+03 -1.325111E+02 -1.678908E+03 3.702285E+02 6.654553E+02
#' 4389 -9.867789E+02 -1.624276E+03 -1.388424E+03 -9.212539E+01 -1.624276E+03 3.288099E+02 5.806334E+02
msg = []
for dt, Radial in sorted(self.radial.iteritems()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for eid, radial in sorted(Radial.iteritems()):
for nid in sorted(radial):
rad = self.radial[dt][eid][nid]
azimuth = self.azimuthal[dt][eid][nid]
axial = self.axial[dt][eid][nid]
shear = self.shear[dt][eid][nid]
omax = self.omax[dt][eid][nid]
oms = self.oms[dt][eid][nid]
ovm = self.ovm[dt][eid][nid]
if nid == 0:
Eid = eid
else:
Eid = ''
([rad, azimuth, axial, shear, omax, oms, ovm], is_all_zeros) = writeFloats13E([rad, azimuth, axial, shear, omax, oms, ovm])
msg.append(' %8s %8s %s %s %s %s %s %s %-s\n' % (Eid, nid, rad, azimuth, axial, shear, omax, oms, ovm.rstrip()))
msg.append('\n')
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
if self.isTransient:
return self._write_f06_transient(header, pageStamp, pageNum, f)
msg = header + [
' S T R A I N S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRAIN SB-MAX SB-MIN M.S.-C\n',
]
for eid, E1s in sorted(self.e1.items()):
#eType = self.eType[eid]
axial = self.axial[eid]
#MSt = self.MSt[eid]
#MSc = self.MSc[eid]
MSt = ''
MSc = ''
e1 = self.e1[eid]
e2 = self.e2[eid]
e3 = self.e3[eid]
e4 = self.e4[eid]
emax = self.emax[eid]
emin = self.emin[eid]
vals = [e1[0], e2[0], e3[0], e4[0], axial, emax[0], emin[0],
e1[1], e2[1], e3[1], e4[1], emax[1], emin[1]]
(vals2, isAllZeros) = writeFloats13E(vals)
[e10, e20, e30, e40, axial, emax0, emin0,
e11, e21, e31, e41, emax1, emin1] = vals2
msg.append('0%8i %13s %13s %13s %13s %13s %13s %13s %-s\n' % (eid, e10, e20, e30, e40, axial, emax0, emin0, MSt.rstrip()))
msg.append(' %8s %13s %13s %13s %13s %13s %13s %13s %-s\n' % ('', e11, e21, e31, e41, '', emax1, emin1, MSc.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
return (''.join(msg), pageNum)
def write_f06(self,
f,
header,
pageStamp,
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.extractionOrder)):
eigr = self.eigenvalues[iMode][0]
eigi = self.eigenvalues[iMode][1]
freq = self.cycles[iMode]
damping = self.damping[iMode]
([eigr, eigi, freq, damping],
is_all_zeros) = writeFloats13E([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(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def _write_f06_transient(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
words = [
' S T R E S S E S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRESS SB-MAX SB-MIN M.S.-C\n',
]
msg = []
for dt, S1s in sorted(self.s1.items()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for eid, S1 in sorted(S1s.items()):
#eType = self.eType[eid]
axial = self.axial[dt][eid]
#MSt = self.MSt[eid]
#MSc = self.MSc[eid]
MSt = ''
MSc = ''
s1 = self.s1[dt][eid]
s2 = self.s2[dt][eid]
s3 = self.s3[dt][eid]
s4 = self.s4[dt][eid]
smax = self.smax[dt][eid]
smin = self.smin[dt][eid]
vals = [s1[0], s2[0], s3[0], s4[0], axial, smax[0], smin[0],
s1[1], s2[1], s3[1], s4[1], smax[1], smin[1]]
(vals2, isAllZeros) = writeFloats13E(vals)
[s1a, s2a, s3a, s4a, axial, smaxa, smina,
s1b, s2b, s3b, s4b, smaxb, sminb] = vals2
msg.append('0%8i %13s %13s %13s %13s %13s %13s %13s %-s\n' % (eid, s1a, s2a, s3a, s4a, axial, smaxa, smina, MSt.rstrip()))
msg.append(' %8s %13s %13s %13s %13s %13s %13s %13s %-s\n' % ('', s1b, s2b, s3b, s4b, '', smaxb, sminb, MSc.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
pageNum += 1
return (''.join(msg), pageNum - 1)
def write_f06(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, pageNum, f)
msg = header + [
' S T R E S S E S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRESS SB-MAX SB-MIN M.S.-C\n',
]
for eid, S1s in sorted(self.s1.items()):
#eType = self.eType[eid]
axial = self.axial[eid]
#MSt = self.MSt[eid]
#MSc = self.MSc[eid]
MSt = ''
MSc = ''
s1 = self.s1[eid]
s2 = self.s2[eid]
s3 = self.s3[eid]
s4 = self.s4[eid]
smax = self.smax[eid]
smin = self.smin[eid]
vals = [s1[0], s2[0], s3[0], s4[0], axial, smax[0], smin[0],
s1[1], s2[1], s3[1], s4[1], smax[1], smin[1]]
(vals2, isAllZeros) = writeFloats13E(vals)
[s1a, s2a, s3a, s4a, axial, smaxa, smina,
s1b, s2b, s3b, s4b, smaxb, sminb] = vals2
msg.append('0%8i %13s %13s %13s %13s %13s %13s %13s %-s\n' % (eid, s1a, s2a, s3a, s4a, axial, smaxa, smina, MSt.rstrip()))
msg.append(' %8s %13s %13s %13s %13s %13s %13s %13s %-s\n' % ('', s1b, s2b, s3b, s4b, '', smaxb, sminb, MSc.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
return (''.join(msg), pageNum)
def _write_f06_transient(self,
header,
pageStamp,
page_num=1,
f=None,
is_mag_phase=False):
words = [
' L O A D V E C T O R\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n'
]
for dt, translations in sorted(iteritems(self.translations)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
f.write(''.join(header + words))
for nodeID, translation in sorted(iteritems(translations)):
rotation = self.rotations[dt][nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
#if not is_all_zeros:
[dx, dy, dz, rx, ry, rz] = vals2
f.write(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' %
(nodeID, grid_type, dx, dy, dz, rx, ry, rz))
f.write(pageStamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
"""
::
EIGENVALUE = 6.158494E+07
R E A L E I G E N V E C T O R N O . 1
POINT ID. TYPE T1 T2 T3 R1 R2 R3
1 G 2.547245E-17 -6.388945E-16 2.292728E+00 -1.076928E-15 2.579163E-17 0.0
2002 G -6.382321E-17 -1.556607E-15 3.242408E+00 -6.530917E-16 1.747180E-17 0.0
2003 G 0.0 0.0 0.0 0.0 0.0 0.0
"""
msg = []
#print self.data_code
for i, (iMode, eigVals) in enumerate(sorted(iteritems(self.translations))):
msg += header
freq = self.eigrs[i]
msg.append('%16s = %12E\n' % ('EIGENVALUE', freq))
msg.append(' R E A L E I G E N V E C T O R N O . %10i\n \n' % (iMode))
msg.append(' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n')
for nodeID, translation in sorted(iteritems(eigVals)):
rotation = self.rotations[iMode][nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (nodeID, grid_type, dx, dy, dz, rx, ry, rz))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, pageNum, f, is_mag_phase)
msg = header + [' F O R C E S O F M U L T I - P O I N T C O N S T R A I N T\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
raise RuntimeError('is this valid...')
for nodeID, translation in sorted(self.translations.items()):
rotation = self.rotations[nodeID]
gridType = self.gridTypes[nodeID]
(dx, dy, dz) = translation
#dxr=dx.real; dyr=dy.real; dzr=dz.real;
#dxi=dx.imag; dyi=dy.imag; dzi=dz.imag
(rx, ry, rz) = rotation
#rxr=rx.real; ryr=ry.real; rzr=rz.real
#rxi=rx.imag; ryi=ry.imag; rzi=rz.imag
#vals = [dxr,dyr,dzr,rxr,ryr,rzr,dxi,dyi,dzi,rxi,ryi,rzi]
vals = list(translation) + list(rotation)
(vals2, isAllZeros) = writeFloats13E(vals)
if not isAllZeros:
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %13s %13s %13s %13s %13s %-s\n' % (nodeID, gridType, dx, dy, dz, rx, ry, rz.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
return (''.join(msg), pageNum)
def _write_f06_transient(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
words = [' S T R A I N S I N B E A M E L E M E N T S ( C B E A M )\n',
' STAT DIST/\n',
' ELEMENT-ID GRID LENGTH SXC SXD SXE SXF S-MAX S-MIN M.S.-T M.S.-C\n']
msg = []
for dt, SMaxs in sorted(self.smax.items()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for eid, Smax in sorted(SMaxs.items()):
msg.append('0 %8i\n' % (eid))
for i, nid in enumerate(self.grids[eid]):
xxb = self.xxb[eid][i]
sxc = self.sxc[dt][eid][i]
sxd = self.sxd[dt][eid][i]
sxe = self.sxe[dt][eid][i]
sxf = self.sxf[dt][eid][i]
sMax = self.smax[dt][eid][i]
sMin = self.smin[dt][eid][i]
SMt = self.MS_tension[dt][eid][i]
SMc = self.MS_compression[dt][eid][i]
(vals2, isAllZeros) = writeFloats13E([sxc, sxd,
sxe, sxf, sMax, sMin, SMt, SMc])
(sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc) = vals2
msg.append('%19s %4.3f %12s %12s %12s %12s %12s %12s %12s %s\n' % (nid, xxb, sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc.strip()))
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
pageNum += 1
return (''.join(msg), pageNum - 1)
def _write_f06_transient_block(self, words, header, pageStamp, page_num=1, f=None):
msg = []
#assert f is not None # remove
for dt, translations in sorted(self.translations.iteritems()):
if isinstance(dt, float): # fix
#header[1] = ' %s = %10.4E float %s\n' % (self.data_code['name'], dt, self.analysis_code)
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
#header[1] = ' %s = %10i integer %s\n' % (self.data_code['name'], dt, self.analysis_code)
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
msg += header + words
for nodeID, translation in sorted(translations.iteritems()):
rotation = self.rotations[dt][nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
#if not is_all_zeros:
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (nodeID, grid_type, dx, dy, dz, rx, ry, rz))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self, f, header, pageStamp, 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.extractionOrder)):
eigenvalue = self.eigenvalues[iMode]
#cycle = sqrt(abs(eigenvalue)) / (2. * pi)
omega = self.radians[iMode]
freq = self.cycles[iMode]
mass = self.generalizedMass[iMode]
stiff = self.generalizedStiffness[iMode]
([eigen, omega, freq, mass, stiff], is_all_zeros) = writeFloats13E(
[eigenvalue, omega, freq, mass, stiff])
msg.append(
' %8s %8s %-13s %-13s %-13s %-13s %s\n'
% (iMode, order, eigen, omega, freq, mass, stiff))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
"""
::
EIGENVALUE = 6.158494E+07
R E A L E I G E N V E C T O R N O . 1
POINT ID. TYPE T1 T2 T3 R1 R2 R3
1 G 2.547245E-17 -6.388945E-16 2.292728E+00 -1.076928E-15 2.579163E-17 0.0
2002 G -6.382321E-17 -1.556607E-15 3.242408E+00 -6.530917E-16 1.747180E-17 0.0
2003 G 0.0 0.0 0.0 0.0 0.0 0.0
"""
msg = []
#print self.data_code
for i, (iMode, eigVals) in enumerate(sorted(self.translations.iteritems())):
msg += header
freq = self.eigrs[i]
msg.append('%16s = %12E\n' % ('EIGENVALUE', freq))
msg.append(' R E A L E I G E N V E C T O R N O . %10i\n \n' % (iMode))
msg.append(' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n')
for nodeID, translation in sorted(eigVals.iteritems()):
rotation = self.rotations[iMode][nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (nodeID, grid_type, dx, dy, dz, rx, ry, rz))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def _write_f06_transient(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
msg = []
words = [' N O N - L I N E A R - F O R C E V E C T O R\n'
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
for dt, translations in sorted(self.translations.iteritems()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for nodeID, translation in sorted(translations.iteritems()):
rotation = self.rotations[dt][nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
if not is_all_zeros:
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (nodeID, grid_type, dx, dy, dz, rx, ry, rz))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
raise NotImplementedError('CBUSH')
return 'BushStress write_f06 not implemented...', pageNum
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, pageNum, f, is_mag_phase)
msg = header + [
' S T R A I N S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRAIN SB-MAX SB-MIN M.S.-C\n',
]
for eid, E1s in sorted(self.e1.items()):
eType = self.eType[eid]
axial = self.axial[eid]
e1 = self.e1[eid]
e2 = self.e2[eid]
e3 = self.e3[eid]
e4 = self.e4[eid]
vals = [e1[0], e2[0], e3[0], e4[0], axial,
e1[1], e2[1], e3[1], e4[1]]
(vals2, isAllZeros) = writeFloats13E(vals)
[e10, e20, e30, e40, axial,
e11, e21, e31, e41] = vals2
msg.append('0%8i %13s %13s %13s %13s %13s %13s %13s %-s\n' % (eid, e10, e20, e30, e40, axial.rstrip()))
msg.append(' %8s %13s %13s %13s %13s %13s %13s %13s %-s\n' % ('', e11, e21, e31, e41.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
return (''.join(msg), pageNum)
def _write_f06_transient(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
msg = []
words = [' L O A D V E C T O R\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
for dt, translations in sorted(self.translations.items()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for nodeID, translation in sorted(translations.items()):
rotation = self.rotations[dt][nodeID]
gridType = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, isAllZeros) = writeFloats13E(vals)
if not isAllZeros:
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %13s %13s %13s %13s %13s %-s\n' % (nodeID, gridType, dx, dy, dz, rx, ry, rz.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
pageNum += 1
return (''.join(msg), pageNum - 1)
def _write_f06_transient(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
raise NotImplementedError('CBUSH')
words = [
' S T R A I N S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRAIN SB-MAX SB-MIN M.S.-C\n',
]
msg = []
for dt, E1s in sorted(self.e1.items()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for eid, e1s in sorted(E1s.items()):
eType = self.eType[eid]
axial = self.axial[eid]
e1 = self.e1[eid]
e2 = self.e2[eid]
e3 = self.e3[eid]
e4 = self.e4[eid]
vals = [e1[0], e2[0], e3[0], e4[0], axial,
e1[1], e2[1], e3[1], e4[1]]
(vals2, isAllZeros) = writeFloats13E(vals)
[e10, e20, e30, e40,
e11, e21, e31, e41] = vals2
msg.append('0%8i %13s %13s %13s %13s %13s %13s %13s %-s\n' % (eid, e10, e20, e30, e40, axial.rstrip()))
msg.append(' %8s %13s %13s %13s %13s %13s %13s %13s %-s\n' % ('', e11, e21, e31, e41.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
pageNum += 1
return (''.join(msg), pageNum - 1)
def write_f06(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False, is_sort1=True):
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]
# loop over all the elements
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, is_all_zeros) = writeFloats13E(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_quad4_bilinear_transient(self, f, itime, n, is_magnitude_phase, cen):
"""
CQUAD4 bilinear
CQUAD8
CTRIAR
CTRIA6
"""
fds = self.fiberCurvature[:, 0]
oxx = self.data[itime, :, 0]
oyy = self.data[itime, :, 1]
txy = self.data[itime, :, 2]
eids = self.element_node[:, 0]
nodes = self.element_node[:, 1]
ilayer0 = True
for eid, node, fd, doxx, doyy, dtxy in zip(eids, nodes, fds, oxx, oyy, txy):
vals, is_all_zeros = writeFloats13E([fd])
fdr = vals[0]
([oxxr, oyyr, txyr,
oxxi, oyyi, txyi,], is_all_zeros) = writeImagFloats13E([doxx, doyy, dtxy], is_magnitude_phase)
if node == 0 and ilayer0:
f.write('0 %8i %8s %-13s %-13s / %-13s %-13s / %-13s %-13s / %s\n' % (eid, cen, fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
elif ilayer0: # TODO: assuming 2 layers?
f.write(' %8s %8i %-13s %-13s / %-13s %-13s / %-13s %-13s / %s\n' % ('', node, fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
else:
f.write(' %8s %8s %-13s %-13s / %-13s %-13s / %-13s %-13s / %s\n\n' % ('', '', fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
ilayer0 = not ilayer0
def _write_f06_transient(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
words = [
' S T R A I N S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRAIN SB-MAX SB-MIN M.S.-C\n',
]
msg = []
for dt, E1s in sorted(iteritems(self.e1)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for eid, e1s in sorted(iteritems(E1s)):
eType = self.eType[eid]
axial = self.axial[eid]
e1 = self.e1[eid]
e2 = self.e2[eid]
e3 = self.e3[eid]
e4 = self.e4[eid]
vals = [e1[0], e2[0], e3[0], e4[0], axial,
e1[1], e2[1], e3[1], e4[1]]
(vals2, is_all_zeros) = writeFloats13E(vals)
[e10, e20, e30, e40,
e11, e21, e31, e41] = vals2
msg.append('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (eid, e10, e20, e30, e40, axial))
msg.append(' %8s %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % ('', e11, e21, e31, e41))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def _write_f06(self, msg, pageStamp, page_num, f):
out = []
for eid in sorted(self.axial):
axial = self.axial[eid]
MSa = self.MS_axial[eid]
torsion = self.torsion[eid]
MSt = self.MS_torsion[eid]
(vals2, is_all_zeros) = writeFloats13E([axial, torsion])
(axial, torsion) = vals2
out.append([eid, axial, MSa, torsion, MSt])
nOut = len(out)
nWrite = nOut
if nOut % 2 == 1:
nWrite = nOut - 1
for i in xrange(0, nWrite, 2):
outLine = ' %8i %13s %10.4E %13s %10.4E %8i %13s %10.4E %13s %10.4E\n' % (
tuple(out[i] + out[i + 1]))
msg.append(outLine)
if nOut % 2 == 1:
outLine = ' %8i %13s %10.4E %13s %10.4E\n' % (tuple(
out[-1]))
msg.append(outLine)
msg.append(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def _write_f06_transient(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
words = [' S T R A I N S I N B E A M E L E M E N T S ( C B E A M )\n',
' STAT DIST/\n',
' ELEMENT-ID GRID LENGTH SXC SXD SXE SXF S-MAX S-MIN M.S.-T M.S.-C\n']
msg = []
for dt, SMaxs in sorted(self.smax.iteritems()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for eid, Smax in sorted(SMaxs.iteritems()):
msg.append('0 %8i\n' % (eid))
for i, nid in enumerate(self.grids[eid]):
xxb = self.xxb[eid][i]
sxc = self.sxc[dt][eid][i]
sxd = self.sxd[dt][eid][i]
sxe = self.sxe[dt][eid][i]
sxf = self.sxf[dt][eid][i]
sMax = self.smax[dt][eid][i]
sMin = self.smin[dt][eid][i]
SMt = self.MS_tension[dt][eid][i]
SMc = self.MS_compression[dt][eid][i]
(vals2, is_all_zeros) = writeFloats13E([sxc, sxd, sxe, sxf,
sMax, sMin, SMt, SMc])
(sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc) = vals2
msg.append('%19s %4.3f %12s %12s %12s %12s %12s %12s %12s %s\n' % (nid, xxb, sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False, is_sort1=True):
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.elements
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.data[itime, :, 6]
# loop over all the elements
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, is_all_zeros) = writeFloats13E(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_f06(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
f.write('ComplexBarStress write_f06 not implemented...\n')
return page_num
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, page_num, f, is_mag_phase)
msg = header + [
' S T R A I N S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRAIN SB-MAX SB-MIN M.S.-C\n',
]
for eid, E1s in sorted(self.e1.iteritems()):
eType = self.eType[eid]
axial = self.axial[eid]
e1 = self.e1[eid]
e2 = self.e2[eid]
e3 = self.e3[eid]
e4 = self.e4[eid]
vals = [e1[0], e2[0], e3[0], e4[0], axial,
e1[1], e2[1], e3[1], e4[1]]
(vals2, is_all_zeros) = writeFloats13E(vals)
[e10, e20, e30, e40, axial,
e11, e21, e31, e41] = vals2
msg.append('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (eid, e10, e20, e30, e40, axial))
msg.append(' %8s %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % ('', e11, e21, e31, e41))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def _write_f06_transient(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False, is_sort1=True):
#raise NotImplementedError('CBUSH1D')
words = [
# ELEMENT-ID = 7001
' S T R E S S E S ( F O R C E S ) I N B U S H 1 D E L E M E N T S ( C B U S H 1 D )',
' \n',
' AXIAL AXIAL AXIAL AXIAL AXIAL PLASTIC\n',
' TIME FORCE DISPLACEMENT VELOCITY STRESS STRAIN STRAIN STATUS\n',
]
msg = []
for dt, ElementForce in sorted(iteritems(self.element_force)):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for eid, element_force in sorted(iteritems(ElementForce)):
#eType = self.eType[eid]
#element_force = self.element_force[dt][eid]
axial_displacement = self.axial_displacement[dt][eid]
axial_velocity = self.axial_velocity[dt][eid]
axial_stress = self.axial_stress[dt][eid]
axial_strain = self.axial_strain[dt][eid]
plastic_strain = self.plastic_strain[dt][eid]
is_failed = self.is_failed[dt][eid]
vals = [element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed]
(vals2, is_all_zeros) = writeFloats13E(vals)
[element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed] = vals2
msg.append(' %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (eid,
element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def _write_f06_transient(self, header, pageStamp, pageNum=1, f=None):
msg = header + [' G R I D P O I N T F O R C E B A L A N C E\n',
' \n',
' POINT-ID ELEMENT-ID SOURCE T1 T2 T3 R1 R2 R3\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(self.forces.items()):
zero = ' '
for eKey, Force in sorted(Forces.items()):
for iLoad, force in enumerate(Force):
(f1, f2, f3) = force
(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, isAllZeros) = writeFloats13E(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 = ' '
zero = '0'
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
pageNum += 1
return (''.join(msg), pageNum - 1)
def _write_f06_transient(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
words = [' C O M P L E X F O R C E S I N S C A L A R S P R I N G S ( C E L A S 4 )\n',
' (REAL/IMAGINARY)\n',
' \n',
' ELEMENT ELEMENT\n',
' ID. FORCE ID. FORCE\n']
msg = []
for dt, Force in sorted(self.force.items()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
#packs = []
forces = []
elements = []
line = ''
for eid, force in sorted(Force.items()):
elements.append(eid)
forces.append(force)
#pack.append(eid)
#pack.append(f)
([forceReal, forceImag], is_all_zeros) = writeFloats13E([force.real, force.imag])
line += ' %13s %-13s / %-13s' % (eid, forceReal, forceImag)
if len(forces) == 2:
msg.append(line.rstrip() + '\n')
line = ''
forces = []
if forces:
msg.append(line.rstrip() + '\n')
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, pageNum, f)
msg = header + [' S T R A I N S I N B E A M E L E M E N T S ( C B E A M )\n',
' STAT DIST/\n',
' ELEMENT-ID GRID LENGTH SXC SXD SXE SXF S-MAX S-MIN M.S.-T M.S.-C\n']
for eid in sorted(self.smax):
msg.append('0 %8i\n' % (eid))
#print self.xxb[eid]
for i, nid in enumerate(self.grids[eid]):
xxb = self.xxb[eid][i]
sxc = self.sxc[eid][i]
sxd = self.sxd[eid][i]
sxe = self.sxe[eid][i]
sxf = self.sxf[eid][i]
sMax = self.smax[eid][i]
sMin = self.smin[eid][i]
SMt = self.MS_tension[eid][i]
SMc = self.MS_compression[eid][i]
(vals2, isAllZeros) = writeFloats13E([
sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc])
(sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc) = vals2
msg.append('%19s %4.3f %12s %12s %12s %12s %12s %12s %12s %s\n' % (nid, xxb, sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc.strip()))
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
return (''.join(msg), pageNum)
def write_f06(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False, is_sort1=True):
msg = self._get_msgs()
(ntimes, ntotal) = self.data.shape[:2]
eids = self.elements
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]
# loop over all the elements
for (i, eid, txi, tyi, tzi, rxi, ryi, rzi) in zip(
count(), eids, tx, ty, tz, rx, ry, rz):
vals = [txi, tyi, tzi, rxi, ryi, rzi]
(vals2, is_all_zeros) = writeFloats13E(vals)
[txi, tyi, tzi, rxi, ryi, rzi] = vals2
msg.append('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_f06(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False, is_sort1=True):
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
)
msg = header + [
" 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",
" STAT DIST/\n",
" ELEMENT-ID GRID LENGTH SXC SXD SXE SXF S-MAX S-MIN M.S.-T M.S.-C\n",
]
for eid in sorted(self.smax):
msg.append("0 %8i\n" % (eid))
for i, nid in enumerate(self.grids[eid]):
xxb = self.xxb[eid][i]
sxc = self.sxc[eid][i]
sxd = self.sxd[eid][i]
sxe = self.sxe[eid][i]
sxf = self.sxf[eid][i]
sMax = self.smax[eid][i]
sMin = self.smin[eid][i]
SMt = self.MS_tension[eid][i]
SMc = self.MS_compression[eid][i]
(vals2, is_all_zeros) = writeFloats13E([sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc])
(sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc) = vals2
msg.append(
"%19s %4.3f %12s %12s %12s %12s %12s %12s %12s %s\n"
% (nid, xxb, sxc, sxd, sxe, sxf, sMax, sMin, SMt, SMc.strip())
)
msg.append(page_stamp % page_num)
f.write("".join(msg))
return page_num
def write_f06(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
if self.dt is not None:
return self._write_f06_transient(header, pageStamp, pageNum, f)
msg = header + [' S T R A I N S I N R O D E L E M E N T S ( C R O D )\n',
' ELEMENT AXIAL SAFETY TORSIONAL SAFETY ELEMENT AXIAL SAFETY TORSIONAL SAFETY\n',
' ID. STRAIN MARGIN STRAIN MARGIN ID. STRAIN MARGIN STRAIN MARGIN\n']
out = []
for eid in sorted(self.axial):
axial = self.axial[eid]
MSa = self.MS_axial[eid]
torsion = self.torsion[eid]
MSt = self.MS_torsion[eid]
(vals2, isAllZeros) = writeFloats13E([axial, torsion])
(axial, torsion) = vals2
out.append([eid, axial, MSa, torsion, MSt])
nOut = len(out)
nWrite = nOut
if nOut % 2 == 1:
nWrite = nOut - 1
for i in range(0, nWrite, 2):
outLine = ' %8i %13s %10.4E %13s %10.4E %8i %13s %10.4E %13s %10.4E\n' % (tuple(out[i] + out[i + 1]))
msg.append(outLine)
if nOut % 2 == 1:
outLine = ' %8i %13s %10.4E %13s %10.4E\n' % (
tuple(out[-1]))
msg.append(outLine)
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
return(''.join(msg), pageNum)
def write_f06(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, page_num, f)
msg = header + [' S T R A I N S I N T R I A X 6 E L E M E N T S\n',
' ELEMENT GRID ID STRAINS IN MATERIAL COORD SYSTEM MAX MAG MAX VON MISES \n',
' ID RADIAL AZIMUTHAL AXIAL SHEAR PRINCIPAL SHEAR\n', ]
#' 5351 0 -9.726205E+02 -1.678908E+03 -1.452340E+03 -1.325111E+02 -1.678908E+03 3.702285E+02 6.654553E+02
#' 4389 -9.867789E+02 -1.624276E+03 -1.388424E+03 -9.212539E+01 -1.624276E+03 3.288099E+02 5.806334E+02
#out = []
for eid, radial in sorted(self.radial.iteritems()):
for nid in sorted(radial):
rad = self.radial[eid][nid]
azimuth = self.azimuthal[eid][nid]
axial = self.axial[eid][nid]
shear = self.shear[eid][nid]
emax = self.emax[eid][nid]
ems = self.ems[eid][nid]
evm = self.evm[eid][nid]
if nid == 0:
Eid = eid
else:
Eid = ''
([rad, azimuth, axial, shear, emax, ems, evm], is_all_zeros) = writeFloats13E([rad, azimuth, axial, shear, emax, ems, evm])
msg.append(' %8s %8s %s %s %s %s %s %s %-s\n' % (Eid, nid, radial, azimuth, axial, shear, emax, ems, evm.rstrip()))
msg.append('\n')
msg.append(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False, is_sort1=True):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, page_stamp, page_num, f, is_sort1=is_sort1)
msg = header + [
' S T R A I N S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRAIN SB-MAX SB-MIN M.S.-C\n',
]
for eid, E1s in sorted(iteritems(self.e1)):
#eType = self.eType[eid]
axial = self.axial[eid]
#MSt = self.MSt[eid]
#MSc = self.MSc[eid]
MSt = ''
MSc = ''
e1 = self.e1[eid]
e2 = self.e2[eid]
e3 = self.e3[eid]
e4 = self.e4[eid]
emax = self.emax[eid]
emin = self.emin[eid]
vals = [e1[0], e2[0], e3[0], e4[0], axial, emax[0], emin[0],
e1[1], e2[1], e3[1], e4[1], emax[1], emin[1]]
(vals2, is_all_zeros) = writeFloats13E(vals)
[e10, e20, e30, e40, axial, emax0, emin0,
e11, e21, e31, e41, emax1, emin1] = vals2
msg.append('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (eid, e10, e20, e30, e40, axial, emax0, emin0, MSt))
msg.append(' %8s %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % ('', e11, e21, e31, e41, '', emax1, emin1, MSc))
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self,
header,
pageStamp,
page_num=1,
f=None,
is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header,
pageStamp,
page_num,
f,
is_mag_phase=is_mag_phase)
msg = header + [
' F O R C E S O F M U L T I - P O I N T C O N S T R A I N T\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n'
]
for nodeID, translation in sorted(iteritems(self.translations)):
rotation = self.rotations[nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' %
(nodeID, grid_type, dx, dy, dz, rx, ry, rz.rstrip()))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
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, is_all_zeros) = writeFloats13E(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_f06_transient(self, header, pageStamp, pageNum=1, f=None, is_mag_phase=False):
words = [' F O R C E S O F M U L T I - P O I N T C O N S T R A I N T\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
msg = []
for dt, translations in sorted(self.translations.items()):
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
msg += header + words
for nodeID, translation in sorted(translations.items()):
rotation = self.rotations[dt][nodeID]
gridType = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, isAllZeros) = writeFloats13E(vals)
if not isAllZeros:
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %13s %13s %13s %13s %13s %-s\n' % (nodeID, gridType, dx, dy, dz, rx, ry, rz.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
pageNum += 1
return (''.join(msg), pageNum - 1)
def write_f06(self,
header,
pageStamp,
page_num=1,
f=None,
is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, page_num, f)
msg = header + [
' 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'
]
f.write(''.join(msg))
for nodeID, translation in sorted(iteritems(self.translations)):
rotation = self.rotations[nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
#if not is_all_zeros:
[dx, dy, dz, rx, ry, rz] = vals2
f.write('%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' %
(nodeID, grid_type, dx, dy, dz, rx, ry, rz))
f.write(pageStamp % page_num)
return page_num
def _write_f06_transient_block(self, words, header, page_stamp, page_num, f):
words += [' \n', ' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
#words += self.getTableMarker()
if not len(header) >= 3:
header.append('')
node = self.node_gridtype[:, 0]
gridtype = self.node_gridtype[:, 1]
#print("nodes =", node)
for itime in xrange(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):
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 izip(node, gridtype, t1, t2, t3, r1, r2, r3):
sgridtype = self.recast_gridtype_as_string(gridtypei)
vals = [t1i, t2i, t3i, r1i, r2i, r3i]
(vals2, is_all_zeros) = writeFloats13E(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)
page_num += 1
return page_num - 1
def _write_f06_transient(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
words = [' C O M P L E X L O A D V E C T O R\n',
' (REAL/IMAGINARY)\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n']
#return self.__write_f06_transient_block(words,header,pageStamp,page_num,f,is_mag_phase)
for dt, translations in sorted(self.translations.iteritems()):
header[2] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
f.write(''.join(header + words))
for nodeID, translation in sorted(translations.iteritems()):
rotation = self.rotations[dt][nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
if is_mag_phase:
dxr = abs(dx)
dxi = angle(dx, deg=True)
dyr = abs(dy)
dyi = angle(dy, deg=True)
dzr = abs(dz)
dzi = angle(dz, deg=True)
rxr = abs(rx)
rxi = angle(rx, deg=True)
ryr = abs(ry)
ryi = angle(ry, deg=True)
rzr = abs(rz)
rzi = angle(rz, deg=True)
else:
dxr = dx.real
dyr = dy.real
dzr = dz.real
dxi = dx.imag
dyi = dy.imag
dzi = dz.imag
rxr = rx.real
ryr = ry.real
rzr = rz.real
rxi = rx.imag
ryi = ry.imag
rzi = rz.imag
vals = [dxr, dyr, dzr, rxr, ryr, rzr,
dxi, dyi, dzi, rxi, ryi, rzi]
(vals2, is_all_zeros) = writeFloats13E(vals)
[dxr, dyr, dzr, rxr, ryr, rzr,
dxi, dyi, dzi, rxi, ryi, rzi] = vals2
#if not is_all_zeros:
f.write('0 %12i %6s %-13s %-13s %-13s %-13s %-13s %s\n'
' %12s %6s %-13s %-13s %-13s %-13s %-13s %s\n' % (
nodeID, grid_type, dxr, dyr, dzr, rxr, ryr, rzr,
'', '', dxi, dyi, dzi, rxi, ryi, rzi))
f.write(pageStamp % page_num)
page_num += 1
return page_num - 1
def write_f06(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False, is_sort1=True):
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)
msg = header + [' G R I D P O I N T F O R C E B A L A N C E\n',
' \n',
' POINT-ID ELEMENT-ID SOURCE T1 T2 T3 R1 R2 R3\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'
zero = ' '
for eKey, Force in sorted(iteritems(self.force_moment)):
for iLoad, force in enumerate(Force):
(f1, f2, f3, m1, m2, m3) = force
elemName = self.elemName[eKey][iLoad]
eid = self.eids[eKey][iLoad]
vals = [f1, f2, f3, m1, m2, m3]
(vals2, is_all_zeros) = writeFloats13E(vals)
[f1, f2, f3, m1, m2, m3] = vals2
if eid == 0:
eid = ''
msg.append('%s %8s %10s %-8s %-13s %-13s %-13s %-13s %-13s %s\n' % (zero, eKey, eid, elemName,
f1, f2, f3, m1, m2, m3))
zero = ' '
zero = '0'
msg.append(page_stamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self, header, page_stamp, page_num=1, f=None, is_mag_phase=False):
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, is_all_zeros) = writeFloats13E(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_f06_transient(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
f.write('GridPointStressesVolumeObject _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(self.forces.iteritems()):
for eKey, force in sorted(Forces.iteritems()):
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, is_all_zeros) = writeFloats13E(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(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def _write_f06(self, msg, pageStamp, page_num, f):
out = []
for eid in sorted(self.axial):
axial = self.axial[eid]
MSa = self.MS_axial[eid]
torsion = self.torsion[eid]
MSt = self.MS_torsion[eid]
(vals2, is_all_zeros) = writeFloats13E([axial, torsion])
(axial, torsion) = vals2
out.append([eid, axial, MSa, torsion, MSt])
nOut = len(out)
nWrite = nOut
if nOut % 2 == 1:
nWrite = nOut - 1
for i in xrange(0, nWrite, 2):
outLine = ' %8i %13s %10.4E %13s %10.4E %8i %13s %10.4E %13s %10.4E\n' % (tuple(out[i] + out[i + 1]))
msg.append(outLine)
if nOut % 2 == 1:
outLine = ' %8i %13s %10.4E %13s %10.4E\n' % (tuple(out[-1]))
msg.append(outLine)
msg.append(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def write_f06(self,
header,
pageStamp,
pageNum=1,
f=None,
is_mag_phase=False):
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, pageNum, f)
msg = header + [
' L O A D V E C T O R\n',
' \n',
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n'
]
for nodeID, translation in sorted(self.translations.items()):
rotation = self.rotations[nodeID]
gridType = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, isAllZeros) = writeFloats13E(vals)
if not isAllZeros:
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %13s %13s %13s %13s %13s %-s\n' %
(nodeID, gridType, dx, dy, dz, rx, ry, rz.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
return (''.join(msg), pageNum)
def write_f06(self, header, pageStamp, page_num=1, f=None, is_mag_phase=False):
f.write('%s write_f06 not implemented...\n' % self.__class__.__name__)
return page_num
if self.nonlinear_factor is not None:
return self._write_f06_transient(header, pageStamp, page_num, f, is_mag_phase)
msg = header + [
' S T R A I N S I N B A R E L E M E N T S ( C B A R )\n',
' ELEMENT SA1 SA2 SA3 SA4 AXIAL SA-MAX SA-MIN M.S.-T\n',
' ID. SB1 SB2 SB3 SB4 STRAIN SB-MAX SB-MIN M.S.-C\n',
]
for eid, E1s in sorted(iteritems(self.e1)):
eType = self.eType[eid]
axial = self.axial[eid]
e1 = self.e1[eid]
e2 = self.e2[eid]
e3 = self.e3[eid]
e4 = self.e4[eid]
vals = [e1[0], e2[0], e3[0], e4[0], axial,
e1[1], e2[1], e3[1], e4[1]]
(vals2, is_all_zeros) = writeFloats13E(vals)
[e10, e20, e30, e40, axial,
e11, e21, e31, e41] = vals2
msg.append('0%8i %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % (eid, e10, e20, e30, e40, axial))
msg.append(' %8s %-13s %-13s %-13s %-13s %-13s %-13s %-13s %s\n' % ('', e11, e21, e31, e41))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
return page_num
def _write_f06_block(self,
words,
header,
page_stamp,
page_num,
f,
write_words=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, is_all_zeros) = writeFloats13E(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_f06_transient_block(self,
words,
header,
pageStamp,
page_num=1,
f=None):
msg = []
#assert f is not None # remove
for dt, translations in sorted(iteritems(self.translations)):
if isinstance(dt, float): # fix
#header[1] = ' %s = %10.4E float %s\n' % (self.data_code['name'], dt, self.analysis_code)
header[1] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
else:
#header[1] = ' %s = %10i integer %s\n' % (self.data_code['name'], dt, self.analysis_code)
header[1] = ' %s = %10i\n' % (self.data_code['name'], dt)
msg += header + words
for nodeID, translation in sorted(iteritems(translations)):
rotation = self.rotations[dt][nodeID]
grid_type = self.gridTypes[nodeID]
(dx, dy, dz) = translation
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, is_all_zeros) = writeFloats13E(vals)
#if not is_all_zeros:
[dx, dy, dz, rx, ry, rz] = vals2
msg.append(
'%14i %6s %-13s %-13s %-13s %-13s %-13s %s\n' %
(nodeID, grid_type, dx, dy, dz, rx, ry, rz))
msg.append(pageStamp % page_num)
f.write(''.join(msg))
msg = ['']
page_num += 1
return page_num - 1
def write_f06(self,
header,
pageStamp,
pageNum=1,
f=None,
is_mag_phase=False):
"""
::
EIGENVALUE = 6.158494E+07
CYCLES = 1.248985E+03 R E A L E I G E N V E C T O R N O . 1
POINT ID. TYPE T1 T2 T3 R1 R2 R3
1 G 2.547245E-17 -6.388945E-16 2.292728E+00 -1.076928E-15 2.579163E-17 0.0
2002 G -6.382321E-17 -1.556607E-15 3.242408E+00 -6.530917E-16 1.747180E-17 0.0
2003 G 0.0 0.0 0.0 0.0 0.0 0.0
"""
msg = []
hasCycle = hasattr(self, 'mode_cycle')
#print "self.eigrs =", self.eigrs
#print "dir",dir(self)
for i, (iMode,
eigVals) in enumerate(sorted(self.translations.items())):
msg += header
freq = self.eigrs[i]
msg.append('%16s = %13E\n' % ('EIGENVALUE', freq))
if hasCycle:
msg.append(
'%16s = %13E R E A L E I G E N V E C T O R N O . %10i\n \n'
% ('CYCLES', self.mode_cycle, iMode))
else:
msg.append(
' R E A L E I G E N V E C T O R N O . %10i\n \n'
% (iMode))
msg.append(
' POINT ID. TYPE T1 T2 T3 R1 R2 R3\n'
)
for nodeID, displacement in sorted(eigVals.items()):
rotation = self.rotations[iMode][nodeID]
gridType = self.gridTypes[nodeID]
(dx, dy, dz) = displacement
(rx, ry, rz) = rotation
vals = [dx, dy, dz, rx, ry, rz]
(vals2, isAllZeros) = writeFloats13E(vals)
[dx, dy, dz, rx, ry, rz] = vals2
msg.append('%14i %6s %13s %13s %13s %13s %13s %-s\n' %
(nodeID, gridType, dx, dy, dz, rx, ry, rz.rstrip()))
msg.append(pageStamp + str(pageNum) + '\n')
if f is not None:
f.write(''.join(msg))
msg = ['']
pageNum += 1
return (''.join(msg), pageNum - 1)
