astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -2.916372e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7f7e775028f0>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Venus.DYoblDtDistRot', value = -2.916372e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 9.732005e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7f7e77525870>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Earth.DYoblDtDistRot', value = 9.732005e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 5.571058e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7f7e773507f0>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Mars.DYoblDtDistRot', value = 5.571058e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -1.760723e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7f7e773cdc30>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Venus.DYoblDtDistRot', value = -1.760723e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 8.569418e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7f7e77400bb0>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Earth.DYoblDtDistRot', value = 8.569418e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 5.537936e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7f7e77403af0>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Mars.DYoblDtDistRot', value = 5.537936e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -2.924774e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7f7e7722d630>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Venus.DYoblDtDistRot', value = -2.924774e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 3.067482e-12 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7f7e770485b0>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Earth.DYoblDtDistRot', value = 3.067482e-12
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 5.583147e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7f7e7704b4f0>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Mars.DYoblDtDistRot', value = 5.583147e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -1.766696e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7f7e770e4970>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Venus.DYoblDtDistRot', value = -1.766696e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 9.822112e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7f7e770e78b0>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Earth.DYoblDtDistRot', value = 9.822112e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 5.548395e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7f7e7712a830>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Mars.DYoblDtDistRot', value = 5.548395e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -2.924774e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7f7e76eb0280>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Venus.DYoblDtDistRot', value = -2.924774e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 3.067482e-12 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7f7e76eb31c0>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Earth.DYoblDtDistRot', value = 3.067482e-12
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 5.583147e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7f7e76d5e140>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.initial.Mars.DYoblDtDistRot', value = 5.583147e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 1.425669e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7f7e76ddb580>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Venus.DYoblDtDistRot', value = 1.425669e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -2.366691e-12 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7f7e76e02500>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Earth.DYoblDtDistRot', value = -2.366691e-12
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 5.14628e-13 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7f7e76c45480>
vplanet_output = <vplanet.Output: solarsys>
param = 'log.final.Mars.DYoblDtDistRot', value = 5.14628e-13
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 9.926721e-09 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_CTL_LL2.Test_CTL_LL2 object at 0x7f7e76aee9e0>
vplanet_output = <vplanet.Output: TGard>
param = 'log.initial.TGb.DYoblDtDistRot', value = 9.926721e-09
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 7.380027e-12 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_CTL_LL2.Test_CTL_LL2 object at 0x7f7e76b1ba60>
vplanet_output = <vplanet.Output: TGard>
param = 'log.initial.TGc.DYoblDtDistRot', value = 7.380027e-12
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -8.70902e-09 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_CTL_LL2.Test_CTL_LL2 object at 0x7f7e76b77fa0>
vplanet_output = <vplanet.Output: TGard>, param = 'log.final.TGb.DYoblDtDistRot'
value = -8.70902e-09, unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -6.748655e-12 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_CTL_LL2.Test_CTL_LL2 object at 0x7f7e76bc5060>
vplanet_output = <vplanet.Output: TGard>, param = 'log.final.TGc.DYoblDtDistRot'
value = -6.748655e-12, unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity 9.980137e-09 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_CTL_RD4.Test_CTL_RD4 object at 0x7f7e76976b00>
vplanet_output = <vplanet.Output: TGard>
param = 'log.initial.TGb.DYoblDtDistRot', value = 9.980137e-09
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -3.532139e-11 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_CTL_RD4.Test_CTL_RD4 object at 0x7f7e7697bb80>
vplanet_output = <vplanet.Output: TGard>
param = 'log.initial.TGc.DYoblDtDistRot', value = -3.532139e-11
unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError

astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible
self = <Quantity -8.899329e-09 1 / sec>, unit = Unit(dimensionless)
equivalencies = []

    def to_value(self, unit=None, equivalencies=[]):
        """
        The numerical value, possibly in a different unit.
    
        Parameters
        ----------
        unit : unit-like, optional
            The unit in which the value should be given. If not given or `None`,
            use the current unit.
    
        equivalencies : list of tuple, optional
            A list of equivalence pairs to try if the units are not directly
            convertible (see :ref:`astropy:unit_equivalencies`). If not provided
            or ``[]``, class default equivalencies will be used (none for
            `~astropy.units.Quantity`, but may be set for subclasses).
            If `None`, no equivalencies will be applied at all, not even any
            set globally or within a context.
    
        Returns
        -------
        value : ndarray or scalar
            The value in the units specified. For arrays, this will be a view
            of the data if no unit conversion was necessary.
    
        See Also
        --------
        to : Get a new instance in a different unit.
        """
        if unit is None or unit is self.unit:
            value = self.view(np.ndarray)
        elif not self.dtype.names:
            # For non-structured, we attempt a short-cut, where we just get
            # the scale.  If that is 1, we do not have to do anything.
            unit = Unit(unit)
            # We want a view if the unit does not change.  One could check
            # with "==", but that calculates the scale that we need anyway.
            # TODO: would be better for `unit.to` to have an in-place flag.
            try:
