Esempio n. 1
0
    def _write_f06_quad4_bilinear_transient(self, f, itime, n, is_magnitude_phase, cen):
        """
        CQUAD4 bilinear
        CQUAD8
        CTRIAR
        CTRIA6
        """
        fds = self.fiber_curvature
        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):
            fdr = write_float_13e(fd)
            [oxxr, oyyr, txyr,
             oxxi, oyyi, txyi,] = write_imag_floats_13e([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
Esempio n. 2
0
    def _write_f06_tri3_transient(self, f, itime, n, is_magnitude_phase, cen):
        """
        CQUAD4 linear
        CTRIA3
        """
        fds = self.fiber_curvature
        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, fdr, doxx, doyy, dtxy in zip(eids, nodes, fds, oxx, oyy, txy):
            vals = write_float_13e(fdr)
            fdr = vals[0]
            [oxxr, oyyr, txyr,
             oxxi, oyyi, txyi,] = write_imag_floats_13e([doxx, doyy, dtxy], is_magnitude_phase)

            if ilayer0:    # TODO: assuming 2 layers?
                f.write('0  %6i   %-13s     %-13s / %-13s     %-13s / %-13s     %-13s / %s\n' % (eid, fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
            else:
                f.write('   %6s   %-13s     %-13s / %-13s     %-13s / %-13s     %-13s / %s\n' % ('', fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
            ilayer0 = not ilayer0
Esempio n. 3
0
    def _write_sort1_as_sort1(self, header, page_stamp, page_num, f, msg_temp, is_mag_phase):
        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)
            f.write(''.join(header + msg_temp))

            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, itx, ity, itz, irx, iry, irz in zip(eids, tx, ty, tz, rx, ry, rz):
                [txr, tyr, tzr, rxr, ryr, rzr,
                 txi, tyi, tzi, rxi, ryi, rzi] = write_imag_floats_13e([itx, ity, itz, irx, iry, irz], is_mag_phase)
                #'0               1.000000E-01      0.0           2.912573E+00  0.0           0.0           0.0           0.0'
                #'                                    0.0         179.9942        0.0           0.0           0.0           0.0'
                f.write('                %8i    %-13s %-13s %-13s %-13s %-13s %s\n'
                        '                %8s    %-13s %-13s %-13s %-13s %-13s %s\n' % (
                            eid, txr, tyr, tzr, rxr, ryr, rzr,
                            '', txi, tyi, tzi, rxi, ryi, rzi))

            f.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, is_mag_phase):
        assert self.ntimes == len(self._times), 'ntimes=%s len(self._times)=%s' % (self.ntimes, self._times)
        for itime, dt in enumerate(self._times):
            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]

            header[2] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
            f.write(''.join(header + words))
            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_imag_floats_13e(vals, is_mag_phase)
                [dxr, dyr, dzr, rxr, ryr, rzr,
                 dxi, dyi, dzi, rxi, ryi, rzi] = vals2
                if sgridtype == 'G':
                    f.write('0 %12i %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                            '  %12s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n' % (
                                node_id, sgridtype, dxr, dyr, dzr, rxr, ryr, rzr,
                                '', '', dxi, dyi, dzi, rxi, ryi, rzi))
                elif sgridtype == 'S':
                    f.write('0 %12i %6s     %-13s\n'
                            '  %12s %6s     %-13s\n' % (node_id, sgridtype, dxr, '', '', dxi))
                else:
                    raise NotImplementedError(sgridtype)
            f.write(page_stamp % page_num)
            page_num += 1
        return page_num
Esempio n. 5
0
    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 = self.get_f06_header(is_mag_phase=is_mag_phase, is_sort1=is_sort1)

        ntimes = self.data.shape[0]

        eids = self.element
        #is_odd = False
        #nwrite = len(eids)
        #if len(eids) % 2 == 1:
            #nwrite -= 1
            #is_odd = True

        #print('len(eids)=%s nwrite=%s is_odd=%s' % (len(eids), nwrite, is_odd))
        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))

            #print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids)))
            spring_force = self.data[itime, :, 0]

            for eid, spring_forcei in zip(eids, spring_force):
                [rspring, ispring] = write_imag_floats_13e([spring_forcei], is_mag_phase)
                #ELEMENT                             AXIAL                                       TORSIONAL
                    #ID.                              STRESS                                         STRESS
                    #14                  0.0          /  0.0                           0.0          /  0.0


                f06_file.write('      %8i   %-13s / %-13s\n' % (eid, rspring, ispring))
            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 6
0
    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_temp = self.get_f06_header(is_mag_phase=is_mag_phase, is_sort1=is_sort1)

        ntimes = self.data.shape[0]

        eids = self.element
        is_odd = False
        nwrite = len(eids)
        if len(eids) % 2 == 1:
            nwrite -= 1
            is_odd = True

        #print('len(eids)=%s nwrite=%s is_odd=%s' % (len(eids), nwrite, is_odd))
        for itime in range(ntimes):
            dt = self._times[itime]  # TODO: rename this...
            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)))
            spring_force = self.data[itime, :, 0]

            out = []
            for eid, spring_forcei in zip(eids, spring_force):
                [rspring, ispring] = write_imag_floats_13e([spring_forcei], is_mag_phase)
                #ELEMENT                             AXIAL                                       TORSIONAL
                    #ID.                              STRESS                                         STRESS
                    #14                  0.0          /  0.0                           0.0          /  0.0


                f.write('      %8i   %-13s / %-13s\n' % (eid, rspring, ispring))
            f.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 7
