search

bifurcationkit / BifurcationKit.jl

A Julia package to perform Bifurcation Analysis
https://bifurcationkit.github.io/BifurcationKitDocs.jl/stable
Other
303 stars 37 forks source link

Issue with finding periodic orbit and continuation #155

Closed LEquinoxy closed 3 months ago

LEquinoxy commented 4 months ago

Hello, I have established a ODE model for a DC transmission system (dimension = 84) and attempted to perform bifurcation analysis. I used (1+tanh(AAx))/2 to approximate the discontinuities present in the actual system (i.e., sign(x)), where AA is the approximation coefficient. Due to the appearance of (1+tanh(AAx))/2 and the need for a large AA, this ODE should be very stiff. Here is my code; the ODE model (ODE_hybrid_com.jl) and the initial conditions (u0_new.jld2) are provided in the attachment. 

```julia
using Revise, Parameters, Plots, BifurcationKit, JLD2, ODEInterfaceDiffEq
using DifferentialEquations, MATLABDiffEq, MATLAB, ParameterizedFunctions
const BK = BifurcationKit

include("ODE_hybrid_com.jl")

file = jldopen("u0_new.jld2", "r")
u0 = file["u0_new"]
close(file)

par_ODE = (AA=1e10, Ihold_real=1e-5, Us_pu_rec=1.0, Kp_dc=pi/180*25*2.25) #parameters of the ODE

## Solve to get initial guess
prob_ODE = ODEProblem(ODE_hybrid_com, u0, (0, 0.5), par_ODE, reltol=1e-13, abstol=1e-13)
sol = solve(prob_ODE)
prob_ODE = ODEProblem(ODE_hybrid_com, sol.u[end], (0, 0.02), par_ODE, reltol=1e-13, abstol=1e-13)
sol = solve(prob_ODE)

## Plot the initial guess
T = sol.t
u = hcat(sol.u...)
u29 = u[29, :]
u70 = u[70, :]
mat"figure;plot($T, $u29);figure;plot($T, $u70)"
u0_new1 = sol.u[end]

## Define ODE and bifurcation problems
prob_ODE = ODEProblem(ODE_hybrid_com, u0_new1, (0, 0.02), par_ODE, reltol=1e-13, abstol=1e-13)
prob_br = BifurcationProblem(ODE_hybrid_com, u0_new1, par_ODE, (@lens _.Kp_dc))

# Record variables for plotting
function recordFromSolution(x, p)
    xtt = BK.get_periodic_orbit(p.prob_br, x, p.p)
    return (max = maximum(xtt[1, :]), min = minimum(xtt[1, :]), period = getperiod(p.prob_br, x, p.p))
end

# Group parameters
argspo = (record_from_solution = recordFromSolution,)

# Settings
ls = GMRESKrylovKit(dim = 100, verbose = 3)
newton_options = NewtonPar(tol = 1e-10, max_iterations = 5, linsolver = ls; verbose = true)
opts_br = ContinuationPar(p_min = 0.1, p_max = 5.0, ds = 0.5, dsmax = 1.0, dsmin = 1e-10; n_inversion = 6, nev = 5, max_steps = 100, tol_stability = 1e-10, newton_options)

# Continuation
probsh, cish = generate_ci_problem(ShootingProblem(M = 1), prob_br, prob_ODE, sol, 0.02, abstol = 1e-13, reltol = 1e-13)
br_fold_sh = continuation(probsh, cish, PALC(), opts_br; verbosity = 2, plot = true, bothside = true) 

scene = plot(br_fold_sh)

My question is as follows: During the calculation of the initial guess, the residual at step 0 is already around 1e-8. However, in the subsequent iterations, the residual gradually increases and the following warnings appear: Warning: Interrupted. Larger maxiters is needed. If you are using an integrator for non-stiff ODEs or an automatic switching algorithm (the default), you may want to consider using a method for stiff equations. or Warning: dt <= dtmin, and step error estimate = NaN. Aborting. There is either an error in your model specification or the true solution is unstable. Eventually, this leads to the initial guess failing to converge. I would like to know how to solve this problem.

PS: 1. The program seems to run very slowly; is there any way to further optimize it? 2. u0_new is obtained by using ode15s in MATLAB, where I observe that all variables tend to stabilize. However, during this process, I need to constantly adjust the value of AA (in the range of 1e8 to 1e12) and ReTol/AbsTol to ensure the solution appears correct. Is there a more effective and accurate solver in DifferentialEquation.jl for this type of ODE?

ODE_hybrid_com_and_initial_condition.zip

rveltz commented 4 months ago

Hi,

Can you try ls = DefaultLS() to check? You need to tune the options abstol, reltol of GMRESKrylovKit to make Shooting converge, these must be tuned with the tolerance given to ODEProblem. So it is probably easier to try DefaultLS to start and optimise later.

For this type of problem, I would probably use PeriodicOrbitOCollProblem which should be more precise than Shooting.

The program seems to run very slowly; is there any way to further optimize it

rveltz commented 4 months ago
Screenshot 2024-06-06 at 5 36 28 PM

Wow... Such a slow fast system. Solving with Rodas5 necessitate 5500 time steps sur (0,0.2).

LEquinoxy commented 4 months ago

Can you try ls = DefaultLS() to check?

Yes, I have tried this, but I got the same results (which takes me about 20 minutes):

1717684462179

For this type of problem, I would probably use PeriodicOrbitOCollProblem

Yes, I have tried collocation method, i have also tried this method in COCO Toolbox. I used the folowing code:

```julia
    probsh, cish = generate_ci_problem(PeriodicOrbitOCollProblem(150,4;meshadapt=true),
                        prob, sol, 0.02)

