docs: def retrieve_manual_indices(self):
          """Read from self.manual
  
          Read from the boolean array `self.manual`, index all
          occurences of `False` and find the corresponding indices
          in the root hierarchy parent, return those and store them
          in `self._man_root_ids` as well.
  
          Notes
          -----
          This method also retrieves hidden indices, i.e. events
          that are not part of the current hierarchy child but
          which have been manually excluded before and are now
          hidden because a hierarchy parent filtered it out.
  
          If `self.parent_changed` is `True`, i.e. the parent applied
          a filter and the child did not yet hear about this, then
          nothing is computed and `self._man_root_ids` as-is.  This
          is important, because the size of the current filter would
          not match the size of the filtered events of the parent and
          thus index-mapping would not work.
          """
          if self.parent_changed:
              # ignore
              pass
          else:
              # indices from boolean array
              pbool = map_indices_child2root(
                  child=self.rtdc_ds,
                  child_indices=np.where(~self.manual)[0]).tolist()
              # retrieve all indices that are currently not visible
              # previous indices
              pold = self._man_root_ids
              # all indices previously selected either via
              # - self.manual or
              # - self.apply_manual_indices
              pall = sorted(list(set(pbool + pold)))
              # visible indices (only available child indices are returned)
              pvis_c = map_indices_root2child(child=self.rtdc_ds,
                                              root_indices=pall).tolist()
              # map visible child indices back to root indices
              pvis_p = map_indices_child2root(child=self.rtdc_ds,
                                              child_indices=pvis_c).tolist()
              # hidden indices
              phid = list(set(pall) - set(pvis_p))
              # Why not set `all_idx` to `pall`:
              # - pbool is considered to be correct
              # - pold contains hidden indices, but also might contain
              #   excess indices from before, i.e. if self.apply_manual_indices
              #   is called, self.manual is also updated. If however,
              #   self.manual is updated, self._man_root_ids are not updated.
              #   Thus, we trust pbool (self.manual) and only use pold
              #   (self._man_root_ids) to determine hidden indices.
              all_idx = list(set(pbool + phid))
              self._man_root_ids = sorted(all_idx)
          return self._man_root_ids