0
    def _write_f06_quad4_bilinear_transient(self, f06_file, itime,
                                            unused_n, is_magnitude_phase, cen) -> None:
        """
        CQUAD4 bilinear
        CQUAD8
        CTRIAR
        CTRIA6
        """
        fds = self.fiber_curvature
        oxx = self.data[itime, :, 0]
        oyy = self.data[itime, :, 1]
        txy = self.data[itime, :, 2]
        ovm = self.data[itime, :, 3]

        eids = self.element_node[:, 0]
        nodes = self.element_node[:, 1]

        ilayer0 = True
        for eid, node, fd, doxx, doyy, dtxy, dovm in zip(eids, nodes, fds, oxx, oyy, txy, ovm):
            fdr = write_float_13e(fd)
            [oxxr, oyyr, txyr,
             oxxi, oyyi, txyi,] = write_imag_floats_13e([doxx, doyy, dtxy], is_magnitude_phase)

            if node == 0 and ilayer0:
                f06_file.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?
                f06_file.write('   %8s %8i  %-13s   %-13s / %-13s   %-13s / %-13s   %-13s / %s\n' % (
                    '', node, fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
            else:
                f06_file.write('   %8s %8s  %-13s   %-13s / %-13s   %-13s / %-13s   %-13s / %s\n\n' % (
                    '', '', fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
            ilayer0 = not ilayer0
Esempio n. 8
0
    def _write_f06_tri3_transient(self, f06_file, itime,
                                  is_magnitude_phase) -> None:
        """
        CQUAD4 linear
        CTRIA3
        """
        fds = self.fiber_curvature
        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, fd, doxx, doyy, dtxy in zip(eids, fds, oxx, oyy, txy):
            fdr = write_float_13e(fd)
            [
                oxxr,
                oyyr,
                txyr,
                oxxi,
                oyyi,
                txyi,
            ] = write_imag_floats_13e([doxx, doyy, dtxy], is_magnitude_phase)

            if ilayer0:  # TODO: assuming 2 layers?
                f06_file.write(
                    '0  %6i   %-13s     %-13s / %-13s     %-13s / %-13s     %-13s / %s\n'
                    % (eid, fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
            else:
                f06_file.write(
                    '   %6s   %-13s     %-13s / %-13s     %-13s / %-13s     %-13s / %s\n'
                    % ('', fdr, oxxr, oxxi, oyyr, oyyi, txyr, txyi))
            ilayer0 = not ilayer0
Esempio n. 9
0
    def _write_sort1_as_sort1(self, header, page_stamp, page_num, f, msg_temp, is_mag_phase):
        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)
            f.write(''.join(header + msg_temp))

            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, itx, ity, itz, irx, iry, irz in zip(eids, tx, ty, tz, rx, ry, rz):
                [txr, tyr, tzr, rxr, ryr, rzr,
                 txi, tyi, tzi, rxi, ryi, rzi] = write_imag_floats_13e([itx, ity, itz, irx, iry, irz], is_mag_phase)
                #'0               1.000000E-01      0.0           2.912573E+00  0.0           0.0           0.0           0.0'
                #'                                    0.0         179.9942        0.0           0.0           0.0           0.0'
                f.write('                %8i    %-13s %-13s %-13s %-13s %-13s %s\n'
                        '                %8s    %-13s %-13s %-13s %-13s %-13s %s\n' % (
                            eid, txr, tyr, tzr, rxr, ryr, rzr,
                            '', txi, tyi, tzi, rxi, ryi, rzi))

            f.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 10
0
    def _write_sort1_as_sort1(self, f, name, header, page_stamp, msg_temp, page_num, is_mag_phase=False):
        ntimes = self.data.shape[0]
        for itime in range(ntimes):
            dt = self._times[itime]

            dt_line = " %14s = %12.5E\n" % (name, dt)
            header[1] = dt_line
            msg = header + msg_temp
            f.write("\n".join(msg))

            sa1 = self.data[itime, :, 0]
            sa2 = self.data[itime, :, 1]
            sa3 = self.data[itime, :, 2]
            sa4 = self.data[itime, :, 3]
            axial = self.data[itime, :, 4]
            sb1 = self.data[itime, :, 5]
            sb2 = self.data[itime, :, 6]
            sb3 = self.data[itime, :, 7]
            sb4 = self.data[itime, :, 8]
            # [sa1, sa2, sa3, sa4, axial, sb1, sb2, sb3, sb4]

            eids = self.element
            for eid, s1ai, s2ai, s3ai, s4ai, axiali, s2ai, s2bi, s2ci, s2di in zip(
                eids, sa1, sa2, sa3, sa4, axial, sb1, sb2, sb3, sb4
            ):
                vals = (s1ai, s2ai, s3ai, s4ai, axiali, s2ai, s2bi, s2ci, s2di)
                vals2 = write_imag_floats_13e(vals, is_mag_phase)
                (
                    s1ar,
                    s2ar,
                    s3ar,
                    s4ar,
                    axialr,
                    s1br,
                    s2br,
                    s3br,
                    s4br,
                    s1ai,
                    s2ai,
                    s3ai,
                    s4ai,
                    axiali,
                    s1bi,
                    s2bi,
                    s3bi,
                    s4bi,
                ) = vals2

                msg.append("0%8i   %-13s  %-13s  %-13s  %-13s  %s\n" % (eid, s1ar, s2ar, s3ar, s4ar, axialr))
                msg.append(" %8s   %-13s  %-13s  %-13s  %-13s  %s\n" % ("", s1ai, s2ai, s3ai, s4ai, axiali))

                msg.append(" %8s   %-13s  %-13s  %-13s  %s\n" % ("", s1br, s2br, s3br, s4br))
                msg.append(" %8s   %-13s  %-13s  %-13s  %s\n" % ("", s1bi, s2bi, s3bi, s4bi))
            f.write(page_stamp % page_num)
            page_num += 1
        return page_num
Esempio n. 11
0
    def write_sort1_as_sort1(self, f, page_num, page_stamp, header, words, is_mag_phase):
        assert self.ntimes == len(self._times), 'ntimes=%s len(self._times)=%s' % (self.ntimes, self._times)
        words_orig = copy.deepcopy(words)

        for itime, dt in enumerate(self._times):
            if hasattr(self, 'eigrs'):
                words = copy.deepcopy(words_orig)
                eigr = self.eigrs[itime]
                eigi = self.eigis[itime]
                eigr = 0. if eigr == 0 else eigr
                eigi = 0. if eigi == 0 else eigi
                if '%' in words[0]:
                    try:
                        words[0] = words[0] % (eigr, eigi)
                    except TypeError:
                        print('words =', words)
                        raise

                if '%' in words[0]:
                    try:
                        words[1] = words[1] % (itime + 1)
                    except TypeError:
                        print('words =', words)
                        raise

            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]

            header[2] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
            f.write(''.join(header + words))
            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_imag_floats_13e(vals, is_mag_phase)
                [dxr, dyr, dzr, rxr, ryr, rzr,
                 dxi, dyi, dzi, rxi, ryi, rzi] = vals2
                if sgridtype == 'G':
                    f.write('0 %12i %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                            '  %12s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n' % (
                                node_id, sgridtype, dxr, dyr, dzr, rxr, ryr, rzr,
                                '', '', dxi, dyi, dzi, rxi, ryi, rzi))
                elif sgridtype == 'S':
                    f.write('0 %12i %6s     %-13s\n'
                            '  %12s %6s     %-13s\n' % (node_id, sgridtype, dxr, '', '', dxi))
                else:
                    raise NotImplementedError(sgridtype)
            f.write(page_stamp % page_num)
            page_num += 1
        return page_num
Esempio n. 12
0
    def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
                  page_num: int=1, is_mag_phase: bool=False, is_sort1: bool=True):
        if header is None:
            header = []
        msg_temp, nnodes = get_f06_header(self, is_mag_phase, is_sort1)

        # write the f06
        ntimes = self.data.shape[0]

        cid = 0
        for itime in range(ntimes):
            dt = self._times[itime]

            #print('eids=', eids)

            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))

            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]

            eids2 = self.element_node[:, 0]
            nodes = self.element_node[:, 1]

            for deid, node, doxx, doyy, dozz, dtxy, dtyz, dtxz in zip(eids2, nodes, oxx, oyy, ozz, txy, tyz, txz):
                # TODO: cid not supported
                [oxxr, oyyr, ozzr, txyr, tyzr, txzr,
                 oxxi, oyyi, ozzi, txyi, tyzi, txzi,] = write_imag_floats_13e([doxx, doyy, dozz,
                                                                               dtxy, dtyz, dtxz], is_mag_phase)
                if node == 0:  # CENTER
                    f06_file.write(
                        '0 %12i %11sGRID CS %2i GP\n'
                        '0   %22s    %-13s  %-13s  %-13s    %-13s  %-13s  %s\n'
                        '    %22s    %-13s  %-13s  %-13s    %-13s  %-13s  %s\n' % (
                            deid, cid, nnodes,
                            'CENTER', oxxr, oyyr, ozzr, txyr, tyzr, txzr,
                            '', oxxi, oyyi, ozzi, txyi, tyzi, txzi,
                    ))
                else:
                    f06_file.write(
                        '0   %22s    %-13s  %-13s  %-13s    %-13s  %-13s  %s\n'
                        '    %22s    %-13s  %-13s  %-13s    %-13s  %-13s  %s\n' % (
                            node, oxxr, oyyr, ozzr, txyr, tyzr, txzr,
                            '', oxxi, oyyi, ozzi, txyi, tyzi, txzi,
                    ))
            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 13