However, this line will lead to out of memory. if I reduce the mesh points, I get the following results: 1717687498740

The entire system consists of a rectifier-side AC grid, a rectifier, a DC line, an inverter, and an inverter-side AC grid. In my preliminary work, I have separated both sides to form two independent systems:

Rectifier-side AC grid + rectifier + ideal DC power source (constant) (corresponding to the 1st to 35th state variables in the ODE), and Ideal DC power source (constant) + inverter + inverter-side AC grid. For these two subsystems, the shooting method can at least ensure the convergence of the initial guess.

The warning reported by using the shooting method is related to the ODE solver. Perhaps I should provide the analytical form of the Jacobian? However, I started using the Julia language because of the bifurcationkit, and I don't know how to do it yet.

rveltz commented 4 months ago

By the way, your tolerances are way too big, I use:

prob_ODE = ODEProblem(ODE_hybrid_com, u0, (0, 0.5), par_ODE, reltol=1e-10, abstol=1e-12)
sol = @time solve(prob_ODE, Rodas5(), progress = true)
prob_ODE = ODEProblem(ODE_hybrid_com, sol.u[end], (0, 0.02), par_ODE, reltol=1e-10, abstol=1e-12)
sol = @time solve(prob_ODE,  Rodas5())

## Plot the initial guess
T = sol.t
u = hcat(sol.u...)
u29 = u[29, :]
u70 = u[70, :]
# mat"figure;plot($T, $u29);figure;plot($T, $u70)"
plot(T, u29);plot!(T, u70)
u0_new1 = sol.u[end]

## Define ODE and bifurcation problems
# prob_ODE = ODEProblem(ODE_hybrid_com, u0_new1, (0, 0.02), par_ODE, reltol=1e-13, abstol=1e-13)
prob_br = BifurcationProblem(ODE_hybrid_com, u0_new1, par_ODE, (@lens _.Kp_dc))

# Record variables for plotting
function recordFromSolution(x, p)
    xtt = BK.get_periodic_orbit(p.prob_br, x, p.p)
    return (max = maximum(xtt[1, :]), min = minimum(xtt[1, :]), period = getperiod(p.prob_br, x, p.p))
end

# Group parameters
argspo = (record_from_solution = recordFromSolution,)

