def dump(self, nest=0, out_stream=sys.stdout, verbose=False, dvecs=False,
             sizes=False):
        klass = self.__class__.__name__
        if dvecs:
            ulabel, plabel, uvecname, pvecname = 'du', 'dp', 'dunknowns', 'dparams'
        else:
            ulabel, plabel, uvecname, pvecname = 'u', 'p', 'unknowns', 'params'

        uvec = getattr(self, uvecname)
        pvec = getattr(self, pvecname)

        template = "%s %s '%s'"
        out_stream.write(template % (" "*nest, klass, self.name))

        out_stream.write("  NL: %s  LN: %s" % (self.nl_solver.__class__.__name__,
                                               self.ln_solver.__class__.__name__))
        if sizes:
            commsz = self.comm.size if hasattr(self.comm, 'size') else 0
            template = "    req: %s  usize:%d  psize:%d  commsize:%d"
            out_stream.write(template % (self.get_req_procs(),
                                         uvec.vec.size,
                                         pvec.vec.size,
                                         commsz))
        out_stream.write("\n")

        if verbose:  # pragma: no cover
            vec_conns = dict(self._data_xfer[('', 'fwd', None)].vec_conns)
            byobj_conns = dict(self._data_xfer[('', 'fwd', None)].byobj_conns)

            # collect width info
            lens = [len(u)+sum(map(len, v)) for u, v in
                    chain(iteritems(vec_conns), iteritems(byobj_conns))]
            if lens:
                nwid = max(lens) + 9
            else:
                lens = [len(n) for n in uvec]
                nwid = max(lens) if lens else 12

            for v, acc in iteritems(uvec._dat):
                if acc.pbo or acc.remote:
                    continue
                out_stream.write(" "*(nest+8))
                uslice = '{0}[{1[0]}:{1[1]}]'.format(ulabel, uvec._dat[v].slice)
                pnames = [p for p, u in iteritems(vec_conns) if u == v]

                if pnames:
                    if len(pnames) == 1:
                        pname = pnames[0]
                        pslice = pvec._dat[pname].slice
                        if pslice is None:
                            pslice = (-1, -1)
                        pslice = '%d:%d' % (pslice[0], pslice[1])
                    else:
                        pslice = []
                        for p in pnames:
                            ps = pvec._dat[p].slice
                            if ps is None:
                                ps = (-1, -1)
                            pslice.append(['%d:%d' % ps])
                        if len(pslice) > 1:
                            pslice = ','.join(pslice)
                        else:
                            pslice = pslice[0]

                    pslice = '{}[{}]'.format(plabel, pslice)

                    connstr = '%s -> %s' % (v, pnames)
                    template = "{0:<{nwid}} {1:<10} {2:<10} {3:>10}\n"
                    out_stream.write(template.format(connstr,
                                                     uslice,
                                                     pslice,
                                                     repr(uvec[v]),
                                                     nwid=nwid))
                else:
                    template = "{0:<{nwid}} {1:<21} {2:>10}\n"
                    out_stream.write(template.format(v,
                                                     uslice,
                                                     repr(uvec[v]),
                                                     nwid=nwid))

            if not dvecs:
                for dest, src in iteritems(byobj_conns):
                    out_stream.write(" "*(nest+8))
                    connstr = '%s -> %s:' % (src, dest)
                    template = "{0:<{nwid}} (by_obj)  ({1})\n"
                    out_stream.write(template.format(connstr,
                                                     repr(uvec[src]),
                                                     nwid=nwid))

        nest += 3
        for sub in self.subsystems():
            sub.dump(nest, out_stream=out_stream, verbose=verbose, dvecs=dvecs,
                     sizes=sizes)

        out_stream.flush()
Writes a formated dump of the `System` tree to file.
dataset/ETHPy150Open OpenMDAO/OpenMDAO/openmdao/core/group.py/Group.dump