0
    def write_sort1_as_sort2(self, f06_file, page_num, page_stamp, header,
                             words, is_mag_phase):
        node = self.node_gridtype[:, 0]
        gridtype = self.node_gridtype[:, 1]

        times = self._times
        # print(self.data.shape)
        for inode, (node_id, gridtypei) in enumerate(zip(node, gridtype)):
            # TODO: for SORT1 pretending to be SORT2
            #t1 = self.data[:, inode, 0].ravel()
            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()
            if len(r3) != len(times):
                raise RuntimeError('len(d)=%s len(times)=%s' %
                                   (len(r3), len(times)))

            header[2] = ' POINT-ID = %10i\n' % node_id
            f06_file.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_imag_floats_13e(vals, is_mag_phase)
                [dxr, dyr, dzr, rxr, ryr, rzr, dxi, dyi, dzi, rxi, ryi,
                 rzi] = vals2
                sdt = write_float_12e(dt)
                #if not is_all_zeros:
                if sgridtype == 'G':
                    f06_file.write(
                        '0 %12s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                        '  %13s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                        % (sdt, sgridtype, dxr, dyr, dzr, rxr, ryr, rzr, '',
                           '', dxi, dyi, dzi, rxi, ryi, rzi))
                elif sgridtype == 'S':
                    f06_file.write('0 %12s %6s     %-13s\n'
                                   '  %12s %6s     %-13s\n' %
                                   (sdt, sgridtype, dxr, '', '', dxi))
                else:
                    msg = 'nid=%s dt=%s type=%s dx=%s dy=%s dz=%s rx=%s ry=%s rz=%s' % (
                        node_id, dt, sgridtype, t1i, t2i, t3i, r1i, r2i, r3i)
                    raise NotImplementedError(msg)
            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num
