Define analysis_solver and optimization_solver

EdoAlvarezR · EdoAlvarezR · commit 186bbbe142ab · 2026-01-23T17:27:33.000-06:00
diff --git a/Project.toml b/Project.toml
@@ -20,7 +20,7 @@ CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 SimpleNonlinearSolve = "727e6d20-b764-4bd8-a329-72de5adea6c7"
 NonlinearSolve = "8913a72c-1f9b-4ce2-8d82-65094dcecaec"
-NLsolve = "2774e3e8-f4cf-5e23-947b-6d7e65073b56"
+ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
 
 # [sources]
 # FastMultipole = {url = "https://github.com/byuflowlab/FastMultipole", rev = "d21d242d081ea8c9c19655097d83413b1f783d2d"}
diff --git a/examples/liftingline_a50k27.jl b/examples/liftingline_a50k27.jl
@@ -109,8 +109,8 @@ sigmafactor     = 0.0                           # Dragging line amplification fa
 sigmaexponent   = 1.0                           # Dragging line amplification exponent (no effects if `sigmafactor==0.0`)
 
                                                 # Nonlinear solver
-solver          = pnl.SimpleNonlinearSolve.SimpleDFSane()              # Indifferent to initial guess, but somewhat not robust
-# solver        = pnl.SimpleNonlinearSolve.SimpleTrustRegion()         # Trust region needs a good initial guess, but it converges very reliably
+solver          = pnl.analysis_solver           # Very robust and physically accurate, but it can take a long time post-stall (not AD compatible)
+# solver        = pnl.optimization_solver       # Robus, fast, and ForwardDiff compatible, but often times it returns the secondary solution that is unphysical post stall
 
 solver_optargs  = (; 
                     abstol = 1e-9,  
diff --git a/examples/liftingline_weber.jl b/examples/liftingline_weber.jl
@@ -25,8 +25,6 @@ include(joinpath(pnl.examples_path, "plotformat.jl"))
 import CSV
 import DataFrames: DataFrame
 
-import SIAMFANLEquations
-
 
 run_name        = "ll-weber"                    # Name of this run
 
@@ -114,16 +112,8 @@ sigmafactor     = 0.0                           # Dragging line amplification fa
 sigmaexponent   = 4.0                           # Dragging line amplification exponent (no effects if `sigmafactor==0.0`)
 
                                                 # Nonlinear solver
-# solver          = pnl.SimpleNonlinearSolve.SimpleDFSane()              # Indifferent to initial guess, but somewhat not robust
-# solver        = pnl.SimpleNonlinearSolve.SimpleTrustRegion()         # Trust region needs a good initial guess, but it converges very reliably
-solver          = pnl.NonlinearSolve.SimpleBroyden()                      # <---- Wining
-# solver        = pnl.NonlinearSolve.NLsolveJL(method = :trust_region)
-# solver        = pnl.NonlinearSolve.SIAMFANLEquationsJL(method = :anderson)
-# solver        = pnl.NonlinearSolve.FixedPointAccelerationJL(; algorithm = :Newton)
-# solver        = pnl.NonlinearSolve.FixedPointAccelerationJL(; algorithm = :Newton)
-# solver = pnl.NonlinearSolve.NonlinearSolveQuasiNewton.Broyden(; autodiff = ADTypes.AutoForwardDiff(),  init_jacobian=Val(:true_jacobian))
-# solver = pnl.NonlinearSolve.NonlinearSolve.FastShortcutNLLSPolyalg(; autodiff = ADTypes.AutoForwardDiff(), vjp_autodiff = ADTypes.AutoForwardDiff(), jvp_autodiff = ADTypes.AutoForwardDiff()), # <--- WINING
-# solver = pnl.NonlinearSolve.NonlinearSolve.FastShortcutNonlinearPolyalg(; autodiff = ADTypes.AutoForwardDiff(), vjp_autodiff = ADTypes.AutoForwardDiff(), jvp_autodiff = ADTypes.AutoForwardDiff(), prefer_simplenonlinearsolve = Val(true)) 
+solver          = pnl.analysis_solver           # Very robust and physically accurate, but it can take a long time post-stall (not AD compatible)
+# solver        = pnl.optimization_solver       # Robus, fast, and ForwardDiff compatible, but often times it returns the secondary solution that is unphysical post stall
 
 solver_optargs  = (; 
                     abstol = 1e-9,  
diff --git a/src/FLOWPanel.jl b/src/FLOWPanel.jl
@@ -24,9 +24,9 @@ import Dierckx
 import LinearAlgebra as LA
 import LinearAlgebra: I
 import Krylov
-import NLsolve
 import NonlinearSolve
 import SimpleNonlinearSolve
+import ADTypes
 import Requires: @require
 
 # ------------ FLOW LAB MODULES ------------------------------------------------
diff --git a/src/liftingline/nonlinearsolver.jl b/src/liftingline/nonlinearsolver.jl
@@ -22,6 +22,31 @@
   * License     : MIT License
 =###############################################################################
 
+"""
+Robust, fast, and ForwardDiff compatible (though solver might be a bit noise, so 
+set optimizer tol ~5e-5). Often it returns the secondary solution that is 
+unphysical post stall. Not CSDA compatible.
+"""
+const optimization_solver = NonlinearSolve.FastShortcutNonlinearPolyalg(; 
+                                autodiff = :forward, 
+                                vjp_autodiff = :forward, jvp_autodiff = :forward, 
+                                prefer_simplenonlinearsolve = Val(true)
+                                )
+
+"""
+Very robust and physically accurate, but it can take a long time. 
+Not ForwardDiff nor CSDA compatible.
+"""
+const analysis_solver = NonlinearSolve.FastShortcutNLLSPolyalg(; 
+                                autodiff = ADTypes.AutoForwardDiff(), 
+                                # vjp_autodiff = ADTypes.AutoForwardDiff(), 
+                                # jvp_autodiff = ADTypes.AutoForwardDiff(), 
+                                )
+
+
+
+
+                                
 function solve(self::LiftingLine, Uinf::AbstractVector, 
                                             args...; optargs...) 
     solve(self, repeat(Uinf, 1, self.nelements), args...; optargs...)
diff --git a/src/liftingline/optimization.jl b/src/liftingline/optimization.jl
@@ -134,12 +134,13 @@ function run_liftingline(;
                                                         # Nonlinear solver
         # solver        = SimpleNonlinearSolve.SimpleDFSane(),             # Indifferent to initial guess, but somewhat not robust post stall   <---- NOT COMPATIBLE WITH FORWARDDIFF (but compatible with CSDA and optimization converges well)
         # solver        = SimpleNonlinearSolve.SimpleTrustRegion(),        # Trust region needs a good initial guess, but solver converges very reliably post stall, not compatible with CSDA nor ForwardDiff
-        solver        = NonlinearSolve.SimpleBroyden(),                  # Optimization converges well while being compatible with ForwardDiff (not compatible with CSDA). EXTREMELY ROBUST ACROSS LINEAR, MILD STALL, AND DEEP STALL (it returns an answer, but it might be noise and not accurate)
+        # solver        = NonlinearSolve.SimpleBroyden(),                  # Optimization converges well while being compatible with ForwardDiff (not compatible with CSDA). EXTREMELY ROBUST ACROSS LINEAR, MILD STALL, AND DEEP STALL (it returns an answer, but it might be noise and not accurate)
         # solver        = NonlinearSolve.NonlinearSolveQuasiNewton.Broyden(; autodiff = ADTypes.AutoForwardDiff(),  init_jacobian=Val(:true_jacobian)) # Also extremely robust across regions (it returns an answer, but it might be noise and not accurate)
         # solver        = NonlinearSolve.NLsolveJL(method = :trust_region),# Optimization converges very well with ForwardDiff, not compatible with CSDA. Solver converges slowly but realibly in linear and mild stall regions, does not converge post stall
         # solver        = NonlinearSolve.SIAMFANLEquationsJL(method = :newton, autodiff=ADTypes.AutoForwardDiff()), # Also robust in linear and mild stall regions, but much faster
         # solver        = NonlinearSolve.NonlinearSolve.FastShortcutNLLSPolyalg(; autodiff = ADTypes.AutoForwardDiff(), vjp_autodiff = ADTypes.AutoForwardDiff(), jvp_autodiff = ADTypes.AutoForwardDiff()) # Very robust, but it can take a long time. Not ForwardDiff nor CSDA compatible
         # solver        = NonlinearSolve.NonlinearSolve.FastShortcutNonlinearPolyalg(; autodiff = ADTypes.AutoForwardDiff(), vjp_autodiff = ADTypes.AutoForwardDiff(), jvp_autodiff = ADTypes.AutoForwardDiff(), prefer_simplenonlinearsolve = Val(true)) # 100% convergence, and super fast, but it might return the wrong solution. ForwardDiff compatible (though solver might be a bit noise, so set optimizer tol ~5e-5)
+        solver          = optimization_solver,
         
         solver_optargs  = (; 
                             abstol = 1e-13,  
diff --git a/test/runtests_liftingline.jl b/test/runtests_liftingline.jl
@@ -104,7 +104,7 @@ v_lvl = 0
         # deltajoint    = 0.15                          # Joint distance, deltajoint = dx/c
         deltajoint      = 1.0
                                                         # Nonlinear solver
-        solver          = pnl.SimpleNonlinearSolve.SimpleDFSane()
+        solver          = pnl.analysis_solver
         solver_optargs  = (; abstol = 1e-9)
 
         Dhat            = Uinf/norm(Uinf)               # Drag direction
diff --git a/test/runtests_liftingline_optimization.jl b/test/runtests_liftingline_optimization.jl
@@ -266,7 +266,7 @@ v_lvl = 0
                                     sigmaexponent   = 4.0,                          # Dragging line amplification exponent (no effects if `sigmafactor==0.0`)
                                     
                                                                                     # Nonlinear solver
-                                    solver          = pnl.SimpleNonlinearSolve.SimpleDFSane(),             # Indifferent to initial guess, but somewhat not robust
+                                    solver          = pnl.optimization_solver,
                                     
                                     solver_optargs  = (; 
                                                         abstol = 1e-9,  
diff --git a/test/runtests_liftingline_optimization_snopt.jl b/test/runtests_liftingline_optimization_snopt.jl
@@ -130,8 +130,10 @@ v_lvl = 0
                                     # solver          = pnl.NonlinearSolve.SimpleBroyden(),              # This seems to converge well while being compatible with ForwardDiff
                                     # solver        = pnl.NonlinearSolve.NLsolveJL(method = :trust_region), # Converges very well with ForwardDiff, not compatible with CSDA
 
-                                    # solver = pnl.NonlinearSolve.NonlinearSolve.FastShortcutNLLSPolyalg(; autodiff = ADTypes.AutoForwardDiff(), vjp_autodiff = ADTypes.AutoForwardDiff(), jvp_autodiff = ADTypes.AutoForwardDiff()),
-                                    solver = pnl.NonlinearSolve.NonlinearSolve.FastShortcutNonlinearPolyalg(; autodiff = ADTypes.AutoForwardDiff(), vjp_autodiff = ADTypes.AutoForwardDiff(), jvp_autodiff = ADTypes.AutoForwardDiff(), prefer_simplenonlinearsolve = Val(true)), # Robust, fast, and ForwardDiff compatible (though solver might be a bit noise, so set optimizer tol ~5e-5)
+                                    # solver        = pnl.NonlinearSolve.NonlinearSolve.FastShortcutNLLSPolyalg(; autodiff = ADTypes.AutoForwardDiff(), vjp_autodiff = ADTypes.AutoForwardDiff(), jvp_autodiff = ADTypes.AutoForwardDiff()),
+                                    # solver        = pnl.NonlinearSolve.NonlinearSolve.FastShortcutNonlinearPolyalg(; autodiff = :forward, vjp_autodiff = :forward, jvp_autodiff = :forward, prefer_simplenonlinearsolve = Val(true)), # Robust, fast, and ForwardDiff compatible (though solver might be a bit noise, so set optimizer tol ~5e-5)
+                                    
+                                    solver          = pnl.optimization_solver,
                                     
                                     solver_optargs  = (; 
                                                         abstol = 1e-12,             # <-- tight tolerance to converge derivatives
