Add get_param_axis*

src/base/contkind.jl

@@ -1,14 +1,16 @@
 abstract type ContinuationKind end
+abstract type OneParamCont <: ContinuationKind end
+abstract type TwoParamCont <: ContinuationKind end
 
 # Codim1
-struct FixedPointCont <: ContinuationKind end
+struct FixedPointCont <: OneParamCont end
 
 # Codim2
-struct SaddleNodeCont <: ContinuationKind end
-struct HopfCont <: ContinuationKind end
+struct SaddleNodeCont <: TwoParamCont end
+struct HopfCont <: TwoParamCont end
 
 # Codim1LimitCycle
-struct LimitCycleCont <: ContinuationKind end
+struct LimitCycleCont <: OneParamCont end
 
 
 #=

src/base/solution.jl

@@ -69,6 +69,9 @@ PointTypeType(::Type{<: BifurcationSweep{_tk, ptType}}) where {_tk, ptType} =
 
 point_type_type(::T) where {T <: BifurcationSweep} = PointTypeType(T)
 
+contkind(sweep::BifurcationSweep) = contkind(problem_of(sweep)) # TODO: don't
+# this is terrible!
+
 function check_sweep_length(sweep)
     @assert length(sweep) == length(sweep.jacobians) == length(sweep.eigvals)
 end

src/base/tools.jl

@@ -25,6 +25,15 @@ problem_of(solver::BifurcationSolver) = solver.prob
 problem_of(sol::BifurcationSolution) = problem_of(as(sol, ContinuationSolution))
 problem_of(sweep::BifurcationSweep) = problem_of(as(sweep, ContinuationSweep))
 
+get_param_axis(ctx, ::Val{1}) = _get_param_axis1(contkind(ctx), ctx)
+_get_param_axis1(::OneParamCont, ctx) = problem_of(ctx).param_axis
+_get_param_axis1(::FixedPointCont, ctx) = problem_of(ctx).p.param_axis  # TODO: remove
+_get_param_axis1(::TwoParamCont, ctx) = problem_of(ctx).param_axis1
+
+get_param_axis(ctx, ::Val{2}) = problem_of(ctx).param_axis2
+get_param_axis1(ctx) = get_param_axis(ctx, Val(1))
+get_param_axis2(ctx) = get_param_axis(ctx, Val(2))
+
 function count_special_points(sweep::BifurcationSweep)
     counter = Dict{point_type_type(sweep), Int}()
     for sp in sweep.special_points

src/codim1lc/data.jl

@@ -1,26 +1,39 @@
+import ..BifurcationsBase
+
+
 dim_ds_state(sweep::Codim1LCSweep) = length(sweep.eigvals[1])  # TODO: don't
 
 
 abstract type AbstractLimitCycleData end
 
-struct LimitCycleData{M, R, V} <: AbstractLimitCycleData
+struct LimitCycleData{M, R, V, P} <: AbstractLimitCycleData
     state::M
     period::R
     param_value::V
-    # param_axis::L
+    prob::P
 end
 
-LimitCycleData(u::AbstractVector, n::Integer) =
+BifurcationsBase.problem_of(lc::LimitCycleData) = lc.prob
+BifurcationsBase.contkind(lc::LimitCycleData) = contkind(lc.prob)  # TODO: don't
+
+LimitCycleData(u::AbstractVector, n::Integer, prob) =
     LimitCycleData(
         reshape((@view u[1:end-2]), n, :),
         u[end - 1],  # period
         u[end],      # param_value
+        prob,
     )
 
 function limitcycles(sweep::Codim1LCSweep)
     n = dim_ds_state(sweep)
     u_list = as(sweep, ContinuationSweep).u
-    return LimitCycleData.(u_list, (n,))
+    sol = as(sweep, ContinuationSweep).sol.value  # TODO: don't
+    if sol !== nothing
+        prob = sol.prob
+    else
+        prob = nothing
+    end
+    return LimitCycleData.(u_list, (n,), (prob,))
 end
 
 limitcycles(sol::Codim1LCSolution) = vcat(limitcycles.(sol.sweeps)...)

src/plotting.jl

@@ -9,16 +9,16 @@ using .ArrayUtils: nan_
 using .Continuations: as, ContinuationSweep, ContinuationSolution,
     ContinuationSolver, sweeps_as_vectors
 using .BifurcationsBase: BifurcationSweep, BifurcationSolution,
-    BifurcationSolver, special_points, measure, problem_of
+    BifurcationSolver, special_points, measure, problem_of,
+    get_param_axis1, get_param_axis2
 using .Codim1: Codim1Sweep, Codim1Solution, Codim1Solver,
     AbstractCodim1SpecialPoint, stabilities, curves_by_stability,
     SpecialPoint, SpecialPointInterval, resolved_points
 using .Codim2: Codim2Sweep, Codim2Solution, Codim2Solver,
     AbstractCodim2SpecialPoint
 using .Codim1LimitCycle: Codim1LCSweep, Codim1LCSolution, Codim1LCSolver,
-    LimitCycleData, CWStateMeasurement, limitcycles
-using .Codim2LimitCycle: Codim2LCSweep, Codim2LCSolution, Codim2LCSolver,
-    FoldLimitCycleData
+    CWStateMeasurement, limitcycles
+using .Codim2LimitCycle: Codim2LCSweep, Codim2LCSolution, Codim2LCSolver
 
 const AbstractSolver = Union{ContinuationSolver, BifurcationSolver}
 const AbstractSolution = Union{ContinuationSolution, BifurcationSolution}
@@ -151,23 +151,9 @@ plottable_name(::Any, key::Integer) = "u$key"
 function plottable_name(ctx, key::Symbol)
     if key in (:parameter, :p1, :p2)
         lens = if key in (:parameter, :p1)
-            if ctx isa LimitCycleData
-                ctx.param_axis
-            elseif ctx isa FoldLimitCycleData
-                ctx.param_axis1
-            elseif ctx isa Codim1Ctx
-                problem_of(ctx).p.param_axis
-            elseif ctx isa Codim1LCCtx
-                problem_of(ctx).param_axis
-            else
-                problem_of(ctx).param_axis1
-            end
+            get_param_axis1(ctx)
         else
-            if ctx isa FoldLimitCycleData
-                ctx.param_axis2
-            else
-                problem_of(ctx).param_axis2
-            end
+            get_param_axis2(ctx)
         end
         return lens_name(lens)
     else