Пример #1
0
    def read_time_stepper(self, filename=None):
        filename = get_default(filename, self.filename)
        fd = pt.openFile(filename, mode="r")

        ts_group = fd.root.ts
        out = (ts_group.t0.read(), ts_group.t1.read(), ts_group.dt.read(), ts_group.n_step.read())
        fd.close()
        return out
Пример #2
0
    def _get_step_group(self, step, filename=None):
        filename = get_default(filename, self.filename)
        fd = pt.openFile(filename, mode="r")

        gr_name = "step%d" % step
        try:
            step_group = fd.getNode(fd.root, gr_name)
        except:
            output("step %d data not found - premature end of file?" % step)
            fd.close()
            return None, None

        return fd, step_group
Пример #3
0
    def read_variables_time_history(self, var_names, ts, filename=None):
        filename = get_default(filename, self.filename)
        fd = pt.openFile(filename, mode="r")

        assert_((fd.root.last_step[0] + 1) == ts.n_step)

        ths = dict_from_keys_init(var_names, list)

        arr = nm.asarray
        for step in xrange(ts.n_step):
            gr_name = "step%d" % step
            step_group = fd.getNode(fd.root, gr_name)
            name_dict = step_group._v_attrs.name_dict
            for var_name in var_names:
                data = step_group._f_getChild(name_dict[var_name]).data
                ths[var_name].append(arr(data.read()))

        fd.close()

        return ths
Пример #4
0
    def read_time_history(self, node_name, indx, filename=None):
        filename = get_default(filename, self.filename)
        fd = pt.openFile(filename, mode="r")

        th = dict_from_keys_init(indx, list)
        for step in xrange(fd.root.last_step[0] + 1):
            gr_name = "step%d" % step

            step_group = fd.getNode(fd.root, gr_name)
            data = step_group._f_getChild(node_name).data

            for ii in indx:
                th[ii].append(nm.array(data[ii]))

        fd.close()

        for key, val in th.iteritems():
            aux = nm.array(val)
            if aux.ndim == 4:  # cell data.
                aux = aux[:, 0, :, 0]
            th[key] = aux

        return th
Пример #5
0
    def read(self, mesh, **kwargs):
        fd = pt.openFile(self.filename, mode="r")

        mesh_group = fd.root.mesh

        mesh.name = mesh_group.name.read()
        nodes = mesh_group.nod0.read()

        n_gr = mesh_group.n_gr.read()

        conns = []
        descs = []
        mat_ids = []
        for ig in xrange(n_gr):
            gr_name = "group%d" % ig
            group = mesh_group._f_getChild(gr_name)
            conns.append(group.conn.read())
            mat_ids.append(group.mat_id.read())
            descs.append(group.desc.read())

        fd.close()
        mesh._set_data(nodes, conns, mat_ids, descs)

        return mesh
Пример #6
0
    def write(self, filename, mesh, out=None, ts=None):
        from time import asctime

        if pt is None:
            output("pytables not imported!")
            raise ValueError

        step = get_default_attr(ts, "step", 0)
        if step == 0:
            # A new file.
            fd = pt.openFile(filename, mode="w", title="SfePy output file")

            mesh_group = fd.createGroup("/", "mesh", "mesh")

            fd.createArray(mesh_group, "name", mesh.name, "name")
            fd.createArray(mesh_group, "nod0", mesh.nod0, "vertices")
            fd.createArray(mesh_group, "n_gr", len(mesh.conns), "n_gr")
            for ig, conn in enumerate(mesh.conns):
                conn_group = fd.createGroup(mesh_group, "group%d" % ig, "connectivity group")
                fd.createArray(conn_group, "conn", conn, "connectivity")
                fd.createArray(conn_group, "mat_id", mesh.mat_ids[ig], "material id")
                fd.createArray(conn_group, "desc", mesh.descs[ig], "element Type")

            if ts is not None:
                ts_group = fd.createGroup("/", "ts", "time stepper")
                fd.createArray(ts_group, "t0", ts.t0, "initial time")
                fd.createArray(ts_group, "t1", ts.t1, "final time")
                fd.createArray(ts_group, "dt", ts.dt, "time step")
                fd.createArray(ts_group, "n_step", ts.n_step, "n_step")

            tstat_group = fd.createGroup("/", "tstat", "global time statistics")
            fd.createArray(tstat_group, "created", asctime(), "file creation time")
            fd.createArray(tstat_group, "finished", "." * 24, "file closing time")

            fd.createArray(fd.root, "last_step", nm.array([0], dtype=nm.int32), "last saved step")

            fd.close()

        if out is not None:
            if ts is None:
                step, time, nt = 0, 0.0, 0.0
            else:
                step, time, nt = ts.step, ts.time, ts.nt

            # Existing file.
            fd = pt.openFile(filename, mode="r+")

            step_group = fd.createGroup("/", "step%d" % step, "time step data")
            name_dict = {}
            for key, val in out.iteritems():
                #            print key
                if val.dofs is None:
                    dofs = (-1,)
                else:
                    dofs = val.dofs

                group_name = "_" + key.translate(self._tr)
                data_group = fd.createGroup(step_group, group_name, "%s data" % key)
                fd.createArray(data_group, "data", val.data, "data")
                fd.createArray(data_group, "mode", val.mode, "mode")
                fd.createArray(data_group, "dofs", dofs, "dofs")
                fd.createArray(data_group, "name", val.name, "object name")
                fd.createArray(data_group, "var_name", val.var_name, "object parent name")
                fd.createArray(data_group, "dname", key, "data name")
                name_dict[key] = group_name

            step_group._v_attrs.name_dict = name_dict
            fd.root.last_step[0] = step

            fd.removeNode(fd.root.tstat.finished)
            fd.createArray(fd.root.tstat, "finished", asctime(), "file closing time")
            fd.close()