# Settings
ls = DefaultLS()
ls = GMRESKrylovKit(dim = 100, verbose = 3, verbose = 2)
newton_options = NewtonPar(tol = 1e-10, max_iterations = 5, linsolver = ls; verbose = true)
opts_br = ContinuationPar(p_min = 0.1, p_max = 5.0, ds = 0.5, dsmax = 1.0, dsmin = 1e-10; n_inversion = 6, nev = 5, max_steps = 100, tol_stability = 1e-10, newton_options)

# Continuation
probsh, cish = generate_ci_problem(ShootingProblem(M = 5; jacobian = BK.AutoDiffMF()), prob_br, prob_ODE, sol, 0.02, abstol = 1e-12, reltol = 1e-10)

and it is quite fast

LEquinoxy commented 4 months ago

yes, this is a very stiff system, but very accurate. this is what i try to do for my PhD degree, lol.

rveltz commented 4 months ago

The warning reported by using the shooting method is related to the ODE solver. Perhaps I should provide the analytical form of the Jacobian? However, I started using the Julia language because of the bifurcationkit, and I don't know how to do it yet.

No the warning is related to reltol=1e-13. As a rule of thumbs, reltol =100abstol`. The jacobian is generated by AD and should be fine.

It is just that the jacobian for u29 is zero almost everywhere ;)

rveltz commented 4 months ago

I would reduce the stiffness coefficient, find a periodic orbit and continue that orbit

LEquinoxy commented 3 months ago

Thank you so much！But the jacobian setting jacobian=BK. AutoDiffMF()doesn't change the Jacobian ，I always get: ┌─ Standard shooting functional for periodic orbits ├─ time slices : 5 ├─ lens : Kp_dc ├─ jacobian : BifurcationKit.AutoDiffDense() ├─ update section : 1 ├─ integrator : Rodas5 └─ parallel : false

rveltz commented 3 months ago

it does, look at what ypu pasted: jacobian : BifurcationKit.AutoDiffDense() ├─

rveltz commented 3 months ago

have you made any progress here?

LEquinoxy commented 3 months ago

Sorry for the delayed response! Thanks to your suggestion, I reduced the stiffness coefficient to 1e7 and made some simplification of the model, now the continuation respect to parameter Kp_dc can run perfectly, and the results are highly consistent with our hardware-in-the-loop simulation. However, if I change the bifurcation parameter to Us_pu_rec, i will get something like the following (the codes are provided in the attachment)

```julia
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 45 
Step size = -2.4266e-05
Parameter Us_pu_rec = 9.3478e-01 ⟶  9.3476e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       3.4130e-05     │        0       │
|       1     │       4.9782e-06     │ (  43,   47)   |
|       2     │       2.4581e-06     │ (  40,   47)   |
|       3     │       3.3812e-08     │ (  40,   47)   |
└─────────────┴──────────────────────┴────────────────┘
──▶ Step Converged in 3 Nonlinear Iteration(s)
Parameter Us_pu_rec = 9.3478e-01 ⟶  9.3475e-01
──▶ Computed 76 eigenvalues in 1 iterations, #unstable = 0
Predictor: Bordered
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 46 
Step size = -2.4266e-05
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3473e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       2.0497e+00     │        0       │
|       1     │       2.3843e+01     │ (  45,   45)   |
┌ Warning: dt(3.469446951953614e-18) <= dtmin(3.469446951953614e-18) at t=0.0014336783977632033, and step error estimate = 4.788384048282231e-12. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
|       2     │       1.7962e+37     │ (  50,   50)   |
┌ Warning: dt(3.469446951953614e-18) <= dtmin(3.469446951953614e-18) at t=0.0014477272977239466, and step error estimate = 2.4010270160049256e-12. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
┌ Warning: dt(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, 
Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) <= dtmin(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, 
OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) at t=Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(0.0014889316139169385,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0), and step error estimate = 1.5657124563502283e-21. Aborting. There is either an error in your model specification or 
the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
┌ Warning: dt(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, 
Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) <= dtmin(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, 
OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) at t=Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(0.0014512636021267761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0), and step error estimate = 7.668711657012245e-23. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
┌ Warning: dt(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, 
Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) <= dtmin(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, 
OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) at t=Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(0.0014952099050150399,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0), and step error estimate = 2.7354746630432226e-20. Aborting. There is either an error in your model specification or 
the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
┌ Warning: dt(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, 
Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) <= dtmin(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, 
OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) at t=Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(0.0017854138870974207,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0), and step error estimate = 1.994757407309914e-9. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
┌ Warning: dt(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, 
Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) <= dtmin(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, 
OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) at t=Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(0.0017652076196951298,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0), and step error estimate = 2.9204832636820985e-6. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
┌ Warning: dt(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, 
Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) <= dtmin(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, 
OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) at t=Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(0.0017665000306842488,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0), and step error estimate = 2.92543460961958e-10. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
┌ Warning: dt(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, 
Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) <= dtmin(Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, 
OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(3.469446951953614e-18,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)) at t=Dual{ForwardDiff.Tag{BifurcationKit.var"#756#767"{NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ShootingProblem{BifurcationKit.FlowDE{ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, ODEFunction{true, SciMLBase.AutoSpecialize, typeof(ODE_hybrid_com), UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:reltol, :abstol), Tuple{Float64, Float64}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{1, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Vern7{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, KenCarp47{0, false, Nothing, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, BifurcationKit.AutoDiffDense, Nothing, Nothing, Base.Iterators.Pairs{Symbol, Float64, Tuple{Symbol, Symbol}, NamedTuple{(:abstol, :reltol), Tuple{Float64, Float64}}}, Nothing, Nothing, Float64}, BifurcationKit.AutoDiffDense, Vector{Float64}, SectionSS{Vector{Float64}, Vector{Float64}}, NamedTuple{(:AA, :Ihold_real, :Us_pu_rec, :Kp_dc, :Us_pu_inv, :Kp_CC), NTuple{6, Float64}}, Setfield.PropertyLens{:Us_pu_rec}}}, Float64}}(0.001649616151514616,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0), and step error estimate = 2.606418199120254e-6. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
┌ Warning: dt(3.469446951953614e-18) <= dtmin(3.469446951953614e-18) at t=0.0014450889567353084, and step error estimate = 1.0029078657733016e-19. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase C:\Users\Administrator\.julia\packages\SciMLBase\szsYq\src\integrator_interface.jl:599
|       3     │       3.6481e+37     │ ( 113,  135)   |
└─────────────┴──────────────────────┴────────────────┘
Newton correction failed
Halving ds to -1.213293283805332e-5
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 46 
Step size = -1.2133e-05
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3474e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       2.0309e+00     │        0       │
|       1     │       5.9283e+00     │ (  45,   47)   |
|       2     │       1.7152e+01     │ (  47,   48)   |
|       3     │       1.3167e+01     │ (  98,   99)   |
└─────────────┴──────────────────────┴────────────────┘
Newton correction failed
Halving ds to -6.06646641902666e-6
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 46 
Step size = -6.0665e-06
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       1.0687e-05     │        0       │
|       1     │       1.4335e-05     │ (  41,   46)   |
|       2     │       1.9655e-06     │ (  40,   47)   |
|       3     │       3.5223e+00     │ (  39,   47)   |
└─────────────┴──────────────────────┴────────────────┘
Newton correction failed
Halving ds to -3.03323320951333e-6
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 46 
Step size = -3.0332e-06
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       2.0494e+00     │        0       │
|       1     │       6.9948e-06     │ (  45,   45)   |
|       2     │       2.0462e+00     │ (  40,   45)   |
|       3     │       4.2882e+00     │ (  97,   97)   |
└─────────────┴──────────────────────┴────────────────┘
Newton correction failed
Halving ds to -1.516616604756665e-6
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 46 
Step size = -1.5166e-06
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       2.5846e-06     │        0       │
|       1     │       4.0550e-06     │ (  40,   46)   |
|       2     │       4.9550e-07     │ (  40,   47)   |
|       3     │       3.8277e-08     │ (  36,   47)   |
└─────────────┴──────────────────────┴────────────────┘
──▶ Step Converged in 3 Nonlinear Iteration(s)
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01
──▶ Computed 76 eigenvalues in 1 iterations, #unstable = 0
Predictor: Bordered
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 47 
Step size = -1.5166e-06
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       2.0275e+00     │        0       │
|       1     │       7.6869e-06     │ (  45,   45)   |
|       2     │       2.0275e+00     │ (  40,   47)   |
|       3     │       2.2109e-07     │ (  45,   45)   |
└─────────────┴──────────────────────┴────────────────┘
Newton correction failed
Halving ds to -1.0e-6
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 47 
Step size = -1.0000e-06
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       3.7605e-06     │        0       │
|       1     │       1.9871e-07     │ (  40,   47)   |
|       2     │       2.7396e-08     │ (  36,   47)   |
└─────────────┴──────────────────────┴────────────────┘
──▶ Step Converged in 2 Nonlinear Iteration(s)
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01
──▶ Computed 76 eigenvalues in 1 iterations, #unstable = 0
Predictor: Bordered
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 48 
Step size = -1.0556e-06
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       2.0280e+00     │        0       │
|       1     │       1.2549e-06     │ (  45,   45)   |
|       2     │       7.0085e-08     │ (  40,   47)   |
└─────────────┴──────────────────────┴────────────────┘
──▶ Step Converged in 2 Nonlinear Iteration(s)
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01
──▶ Computed 76 eigenvalues in 1 iterations, #unstable = 0
Predictor: Bordered
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 49 
Step size = -1.1142e-06
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       3.6888e-06     │        0       │
|       1     │       1.0391e+01     │ (  40,   47)   |
|       2     │       5.0963e+01     │ (  45,   45)   |
|       3     │       8.8278e+00     │ (  96,   97)   |
└─────────────┴──────────────────────┴────────────────┘
Newton correction failed
Halving ds to -1.0e-6
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Continuation step 49 
Step size = -1.0000e-06
Parameter Us_pu_rec = 9.3475e-01 ⟶  9.3475e-01 [guess]

┌─────────────────────────────────────────────────────┐
│ Newton step         residual      linear iterations │
├─────────────┬──────────────────────┬────────────────┤
│       0     │       3.2263e-06     │        0       │
|       1     │       1.0220e+01     │ (  40,   46)   |
|       2     │       2.0580e+00     │ (  45,   45)   |
|       3     │       3.9416e+00     │ (  97,   97)   |
└─────────────┴──────────────────────┴────────────────┘
Newton correction failed
┌ Error: Failure to converge with given tolerances.
│  We reached the smallest value [dsmin] valid for ds, namely 1.0e-6.
│  Stopping continuation.
└ @ BifurcationKit C:\Users\Administrator\.julia\packages\BifurcationKit\5kgAI\src\continuation\Contbase.jl:66

The results seems very strange to me. In addition, if the residual at Newton step 0 is around 1e00, the calculation will become very slow. Is there anything i can do to fix this problem ? Or Should I change to Trapezoid method?

test.zip

rveltz commented 3 months ago

Great. A few comments:

LEquinoxy commented 3 months ago

Thanks a lot for your patient guidance! I will try the collocation method. But for now, letting Ntst=200 and m=4 will lead to outofmemory, maybe because the dimension of the matrix (76x200x(4+1)=76000) is too high? By the way, if I reduce the Ntst, the initial guess will likely fail to converge.

rveltz commented 3 months ago

Yes, this is too big! I tried Collocation but it cannot converge because of the kinks in your trajectory. So either you stick to shooting or you know the parameters (slow or fast) which control the kinks. Then you put a small value and continue the periodic orbits until the required value.

LEquinoxy commented 3 months ago

I’ve been adjusting the stiffness parameters in the ODEs these past couple of days, and now the shooting method can accurately continue for Us_pu_rec. I’m going to try continuing the torus bifurcation point and detecting the codim 2 bifurcation. If I encounter any issues during this process, could I possibly ask for your assistance? I’m sorry for taking up your time. Thanks again for your amazing toolkit and patience—it really saved my life!!!!!

rveltz commented 3 months ago

Sure

rveltz commented 3 months ago

should we close this for now?

LEquinoxy commented 3 months ago

Sure, you can close it