Esempio n. 14
0
    def _write_sort1_as_sort1(self,
                              f06_file,
                              name,
                              header,
                              page_stamp,
                              msg_temp,
                              page_num,
                              is_mag_phase=False):
        ntimes = self.data.shape[0]
        for itime in range(ntimes):
            dt = self._times[itime]

            dt_line = ' %14s = %12.5E\n' % (name, dt)
            header[1] = dt_line
            msg = header + msg_temp
            f06_file.write('\n'.join(msg))

            sa1 = self.data[itime, :, 0]
            sa2 = self.data[itime, :, 1]
            sa3 = self.data[itime, :, 2]
            sa4 = self.data[itime, :, 3]
            axial = self.data[itime, :, 4]
            sb1 = self.data[itime, :, 5]
            sb2 = self.data[itime, :, 6]
            sb3 = self.data[itime, :, 7]
            sb4 = self.data[itime, :, 8]
            #[sa1, sa2, sa3, sa4, axial, sb1, sb2, sb3, sb4]

            eids = self.element
            for eid, s1ai, s2ai, s3ai, s4ai, axiali, s2ai, s2bi, s2ci, s2di in zip(
                    eids, sa1, sa2, sa3, sa4, axial, sb1, sb2, sb3, sb4):
                vals = (s1ai, s2ai, s3ai, s4ai, axiali, s2ai, s2bi, s2ci, s2di)
                vals2 = write_imag_floats_13e(vals, is_mag_phase)
                (s1ar, s2ar, s3ar, s4ar, axialr, s1br, s2br, s3br, s4br, s1ai,
                 s2ai, s3ai, s4ai, axiali, s1bi, s2bi, s3bi, s4bi) = vals2

                f06_file.write('0%8i   %-13s  %-13s  %-13s  %-13s  %s\n'
                               ' %8s   %-13s  %-13s  %-13s  %-13s  %s\n' %
                               (eid, s1ar, s2ar, s3ar, s4ar, axialr, '', s1ai,
                                s2ai, s3ai, s4ai, axiali))

                f06_file.write(
                    ' %8s   %-13s  %-13s  %-13s  %s\n'
                    ' %8s   %-13s  %-13s  %-13s  %s\n' %
                    ('', s1br, s2br, s3br, s4br, '', s1bi, s2bi, s3bi, s4bi))
            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num
Esempio n. 15
0
    def write_f06(self,
                  f06_file,
                  header=None,
                  page_stamp='PAGE %s',
                  page_num: int = 1,
                  is_mag_phase: bool = False,
                  is_sort1: bool = 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

        eids = self.eids
        for itime, dt in enumerate(self._times):
            if self.nonlinear_factor not in (None, np.nan):
                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))

            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 = ''
            #node_id = ''
            for eid, f1i, f2i, f3i, m1i, m2i, m3i in zip(
                    eids, f1, f2, f3, m1, m2, m3):
                vals = [f1i, f2i, f3i, m1i, m2i, m3i]
                vals2 = write_imag_floats_13e(vals, is_mag_phase)
                (dxr, dxi, dyr, dyi, dzr, dzi, rxr, rxi, ryr, ryi, rzr,
                 rzi) = vals2  # TODO :verify
                f06_file.write(
                    '%14i %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %s\n'
                    '%14s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %s\n' %
                    (eid, source, dxr, dyr, dzr, rxr, ryr, rzr, '', '', dxi,
                     dyi, dzi, rxi, ryi, rzi))
            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 16
0
    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_temp, nnodes = get_f06_header(self, is_mag_phase, is_sort1)

        # write the f06
        ntimes = self.data.shape[0]

        cid = 0
        for itime in range(ntimes):
            dt = self._times[itime]

            #print('eids=', eids)

            dt_line = ' %14s = %12.5E\n' % (self.data_code['name'], dt)
            header[1] = dt_line
            msg = header + msg_temp
            f.write('\n'.join(msg))

            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]

            eids2 = self.element_node[:, 0]
            nodes = self.element_node[:, 1]

            for deid, node, doxx, doyy, dozz, dtxy, dtyz, dtxz in zip(eids2, nodes, oxx, oyy, ozz, txy, tyz, txz):
                # TODO: cid not supported
                [oxxr, oyyr, ozzr, txyr, tyzr, txzr,
                 oxxi, oyyi, ozzi, txyi, tyzi, txzi,] = write_imag_floats_13e([doxx, doyy, dozz,
                                                                               dtxy, dtyz, dtxz], is_mag_phase)
                if node == 0:  # CENTER
                    f.write('0 %12i %11sGRID CS %2i GP\n' % (deid, cid, nnodes))
                    f.write('0   %22s    %-13s  %-13s  %-13s    %-13s  %-13s  %s\n' % ('CENTER', oxxr, oyyr, ozzr, txyr, tyzr, txzr))
                    f.write('    %22s    %-13s  %-13s  %-13s    %-13s  %-13s  %s\n' % ('', oxxi, oyyi, ozzi, txyi, tyzi, txzi))
                else:
                    f.write('0   %22s    %-13s  %-13s  %-13s    %-13s  %-13s  %s\n' % (node, oxxr, oyyr, ozzr, txyr, tyzr, txzr))
                    f.write('    %22s    %-13s  %-13s  %-13s    %-13s  %-13s  %s\n' % ('', oxxi, oyyi, ozzi, txyi, tyzi, txzi))
            f.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 17
