Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Added new test for O2 sinks. #281

Merged
merged 1 commit into from
Apr 9, 2024

Added new test for O2 sinks.

91c875f
Select commit
Loading
Failed to load commit list.
Sign in for the full log view
Merged

Added new test for O2 sinks. #281

Added new test for O2 sinks.
91c875f
Select commit
Loading
Failed to load commit list.
GitHub Actions / Test Results failed Apr 9, 2024 in 0s

30 fail, 18 042 pass in 3m 43s

18 072 tests   18 042 ✅  3m 43s ⏱️
     1 suites       0 💤
     1 files        30 ❌

Results for commit 91c875f.

Annotations

Check warning on line 0 in tests.Distorb.LL2.test_LL2.Test_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Venus.DYoblDtDistRot--2.916372e-13-unit113-param_options113] (tests.Distorb.LL2.test_LL2.Test_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7fb40957da90>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.LL2.test_LL2.Test_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Earth.DYoblDtDistRot-9.732005e-13-unit176-param_options176] (tests.Distorb.LL2.test_LL2.Test_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7fb4094d9a90>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.LL2.test_LL2.Test_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Mars.DYoblDtDistRot-5.571058e-13-unit239-param_options239] (tests.Distorb.LL2.test_LL2.Test_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7fb4094f9a90>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.LL2.test_LL2.Test_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Venus.DYoblDtDistRot--1.760723e-13-unit521-param_options521] (tests.Distorb.LL2.test_LL2.Test_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7fb409408190>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.LL2.test_LL2.Test_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Earth.DYoblDtDistRot-8.569418e-13-unit584-param_options584] (tests.Distorb.LL2.test_LL2.Test_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7fb409426190>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.LL2.test_LL2.Test_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Mars.DYoblDtDistRot-5.537936e-13-unit647-param_options647] (tests.Distorb.LL2.test_LL2.Test_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_LL2.Test_LL2 object at 0x7fb409344190>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.RD4.test_RD4.Test_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Venus.DYoblDtDistRot--2.924774e-13-unit113-param_options113] (tests.Distorb.RD4.test_RD4.Test_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7fb4091d53a0>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.RD4.test_RD4.Test_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Earth.DYoblDtDistRot-3.067482e-12-unit176-param_options176] (tests.Distorb.RD4.test_RD4.Test_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7fb4091f53a0>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.RD4.test_RD4.Test_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Mars.DYoblDtDistRot-5.583147e-13-unit239-param_options239] (tests.Distorb.RD4.test_RD4.Test_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7fb4091913a0>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.RD4.test_RD4.Test_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Venus.DYoblDtDistRot--1.766696e-13-unit521-param_options521] (tests.Distorb.RD4.test_RD4.Test_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7fb409116a60>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.RD4.test_RD4.Test_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Earth.DYoblDtDistRot-9.822112e-13-unit584-param_options584] (tests.Distorb.RD4.test_RD4.Test_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7fb409135a60>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.Distorb.RD4.test_RD4.Test_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Mars.DYoblDtDistRot-5.548395e-13-unit647-param_options647] (tests.Distorb.RD4.test_RD4.Test_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_RD4.Test_RD4 object at 0x7fb4095cd8b0>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Venus.DYoblDtDistRot--2.924774e-13-unit113-param_options113] (tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7fb408edfc40>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Earth.DYoblDtDistRot-3.067482e-12-unit176-param_options176] (tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7fb408efdc40>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.Mars.DYoblDtDistRot-5.583147e-13-unit239-param_options239] (tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7fb408e9cc40>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Venus.DYoblDtDistRot-1.425669e-13-unit521-param_options521] (tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7fb408e30340>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Earth.DYoblDtDistRot--2.366691e-12-unit584-param_options584] (tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7fb408d4f340>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.Mars.DYoblDtDistRot-5.14628e-13-unit647-param_options647] (tests.DistorbDistrot.SSDistOrbDistRot.test_SSDistOrbDistRot.Test_SSDistOrbDistRot) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1160: UnitConversionError

During handling of the above exception, another exception occurred:

self = <test_SSDistOrbDistRot.Test_SSDistOrbDistRot object at 0x7fb408d70340>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrotEqtide.CTL_LL2.test_CTL_LL2.Test_CTL_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.TGb.DYoblDtDistRot-9.926721e-09-unit171-param_options171] (tests.DistorbDistrotEqtide.CTL_LL2.test_CTL_LL2.Test_CTL_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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 0x7fb408b9ee50>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrotEqtide.CTL_LL2.test_CTL_LL2.Test_CTL_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.TGc.DYoblDtDistRot-7.380027e-12-unit278-param_options278] (tests.DistorbDistrotEqtide.CTL_LL2.test_CTL_LL2.Test_CTL_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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 0x7fb408c12fd0>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrotEqtide.CTL_LL2.test_CTL_LL2.Test_CTL_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.TGb.DYoblDtDistRot--8.70902e-09-unit455-param_options455] (tests.DistorbDistrotEqtide.CTL_LL2.test_CTL_LL2.Test_CTL_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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 0x7fb408bef6d0>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrotEqtide.CTL_LL2.test_CTL_LL2.Test_CTL_LL2

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.TGc.DYoblDtDistRot--6.748655e-12-unit562-param_options562] (tests.DistorbDistrotEqtide.CTL_LL2.test_CTL_LL2.Test_CTL_LL2) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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 0x7fb408ae3850>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrotEqtide.CTL_RD4.test_CTL_RD4.Test_CTL_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.TGb.DYoblDtDistRot-9.980137e-09-unit171-param_options171] (tests.DistorbDistrotEqtide.CTL_RD4.test_CTL_RD4.Test_CTL_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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 0x7fb4089ce7c0>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrotEqtide.CTL_RD4.test_CTL_RD4.Test_CTL_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.initial.TGc.DYoblDtDistRot--3.532139e-11-unit278-param_options278] (tests.DistorbDistrotEqtide.CTL_RD4.test_CTL_RD4.Test_CTL_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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 0x7fb408a01940>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError

Check warning on line 0 in tests.DistorbDistrotEqtide.CTL_RD4.test_CTL_RD4.Test_CTL_RD4

See this annotation in the file changed.

@github-actions github-actions / Test Results

test_benchmark[log.final.TGb.DYoblDtDistRot--8.899329e-09-unit455-param_options455] (tests.DistorbDistrotEqtide.CTL_RD4.test_CTL_RD4.Test_CTL_RD4) failed

junit/test-results.xml [took 0s]
Raw output
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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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 0x7fb4088df040>
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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1857: in __array_function__
    args, kwargs, unit, out = function_helper(*args, **kwargs)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:1658: in _to_own_unit
    _value = value.to_value(unit)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:990: in to_value
    value = self._to_value(unit, equivalencies)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/quantity.py:896: in _to_value
    return self.unit.to(
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1196: in to
    return self._get_converter(Unit(other), equivalencies)(value)
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1125: in _get_converter
    raise exc
/opt/hostedtoolcache/Python/3.9.19/x64/lib/python3.9/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.9.19/x64/lib/python3.9/site-packages/astropy/units/core.py:1086: UnitConversionError