>               scale = self.unit._to(unit)

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:987: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), other = Unit(dimensionless)

    def _to(self, other):
        """
        Returns the scale to the specified unit.
    
        See `to`, except that a Unit object should be given (i.e., no
        string), and that all defaults are used, i.e., no
        equivalencies and value=1.
        """
        # There are many cases where we just want to ensure a Quantity is
        # of a particular unit, without checking whether it's already in
        # a particular unit.  If we're being asked to convert from a unit
        # to itself, we can short-circuit all of this.
        if self is other:
            return 1.0
    
        # Don't presume decomposition is possible; e.g.,
        # conversion to function units is through equivalencies.
        if isinstance(other, UnitBase):
            self_decomposed = self.decompose()
            other_decomposed = other.decompose()
    
            # Check quickly whether equivalent.  This is faster than
            # `is_equivalent`, because it doesn't generate the entire
            # physical type list of both units.  In other words it "fails
            # fast".
            if self_decomposed.powers == other_decomposed.powers and all(
                self_base is other_base
                for (self_base, other_base) in zip(
                    self_decomposed.bases, other_decomposed.bases
                )
            ):
                return self_decomposed.scale / other_decomposed.scale
    
>       raise UnitConversionError(f"'{self!r}' is not a scaled version of '{other!r}'")
E       astropy.units.core.UnitConversionError: 'Unit("1 / sec")' is not a scaled version of 'Unit(dimensionless)'

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_CTL_RD4.Test_CTL_RD4 object at 0x7f7e768c8100>
vplanet_output = <vplanet.Output: TGard>, param = 'log.final.TGb.DYoblDtDistRot'
value = -8.899329e-09, unit = <Quantity 1. 1 / sec>, param_options = {}

    def test_benchmark(self, vplanet_output, param, value, unit, param_options):
        # The value returned by vplanet
        output_value = recursive_getattr(vplanet_output, param)
    
        # Are we comparing a specific index of an array?
        index = param_options.pop("index", None)
        if index is not None:
            output_value = output_value[index]
    
        # The expected value
        benchmark_value = value * unit
    
        # Check
>       if np.allclose(output_value, benchmark_value, **param_options) == 0:

tests/benchmark.py:31: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:606: in close
    (a, b), unit = _quantities2arrays(a, b, unit_from_first=True)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in _quantities2arrays
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity_helper/function_helpers.py:395: in <genexpr>
    arrays = tuple((q._to_own_unit(arg)) for arg in args)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1108: in _get_converter
    return self._apply_equivalencies(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = Unit("1 / sec"), unit = Unit("1 / sec"), other = Unit(dimensionless)
equivalencies = []

    def _apply_equivalencies(self, unit, other, equivalencies):
        """
        Internal function (used from `_get_converter`) to apply
        equivalence pairs.
        """
    
        def make_converter(scale1, func, scale2):
            def convert(v):
                return func(_condition_arg(v) / scale1) * scale2
    
            return convert
    
        for funit, tunit, a, b in equivalencies:
            if tunit is None:
                ratio = other.decompose() / unit.decompose()
                try:
                    ratio_in_funit = ratio.decompose([funit])
                    return make_converter(ratio_in_funit.scale, a, 1.0)
                except UnitsError:
                    pass
            else:
                try:
                    scale1 = funit._to(unit)
                    scale2 = tunit._to(other)
                    return make_converter(scale1, a, scale2)
                except UnitsError:
                    pass
                try:
                    scale1 = tunit._to(unit)
                    scale2 = funit._to(other)
                    return make_converter(scale1, b, scale2)
                except UnitsError:
                    pass
    
        def get_err_str(unit):
            unit_str = unit.to_string("unscaled")
            physical_type = unit.physical_type
            if physical_type != "unknown":
                unit_str = f"'{unit_str}' ({physical_type})"
            else:
                unit_str = f"'{unit_str}'"
            return unit_str
    
        unit_str = get_err_str(unit)
        other_str = get_err_str(other)
    
>       raise UnitConversionError(f"{unit_str} and {other_str} are not convertible")
E       astropy.units.core.UnitConversionError: '1 / sec' (frequency) and '' (dimensionless) are not convertible

/opt/hostedtoolcache/Python/3.10.14/x64/lib/python3.10/site-packages/astropy/units/core.py:1086: UnitConversionError