0
    def _write_sort1_as_sort1(self, header, page_stamp, page_num, f, msg_temp, is_mag_phase):
        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)
            f.write(''.join(header + msg_temp))

            axial = self.data[itime, :, 0]
            torsion = self.data[itime, :, 1]
            for eid, iaxial, itorsion in zip(eids, axial, torsion):
                [axialr, torsionr, axiali, torsioni] = write_imag_floats_13e([iaxial, itorsion], is_mag_phase)
                f.write('                %8i                 %-13s / %-13s                 %-13s / %s\n' % (
                    eid, axialr, axiali, torsionr, torsioni))

            f.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 18
0
    def write_sort1_as_sort2(self, f, page_num, page_stamp, header, words, is_mag_phase):
        node = self.node_gridtype[:, 0]
        gridtype = self.node_gridtype[:, 1]

        times = self._times
        # print(self.data.shape)
        for inode, (node_id, gridtypei) in enumerate(zip(node, gridtype)):
            # TODO: for SORT1 pretending to be SORT2
            #t1 = self.data[:, inode, 0].ravel()
            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()
            if len(r3) != len(times):
                raise RuntimeError('len(d)=%s len(times)=%s' % (len(r3), len(times)))

            header[2] = ' 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_imag_floats_13e(vals, is_mag_phase)
                [dxr, dyr, dzr, rxr, ryr, rzr,
                 dxi, dyi, dzi, rxi, ryi, rzi] = vals2
                sdt = write_float_12e(dt)
                #if not is_all_zeros:
                if sgridtype == 'G':
                    f.write('0 %12s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                            '  %13s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n' % (
                                sdt, sgridtype, dxr, dyr, dzr, rxr, ryr, rzr,
                                '', '', dxi, dyi, dzi, rxi, ryi, rzi))
                elif sgridtype == 'S':
                    f.write('0 %12s %6s     %-13s\n'
                            '  %12s %6s     %-13s\n' % (sdt, sgridtype, dxr, '', '', dxi))
                else:
                    msg = 'nid=%s dt=%s type=%s dx=%s dy=%s dz=%s rx=%s ry=%s rz=%s' % (
                        node_id, dt, sgridtype, t1i, t2i, t3i, r1i, r2i, r3i)
                    raise NotImplementedError(msg)
            f.write(page_stamp % page_num)
            page_num += 1
        return page_num
Esempio n. 19
0
    def _write_sort1_as_sort1(self, header, page_stamp, page_num, f06_file, msg_temp, is_mag_phase):
        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_temp))

            axial = self.data[itime, :, 0]
            torsion = self.data[itime, :, 1]
            for eid, iaxial, itorsion in zip(eids, axial, torsion):
                [axialr, torsionr, axiali, torsioni] = write_imag_floats_13e([iaxial, itorsion], is_mag_phase)
                f06_file.write('                %8i                 %-13s / %-13s                 %-13s / %s\n' % (
                    eid, axialr, axiali, torsionr, torsioni))

            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 20
0
    def _write_sort1_as_sort1(self, header, page_stamp, page_num, f06_file,
                              msg_temp, is_mag_phase):
        r"""
        C:\\Users\\sdoyle\\Dropbox\\move_tpl\\ofprand1.op2

        '                         C O M P L E X   F O R C E S   I N   B U S H   E L E M E N T S   ( C B U S H ) '
        '                                                          (REAL/IMAGINARY)'
        ' '
        '                  FREQUENCY         FORCE-X       FORCE-Y       FORCE-Z      MOMENT-X      MOMENT-Y      MOMENT-Z  '
        '0               0.0               1.006599E-02  0.0           4.314467E-01  0.0           0.0           0.0'
        '                                 -3.338092E-04  0.0          -9.563536E-03  0.0           0.0           0.0'
        """
        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_temp))

            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, itx, ity, itz, irx, iry, irz in zip(
                    eids, tx, ty, tz, rx, ry, rz):
                [txr, tyr, tzr, rxr, ryr, rzr, txi, tyi, tzi, rxi, ryi,
                 rzi] = write_imag_floats_13e([itx, ity, itz, irx, iry, irz],
                                              is_mag_phase)
                #'0               1.000000E-01      0.0           2.912573E+00  0.0           0.0           0.0           0.0'
                #'                                    0.0         179.9942        0.0           0.0           0.0           0.0'
                f06_file.write(
                    '                %8i    %-13s %-13s %-13s %-13s %-13s %s\n'
                    '                %8s    %-13s %-13s %-13s %-13s %-13s %s\n'
                    % (eid, txr, tyr, tzr, rxr, ryr, rzr, '', txi, tyi, tzi,
                       rxi, ryi, rzi))

            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num - 1
Esempio n. 21
0
    def write_sort1_as_sort1(self, f, page_num, page_stamp, header, words,
                             is_mag_phase):
        assert self.ntimes == len(
            self._times), 'ntimes=%s len(self._times)=%s' % (self.ntimes,
                                                             self._times)
        for itime, dt in enumerate(self._times):
            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]

            header[2] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
            f.write(''.join(header + words))
            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_imag_floats_13e(vals, is_mag_phase)
                [dxr, dyr, dzr, rxr, ryr, rzr, dxi, dyi, dzi, rxi, ryi,
                 rzi] = vals2
                if sgridtype == 'G':
                    f.write(
                        '0 %12i %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                        '  %12s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                        % (node_id, sgridtype, dxr, dyr, dzr, rxr, ryr, rzr,
                           '', '', dxi, dyi, dzi, rxi, ryi, rzi))
                elif sgridtype == 'S':
                    f.write('0 %12i %6s     %-13s\n'
                            '  %12s %6s     %-13s\n' %
                            (node_id, sgridtype, dxr, '', '', dxi))
                else:
                    raise NotImplementedError(sgridtype)
            f.write(page_stamp % page_num)
            page_num += 1
        return page_num
