Remove some more potential list code that cannot be accessed anymore with the switch to CompositePotential and add some further tests

Author: jobovy

galpy/orbit/Orbits.py

@@ -2694,7 +2694,7 @@ def Jacobi(self, *args, **kwargs):
                     raise AttributeError("Integrate orbit or specify pot=")
             else:
                 pot = kwargs["pot"]
-            if isinstance(pot, (list, CompositePotential)):
+            if isinstance(pot, (CompositePotential, planarCompositePotential)):
                 for p in pot:
                     if hasattr(p, "OmegaP"):
                         OmegaP = p.OmegaP()

galpy/potential/Potential.py

@@ -118,8 +118,10 @@ def _check_potential_list_and_deprecate(Pot):
         elif all(d >= 2 for d in dims):
             from .planarCompositePotential import planarCompositePotential
 
-            if any(d != 2 for d in dims):
+            if any(d != 2 for d in dims):  # pragma: no cover
                 # Mixed 2D and 3D potentials: convert 3D to 2D
+                # not worrying about coverage, because this is behavior that isn't
+                # really recommended and will be deprecated
                 Pot = [p.toPlanar() if _dim(p) == 3 else p for p in Pot]
 
             Pot = planarCompositePotential(Pot)
@@ -4102,12 +4104,10 @@ def _dim(Pot):
     Notes
     -----
     - 2016-04-19 - Written - Bovy (UofT)
+    - 2025-12-29 - Just returns Pot.dim now that lists of potentials are being deprecated - Bovy (UofT)
 
     """
-    if isinstance(Pot, list):
-        return min([_dim(p) for p in Pot])
-    else:
-        return Pot.dim
+    return Pot.dim
 
 
 def _isNonAxi(Pot):

galpy/potential/planarForce.py

@@ -150,7 +150,7 @@ def __add__(self, b):
         # Physical compatibility is checked in planarCompositePotential.__init__
         return planarCompositePotential(self, b)
 
-    # Define separately to keep order
+    # Define separately to catch errors
     def __radd__(self, b):
         from ..potential import flatten as flatten_pot
         from .planarCompositePotential import planarCompositePotential
@@ -160,8 +160,8 @@ def __radd__(self, b):
                 """Can only combine galpy Force objects with """
                 """other Force objects or combinations thereof"""
             )
-        # Physical compatibility is checked in planarCompositePotential.__init__
-        return planarCompositePotential(b, self)
+
+        # Can't add anything that isn't handled elsewhere, so no further code here
 
     def turn_physical_off(self):
         """

galpy/potential/planarPotential.py

@@ -707,9 +707,7 @@ def RZToplanarPotential(RZPot):
     if isinstance(RZPot, CompositePotential):
         out = []
         for pot in RZPot:
