//  [python]
def _call_internal(self, *args, **kwargs):
        """
        Return the orbits vector at time t

        Parameters
        ----------
        t : numeric, numpy.ndarray or Quantity
            Desired time. Default is the initial time.

        Returns
        -------
        ndarray
            [R,vR,vT,z,vz(,phi)] or [R,vR,vT(,phi)] depending on the orbit; shape = [phasedim,nt,norb]

        Notes
        -----
        - 2019-02-01 - Started - Bovy (UofT)
        - 2019-02-18 - Written interpolation part - Bovy (UofT)

        """
        if len(args) == 0 and "t" in kwargs:
            args = [kwargs.pop("t")]
        if len(args) == 0 or (not hasattr(self, "t") and args[0] == 0.0):
            return numpy.array(self.vxvv).T
        elif not hasattr(self, "t"):
            raise ValueError(
                "Integrate instance before evaluating it at a specific time"
            )
        else:
            t = args[0]
        # Parse t, first check whether we are dealing with the common case
        # where one wants all integrated times
        # 2nd line: scalar Quantities have __len__, but raise TypeError
        # for scalars
        # Remove NaN times from consideration, these are used in internally in  bruteSOS
        t_exact_integration_times = (
            not (_APY_LOADED and isinstance(t, units.Quantity))
            and hasattr(t, "__len__")
            and (len(t) == len(self.t))
            and n.all((t == self.t)[~numpy.isnan(self.t)])
        )
        if _APY_LOADED and isinstance(t, units.Quantity):
            t = conversion.parse_time(t, ro=self._ro, vo=self._vo)
            # Need to re-evaluate now that t has changed...
            t_exact_integration_times = (
                hasattr(t, "__len__")
                and (len(t) == len(self.t))
                and n.all((t == self.t)[~numpy.isnan(self.t)])
            )
        elif (
            "_integrate_t_asQuantity" in self.__dict__
            and self._integrate_t_asQuantity
            and not t_exact_integration_times
        ):
            # Not doing hasattr in above elif, bc currently slow due to overwrite of __getattribute__
            warnings.warn(
                "You specified integration times as a Quantity, but are evaluating at times not specified as a Quantity; assuming that time given is in natural (internal) units (multiply time by unit to get output at physical time)",
                galpyWarning,
            )
        if (
            t_exact_integration_times
        ):  # Common case where one wants all integrated times
            return self.orbit.T.copy()
        elif (
            isinstance(t, (int, float, numpy.number))
            and hasattr(self, "t")
            and t in list(self.t)
        ):
            return numpy.array(self.orbit[:, list(self.t).index(t), :]).T
        else:
            if isinstance(t, (int, float, numpy.number)):
                nt = 1
                t = numpy.atleast_1d(t)
            else:
                nt = len(t)
            if numpy.any(t > numpy.nanmax(self.t)) or numpy.any(
                t < numpy.nanmin(self.t)
            ):
                raise ValueError("Found time value not in the integration time domain")
            try:
                self._setupOrbitInterp()
            except:
                out = numpy.zeros((self.phasedim(), nt, self.size))
                for jj in range(nt):
                    try:
                        indx = list(self.t).index(t[jj])
                    except ValueError:
                        raise LookupError(
                            "Orbit interpolaton failed; integrate on finer grid"
                        )
                    out[:, jj] = self.orbit[:, indx].T
                return out  # should always have nt > 1, bc otherwise covered by above
            out = numpy.empty((self.phasedim(), nt, self.size))
            # Evaluating RectBivariateSpline on grid requires sorted arrays
            sindx = numpy.argsort(t)
            t = t[sindx]
            usindx = numpy.argsort(sindx)  # to later unsort
            if self.phasedim() == 4 or self.phasedim() == 6:
                # Unpack interpolated x and y to R and phi
                x = self._orbInterp[0](t, self._orb_indx_4orbInterp)
                y = self._orbInterp[-1](t, self._orb_indx_4orbInterp)
                out[0] = numpy.sqrt(x * x + y * y)
                out[-1] = numpy.arctan2(y, x)
                for ii in range(1, self.phasedim() - 1):
                    out[ii] = self._orbInterp[ii](t, self._orb_indx_4orbInterp)
            else:
                for ii in range(self.phasedim()):
                    out[ii] = self._orbInterp[ii](t, self._orb_indx_4orbInterp)
            if nt == 1:
                return out[:, 0]
            else:
                t = t[usindx]
                return out[:, usindx]