Esempio n. 22
0
    def write_f06(self, f, header=None, page_stamp='PAGE %s',
                  page_num=1, is_mag_phase=False, is_sort1=True):
        """
                C O M P L E X   F O R C E S   A C T I N G   O N   S H E A R   P A N E L   E L E M E N T S   (CSHEAR)
                                                          (REAL/IMAGINARY)

                  ====== POINT  1 ======      ====== POINT  2 ======      ====== POINT  3 ======      ====== POINT  4 ======
 ELEMENT          F-FROM-4      F-FROM-2      F-FROM-1      F-FROM-3      F-FROM-2      F-FROM-4      F-FROM-3      F-FROM-1
         ID               KICK-1       SHEAR-12       KICK-2       SHEAR-23       KICK-3       SHEAR-34       KICK-4       SHEAR-41
            28  0.0           0.0           0.0           0.0           0.0           0.0           0.0           0.0
                0.0           0.0           0.0           0.0           0.0           0.0           0.0           0.0
                       0.0           0.0           0.0           0.0           0.0           0.0           0.0           0.0
                       0.0           0.0           0.0           0.0           0.0           0.0           0.0           0.0
        """
        #if header is None:
            #header = []
        #f.write(self.code_information())
        #return page_num
        msg_temp = _get_cshear_msg(is_mag_phase, is_sort1)

        ntimes = self.data.shape[0]
        eids = self.element
        if self.is_sort1():
            if is_sort1:
                for itime in range(ntimes):
                    dt = self._times[itime]

                    dt_line = ' %14s = %12.5E\n' % (self.data_code['name'], dt)
                    header[1] = dt_line
                    msg = header + msg_temp
                    f.write('\n'.join(msg))

                    max_shear = self.data[itime, :, 0]
                    avg_shear = self.data[itime, :, 1]
                    assert len(eids) == len(max_shear)
                    assert len(max_shear) > 0, max_shear
                    for eid, max_sheari, avg_sheari in zip(eids, max_shear, avg_shear):
                        assert isinstance(eid, int), 'eid=%s type=%s' % (eid, type(eid))
                        [rmax_shear, imax_shear, ravg_shear, iavg_shear
                         ,] = write_imag_floats_13e([max_sheari, avg_sheari], is_mag_phase)

                        #f.write('                      28                  0.0          /  0.0                           0.0          /  0.0\n')
                        f.write('%24s                 %-13s / %-13s                 %-13s / %-13s\n' % (
                            eid, rmax_shear, imax_shear, ravg_shear, iavg_shear))
                    f.write(page_stamp % page_num)
                    page_num += 1
            else:
                # TODO: write in SORT2
                times = self._times
                for ieid, eid in enumerate(eids):
                    max_shear = self.data[:, ieid, 0].ravel()
                    avg_shear = self.data[:, ieid, 1].ravel()
                    for itime, max_sheari, avg_sheari in zip(times, max_shear, avg_shear):
                        [rmax_shear, imax_shear, ravg_shear, iavg_shear
                         ] = write_imag_floats_13e([max_sheari, avg_sheari], is_mag_phase)

                        #f.write('   %6s   %-13s / %-13s     %-13s / %-13s\n' % (
                            #eid, rmax_shear, imax_shear, ravg_shear, iavg_shear))
                        f.write('%24s                 %-13s / %-13s                 %-13s / %-13s\n' % (
                            eid, rmax_shear, imax_shear, ravg_shear, iavg_shear))
                    f.write(page_stamp % page_num)
                    page_num += 1
        else:
            raise NotImplementedError('ComplexShearArray-sort2')
        return page_num - 1
