def _setup_vectors(self, param_owners, parent=None,
                       top_unknowns=None, impl=None, alloc_derivs=True):
        self._sysdata.comm = self.comm

        self.params = self.unknowns = self.resids = None
        self.dumat, self.dpmat, self.drmat = OrderedDict(), OrderedDict(), OrderedDict()
        self._local_unknown_sizes = OrderedDict()
        self._local_param_sizes = OrderedDict()
        self._owning_ranks = None
        self.connections = self._probdata.connections
        relevance = self._probdata.relevance

        if not self.is_active():
            return

        self._setup_prom_map()

        self._impl = impl

        my_params = param_owners.get(self.pathname, ())

        max_psize, self._shared_p_offsets = \
            self._get_shared_vec_info(self._params_dict, my_params=my_params)

        if parent is None:
            # determine the size of the largest grouping of parallel subvecs,
            # allocate an array of that size, and sub-allocate from that for all
            # relevant subvecs. We should never need more memory than the
            # largest sized collection of parallel vecs.
            max_usize, self._shared_u_offsets = \
                self._get_shared_vec_info(self._unknowns_dict)

            # Only allocate deriv vectors if needed.
            if not alloc_derivs:
                max_usize = max_psize = 0

            # other vecs will be sub-sliced from this one
            self._shared_du_vec = np.zeros(max_usize)
            self._shared_dr_vec = np.zeros(max_usize)
            self._shared_dp_vec = np.zeros(max_psize)

            self._create_vecs(my_params, voi=None, impl=impl)
            top_unknowns = self.unknowns
        else:

            # Only allocate deriv vectors if needed.
            if not alloc_derivs:
                max_psize = 0

            self._shared_dp_vec = np.zeros(max_psize)

            # map promoted name in parent to corresponding promoted name in this view
            self._relname_map = self._get_relname_map(parent._sysdata.to_prom_name)
            self._create_views(top_unknowns, parent, my_params, voi=None)

        self._u_size_lists = self.unknowns._get_flattened_sizes()
        self._p_size_lists = self.params._get_flattened_sizes()

        self._owning_ranks = self._get_owning_ranks()
        self._sysdata.owning_ranks = self._owning_ranks

        self._setup_data_transfer(my_params, None, alloc_derivs)

        all_vois = set([None])
        if self._probdata.top_lin_gs:
            # create storage for the relevant vecwrappers,
            # keyed by variable_of_interest
            for vois in relevance.groups:
                all_vois.update(vois)
                for voi in vois:
                    if parent is None:
                        self._create_vecs(my_params, voi, impl)
                    else:
                        self._create_views(top_unknowns, parent, my_params,
                                           voi)

                    self._setup_data_transfer(my_params, voi, alloc_derivs)

        for sub in itervalues(self._subsystems):
            sub._setup_vectors(param_owners, parent=self,
                               top_unknowns=top_unknowns,
                               impl=self._impl, alloc_derivs=alloc_derivs)


        # now that all of the vectors and subvecs are allocated, calculate
        # and cache a boolean flag telling us whether to run apply_linear for a
        # given voi and a given child system.

        self._do_apply = {} # dict of (child_pathname, voi) keyed to bool

        for s in self.subsystems(recurse=True, include_self=True):
            for voi, vec in iteritems(s.dpmat):
                for acc in itervalues(vec._dat):
                    if not acc.pbo:
                        self._do_apply[(s.pathname, voi)] = True
                        break
                else:
                    self._do_apply[(s.pathname, voi)] = False

        self._relname_map = None  # reclaim some memory
Create `VecWrappers` for this `Group` and all below it in the
dataset/ETHPy150Open OpenMDAO/OpenMDAO/openmdao/core/group.py/Group._setup_vectors