-            if isinstance(pot, planarPotential) and not pot.isNonAxi:
-                out.append(pot)
-            elif isinstance(pot, Potential) and not pot.isNonAxi:
+            if isinstance(pot, Potential) and not pot.isNonAxi:
                 out.append(planarPotentialFromRZPotential(pot))
             else:
                 raise PotentialError(
@@ -975,15 +973,15 @@ def toPlanarPotential(Pot):
     if isinstance(Pot, CompositePotential):
         out = []
         for pot in Pot:
-            if isinstance(pot, planarForce):
-                out.append(pot)
-            elif isinstance(pot, Potential) and pot.isNonAxi:
+            if isinstance(pot, Potential) and pot.isNonAxi:
                 out.append(planarPotentialFromFullPotential(pot))
             elif isinstance(pot, Potential):
                 out.append(planarPotentialFromRZPotential(pot))
             elif isinstance(pot, DissipativeForce):
                 out.append(planarDissipativeForceFromFullDissipativeForce(pot))
-            else:
+            else:  # pragma: no cover
+                # Can't get here, because there can't be something that's not a proper
+                # potential/force in a CompositePotential, but leaving it in case this ever changes
                 raise PotentialError(
                     "Input to 'toPlanarPotential' is neither an Potential-instance or a list of such instances"
                 )

galpy/potential/verticalPotential.py

@@ -182,14 +182,8 @@ def RZToverticalPotential(RZPot, R):
     if isinstance(RZPot, CompositePotential):
         out = []
         for pot in RZPot:
-            if isinstance(pot, linearPotential):
-                out.append(pot)
-            elif isinstance(pot, Potential):
+            if isinstance(pot, Potential):
                 out.append(verticalPotential(pot, R))
-            elif isinstance(pot, planarPotential):
-                raise PotentialError(
-                    "Input to 'RZToverticalPotential' cannot be a planarPotential"
-                )
             else:  # pragma: no cover
                 raise PotentialError(
                     "Input to 'RZToverticalPotential' is neither an RZPotential-instance or a combination of such instances"
@@ -259,14 +253,8 @@ def toVerticalPotential(Pot, R, phi=None, t0=0.0):
     if isinstance(Pot, CompositePotential):
         out = []
         for pot in Pot:
-            if isinstance(pot, linearPotential):
-                out.append(pot)
-            elif isinstance(pot, Potential):
+            if isinstance(pot, Potential):
                 out.append(verticalPotential(pot, R, phi=phi, t0=t0))
-            elif isinstance(pot, planarPotential):
-                raise PotentialError(
-                    "Input to 'toVerticalPotential' cannot be a planarPotential"
-                )
             else:  # pragma: no cover
                 # All other cases should have been caught by the
                 # conversion.get_physical test above

galpy/util/conversion.py

@@ -843,27 +843,11 @@ def physical_output(obj: Any, kwargs: dict, quantity: str) -> Tuple[bool, float,
     ro = kwargs.get("ro", None)
     if ro is None and (roSet or (hasattr(obj, "_roSet") and obj._roSet)):
         ro = obj._ro
-    if (
-        ro is None
-        and isinstance(obj, list)
-        and hasattr(obj[0], "_roSet")
-        and obj[0]._roSet
-    ):
-        # For lists of Potentials
-        ro = obj[0]._ro
     if _APY_LOADED and isinstance(ro, units.Quantity):
         ro = ro.to(units.kpc).value
     vo = kwargs.get("vo", None)
     if vo is None and (voSet or (hasattr(obj, "_voSet") and obj._voSet)):
         vo = obj._vo
-    if (
-        vo is None
-        and isinstance(obj, list)
-        and hasattr(obj[0], "_voSet")
-        and obj[0]._voSet
-    ):
-        # For lists of Potentials
-        vo = obj[0]._vo
     if _APY_LOADED and isinstance(vo, units.Quantity):
         vo = vo.to(units.km / units.s).value
     return (
@@ -1075,18 +1059,12 @@ def wrapper(*args, **kwargs):
         ro = kwargs.get("ro", None)
         if ro is None and hasattr(Pot, "_ro"):
             ro = Pot._ro
-        if ro is None and isinstance(Pot, list) and hasattr(Pot[0], "_ro"):
-            # For lists of Potentials
-            ro = Pot[0]._ro
         if _APY_LOADED and isinstance(ro, units.Quantity):
             ro = ro.to(units.kpc).value
         if "t" in kwargs or "M" in kwargs:
             vo = kwargs.get("vo", None)
             if vo is None and hasattr(Pot, "_vo"):
                 vo = Pot._vo
-            if vo is None and isinstance(Pot, list) and hasattr(Pot[0], "_vo"):
-                # For lists of Potentials
-                vo = Pot[0]._vo
             if _APY_LOADED and isinstance(vo, units.Quantity):
                 vo = vo.to(units.km / units.s).value
         # Loop through args

tests/test_potential.py

@@ -8171,6 +8171,34 @@ def test_CompositePotential_explicit_units():
     return None
 
 
+def test_planarCompositePotential_explicit_units():
+    # Test that explicit ro/vo initialization works correctly
+    from galpy.potential import LogarithmicHaloPotential, planarCompositePotential
+
+    pot1 = LogarithmicHaloPotential(normalize=0.5).toPlanar()
+    pot2 = LogarithmicHaloPotential(normalize=0.5).toPlanar()
+
+    # Create CompositePotential with explicit ro and vo
+    comp = planarCompositePotential(pot1, pot2, ro=8.5, vo=220.0)
+    # Check that ro and vo are set correctly
+    assert comp._ro == 8.5, "Explicit ro not set correctly"
+    assert comp._vo == 220.0, "Explicit vo not set correctly"
+    assert comp._roSet, "roSet should be True when ro is explicitly provided"
+    assert comp._voSet, "voSet should be True when vo is explicitly provided"
+
+    # Test with only ro set
+    comp_ro = planarCompositePotential(pot1, pot2, ro=9.0)
+    assert comp_ro._ro == 9.0, "Explicit ro not set correctly"
+    assert comp_ro._roSet, "roSet should be True when ro is explicitly provided"
+
+    # Test with only vo set
+    comp_vo = planarCompositePotential(pot1, pot2, vo=230.0)
+    assert comp_vo._vo == 230.0, "Explicit vo not set correctly"
+    assert comp_vo._voSet, "voSet should be True when vo is explicitly provided"
+
+    return None
+
+
 def test_CompositePotential_setitem_error():
     # Test that __setitem__ raises TypeError for non-Potential values
     from galpy.potential import CompositePotential, LogarithmicHaloPotential
@@ -8563,8 +8591,10 @@ def test_planarCompositePotential_from_addition():
     # Create planar potentials
     pot1 = MiyamotoNagaiPotential(normalize=0.6)
     pot2 = LogarithmicHaloPotential(normalize=0.4)
+    pot3 = LogarithmicHaloPotential(normalize=0.2)
     planar1 = toPlanarPotential(pot1)
     planar2 = toPlanarPotential(pot2)
+    planar3 = toPlanarPotential(pot3)
 
     # Add them together
     combined = planar1 + planar2
@@ -8582,6 +8612,51 @@ def test_planarCompositePotential_from_addition():
         "planarCompositePotential from addition evaluates incorrectly"
     )
 
+    # Some further testing copied from CompositePotential
+    # Test adding individual to planarCompositePotential
+    comp12 = planar1 + planar2
+    comp123 = comp12 + planar3
+    assert len(comp123) == 3
+    assert comp123[0] == planar1
+    assert comp123[1] == planar2
+    assert comp123[2] == planar3
+
+    # Test adding planarCompositePotential to individual
+    comp23 = planar2 + planar3
+    comp123_2 = planar1 + comp23
+    assert len(comp123_2) == 3
+    assert comp123_2[0] == planar1
+
+    # Test adding two planarCompositePotentials
+    comp12 = planar1 + planar2
+    comp3 = planar3 + planar3
+    comp_all = comp12 + comp3
+    assert len(comp_all) == 4
+    return None
+
+
+def test_planarCompositePotential_add_error():
+    # Test that __add__ raises TypeError for incompatible types
+    from galpy.potential import LogarithmicHaloPotential, planarCompositePotential
+
+    pot1 = LogarithmicHaloPotential(normalize=0.5).toPlanar()
+    pot2 = LogarithmicHaloPotential(normalize=0.5).toPlanar()
+    comp = planarCompositePotential(pot1, pot2)
+
+    # Try to add a string
+    try:
+        result = comp + "not a potential"
+        assert False, "Should have raised TypeError"
+    except TypeError as e:
+        assert "Can only add planarPotential" in str(e)
+
+    # Try to add a number
+    try:
+        result = comp + 42
+        assert False, "Should have raised TypeError"
+    except TypeError as e:
+        assert "Can only add planarPotential" in str(e)
+
     return None