Esempio n. 23
0
    def write_op2(self,
                  op2,
                  op2_ascii,
                  itable,
                  new_result,
                  date,
                  is_mag_phase=False,
                  endian='>'):
        """writes an OP2"""
        # see TestOP2.test_op2_other_01
        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, 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 self.is_sort1:
            struct1 = Struct(endian + b'i12f')
        else:
            raise NotImplementedError('SORT2')

        op2_ascii.write(f'nelements={nelements:d}\n')

        for itime in range(self.ntimes):
            #print('3, %s' % itable)
            self._write_table_3(op2, 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.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')

            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, itx, ity, itz, irx, iry, irz in zip(
                    eids, tx, ty, tz, rx, ry, rz):
                [txr, tyr, tzr, rxr, ryr, rzr, txi, tyi, tzi, rxi, ryi,
                 rzi] = write_imag_floats_13e([itx, ity, itz, irx, iry, irz],
                                              is_mag_phase)
                data = [
                    eid, itx.real, ity.real, itz.real, irx.real, iry.real,
                    irz.real, itx.imag, ity.imag, itz.imag, irx.imag, iry.imag,
                    irz.imag
                ]
                op2_ascii.write('  eid=%s data=%s\n' %
                                (eids_device, str(data)))
                op2.write(struct1.pack(*data))

            itable -= 1
            header = [
                4 * ntotal,
            ]
            op2.write(pack('i', *header))
            op2_ascii.write('footer = %s\n' % header)
            new_result = False
        return itable
Esempio n. 24
0
    def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',
                  page_num=1, is_mag_phase=False, is_sort1=True):
        """
              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
        """
        msg_temp = _get_cbend_msg(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]

                    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]
                    assert len(eids) == len(angles)
                    assert len(angles) > 0, angles
                    for i, eid, nid, anglei, sci, sdi, sei, sfi in zip(counter, eids, nids, angles, scs, sds, ses, sfs):
                        assert isinstance(eid, ints), 'eid=%s type=%s' % (eid, type(eid))
                        [sc_real, sc_imag,
                         sd_real, sd_imag,
                         se_real, se_imag,
                         sf_real, sf_imag,] = write_imag_floats_13e([sci, sdi, sei, sfi], is_mag_phase)

                        #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%12i %8i  A  %.2f %-13s    %-13s    %-13s    %s\n'
                                ' %12s %8s          %-13s    %-13s    %-13s    %s\n'% (
                                    eid, nid, anglei.real,
                                    sc_real, sd_real, se_real, sf_real,
                                    '', '',
                                    sc_imag, sd_imag, se_imag, sf_imag,
                                ))
                        else:
                            f06_file.write(
                                '0%12s %8i  B  %.2f %-13s    %-13s    %-13s    %s\n'
                                ' %12s %8s          %-13s    %-13s    %-13s    %s\n'% (
                                    '', nid, anglei.real,
                                    sc_real, sd_real, se_real, sf_real,
                                    '', '',
                                    sc_imag, sd_imag, se_imag, sf_imag,
                                ))
                    f06_file.write(page_stamp % page_num)
                    page_num += 1
            else:
                raise NotImplementedError('ComplexBendArray-sort2')
        else:
            raise NotImplementedError('ComplexBendArray-sort2')
        return page_num - 1
Esempio n. 25
0
    def write_f06(self,
                  f,
                  header=None,
                  page_stamp='PAGE %s',
                  page_num=1,
                  is_mag_phase=False,
                  is_sort1=True):
        """
                C O M P L E X   F O R C E S   A C T I N G   O N   S H E A R   P A N E L   E L E M E N T S   (CSHEAR)
                                                          (REAL/IMAGINARY)

                  ====== POINT  1 ======      ====== POINT  2 ======      ====== POINT  3 ======      ====== POINT  4 ======
 ELEMENT          F-FROM-4      F-FROM-2      F-FROM-1      F-FROM-3      F-FROM-2      F-FROM-4      F-FROM-3      F-FROM-1
         ID               KICK-1       SHEAR-12       KICK-2       SHEAR-23       KICK-3       SHEAR-34       KICK-4       SHEAR-41
            28  0.0           0.0           0.0           0.0           0.0           0.0           0.0           0.0
                0.0           0.0           0.0           0.0           0.0           0.0           0.0           0.0
                       0.0           0.0           0.0           0.0           0.0           0.0           0.0           0.0
                       0.0           0.0           0.0           0.0           0.0           0.0           0.0           0.0
        """
        #if header is None:
        #header = []
        #f.write(self.code_information())
        #return page_num
        msg_temp = _get_cshear_msg(is_mag_phase, is_sort1)

        ntimes = self.data.shape[0]
        eids = self.element
        if self.is_sort1():
            if is_sort1:
                for itime in range(ntimes):
                    dt = self._times[itime]

                    dt_line = ' %14s = %12.5E\n' % (self.data_code['name'], dt)
                    header[1] = dt_line
                    msg = header + msg_temp
                    f.write('\n'.join(msg))

                    max_shear = self.data[itime, :, 0]
                    avg_shear = self.data[itime, :, 1]
                    assert len(eids) == len(max_shear)
                    assert len(max_shear) > 0, max_shear
                    for eid, max_sheari, avg_sheari in zip(
                            eids, max_shear, avg_shear):
                        assert isinstance(
                            eid, int), 'eid=%s type=%s' % (eid, type(eid))
                        [
                            rmax_shear,
                            imax_shear,
                            ravg_shear,
                            iavg_shear,
                        ] = write_imag_floats_13e([max_sheari, avg_sheari],
                                                  is_mag_phase)

                        #f.write('                      28                  0.0          /  0.0                           0.0          /  0.0\n')
                        f.write(
                            '%24s                 %-13s / %-13s                 %-13s / %-13s\n'
                            % (eid, rmax_shear, imax_shear, ravg_shear,
                               iavg_shear))
                    f.write(page_stamp % page_num)
                    page_num += 1
            else:
                # TODO: write in SORT2
                times = self._times
                for ieid, eid in enumerate(eids):
                    max_shear = self.data[:, ieid, 0].ravel()
                    avg_shear = self.data[:, ieid, 1].ravel()
                    for itime, max_sheari, avg_sheari in zip(
                            times, max_shear, avg_shear):
                        [rmax_shear, imax_shear, ravg_shear, iavg_shear
                         ] = write_imag_floats_13e([max_sheari, avg_sheari],
                                                   is_mag_phase)

                        #f.write('   %6s   %-13s / %-13s     %-13s / %-13s\n' % (
                        #eid, rmax_shear, imax_shear, ravg_shear, iavg_shear))
                        f.write(
                            '%24s                 %-13s / %-13s                 %-13s / %-13s\n'
                            % (eid, rmax_shear, imax_shear, ravg_shear,
                               iavg_shear))
                    f.write(page_stamp % page_num)
                    page_num += 1
        else:
            raise NotImplementedError('ComplexShearArray-sort2')
        return page_num - 1
Esempio n. 26
0
    def write_sort1_as_sort1(self, f06_file, page_num, page_stamp, header,
                             words, is_mag_phase):
        assert self.ntimes == len(
            self._times), 'ntimes=%s len(self._times)=%s' % (self.ntimes,
                                                             self._times)
        words_orig = copy.deepcopy(words)

        for itime, dt in enumerate(self._times):
            if hasattr(self, 'eigrs'):
                words = copy.deepcopy(words_orig)
                eigr = self.eigrs[itime]
                eigi = self.eigis[itime]
                eigr = 0. if eigr == 0 else eigr
                eigi = 0. if eigi == 0 else eigi
                if '%' in words[0]:
                    try:
                        words[0] = words[0] % (eigr, eigi)
                    except TypeError:
                        print('words =', words)
                        raise

                if '%' in words[0]:
                    try:
                        words[1] = words[1] % (itime + 1)
                    except TypeError:
                        print('words =', words)
                        raise

            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]

            header[2] = ' %s = %10.4E\n' % (self.data_code['name'], dt)
            f06_file.write(''.join(header + words))
            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_imag_floats_13e(vals, is_mag_phase)
                [dxr, dyr, dzr, rxr, ryr, rzr, dxi, dyi, dzi, rxi, ryi,
                 rzi] = vals2
                if sgridtype == 'G':
                    f06_file.write(
                        '0 %12i %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                        '  %12s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                        % (node_id, sgridtype, dxr, dyr, dzr, rxr, ryr, rzr,
                           '', '', dxi, dyi, dzi, rxi, ryi, rzi))
                elif sgridtype == 'S':
                    f06_file.write('0 %12i %6s     %-13s\n'
                                   '  %12s %6s     %-13s\n' %
                                   (node_id, sgridtype, dxr, '', '', dxi))
                elif sgridtype == 'H':
                    f06_file.write(
                        '0 %12i %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                        '  %12s %6s     %-13s  %-13s  %-13s  %-13s  %-13s  %-s\n'
                        % (node_id, sgridtype, dxr, dyr, dzr, rxr, ryr, rzr,
                           '', '', dxi, dyi, dzi, rxi, ryi, rzi))
                else:
                    raise NotImplementedError(sgridtype)
            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num
Esempio n. 27
0
    def _write_sort1_as_sort1(self,
                              f06_file,
                              name,
                              header,
                              page_stamp,
                              msg_temp,
                              page_num,
                              is_mag_phase=False):
        ntimes = self.data.shape[0]

        for itime in range(ntimes):
            dt = self._times[itime]

            dt_line = ' %14s = %12.5E\n' % (name, dt)
            header[1] = dt_line
            msg = header + msg_temp
            f06_file.write('\n'.join(msg))

            sxc = self.data[itime, :, 0]
            sxd = self.data[itime, :, 1]
            sxe = self.data[itime, :, 2]
            sxf = self.data[itime, :, 3]
            #[sxc, sxd, sxe, sxf]

            eids = self.element_node[:, 0]
            nids = self.element_node[:, 1]
            ueids = np.unique(eids)
            i_sd_zero = np.searchsorted(eids, ueids, side='left')
            i_sd_one = np.searchsorted(eids, ueids, side='right')
            i_wrong_index = np.where(i_sd_one == len(eids))
            i_sd_one[i_wrong_index] = i_sd_one[i_wrong_index] - 1
            i_sd_one -= 1
            inid = np.union1d(i_sd_zero, i_sd_one)
            #print(inid)
            #print(eids)
            nid_type = np.zeros(len(eids), dtype='bool')
            i_sd_zero_all = np.zeros(len(eids), dtype='bool')
            nid_type[inid] = 1
            i_sd_zero_all[i_sd_zero] = 1
            #print(nid_type)
            for eid, nid, i_sd_zeroi, nid_typei, sd, sxc, sxd, sxe, sxf in zip(
                    eids, nids, i_sd_zero_all, nid_type, self.sd, sxc, sxd,
                    sxe, sxf):
                vals = (sxc, sxd, sxe, sxf)
                vals2 = write_imag_floats_13e(vals, is_mag_phase)
                (sxcr, sxdr, sxer, sxfr, sxci, sxdi, sxei, sxfi) = vals2

                if nid_typei or 1:
                    if i_sd_zeroi:
                        f06_file.write('0  %8s\n' % eid)
                        f06_file.write(
                            '0%8s  %8i   %.3f     %-13s    %-13s    %-13s    %s\n'
                            ' %8s   %8s  %5s     %-13s    %-13s    %-13s    %s\n'
                            % ('', nid, sd, sxcr, sxdr, sxer, sxfr, '', '', '',
                               sxci, sxdi, sxei, sxfi))
                    else:
                        f06_file.write(
                            '0%8s  %8i   %.3f     %-13s    %-13s    %-13s    %s\n'
                            ' %8s   %8s  %5s     %-13s    %-13s    %-13s    %s\n'
                            % ('', nid, sd, sxcr, sxdr, sxer, sxfr, '', '', '',
                               sxci, sxdi, sxei, sxfi))
                else:
                    f06_file.write(
                        ' %8s  %8s   %.3f     %-13s    %-13s    %-13s    %s\n'
                        ' %8s   %8s  %5s     %-13s    %-13s    %-13s    %s\n' %
                        ('', '', sd, sxcr, sxdr, sxer, sxfr, '', '', '', sxci,
                         sxdi, sxei, sxfi))
            f06_file.write(page_stamp % page_num)
            page_num += 1
        return page_num