Merge pull request #1728 from JuliaRobotics/23Q3/refac/paramfiles

better organize src files

Author: dehann

src/Deprecated.jl

@@ -124,6 +124,17 @@ end
 ## Deprecate code below before v0.35
 ##==============================================================================
 
+# should probably deprecate the abstract type approach?
+abstract type _AbstractThreadModel end
+
+"""
+$(TYPEDEF)
+"""
+struct SingleThreaded <: _AbstractThreadModel end
+# """
+# $(TYPEDEF)
+# """
+# struct MultiThreaded <: _AbstractThreadModel end
 
 
 function _solveLambdaNumeric(

src/IncrementalInference.jl

@@ -60,7 +60,7 @@ using Logging
 using PrecompileTools
 
 # bringing in BSD 3-clause ccolamd
-include("ccolamd.jl")
+include("services/ccolamd.jl")
 using SuiteSparse.CHOLMOD: SuiteSparse_long # For CCOLAMD constraints.
 using .Ccolamd
 
@@ -120,23 +120,29 @@ include("ExportAPI.jl")
 # FIXME, move up to DFG
 # abstract type AbstractManifoldMinimize <: AbstractRelative end
 
-#
-include("ManifoldsExtentions.jl")
+
+
 # regular
 include("entities/SolverParams.jl")
 
 include("entities/HypoRecipe.jl")
+include("entities/CalcFactor.jl")
 include("entities/FactorOperationalMemory.jl")
 
 include("Factors/GenericMarginal.jl")
 # Special belief types for sampling as a distribution
 include("entities/AliasScalarSampling.jl")
 include("entities/OptionalDensities.jl")
 include("entities/BeliefTypes.jl")
+
+#
+include("manifolds/services/ManifoldsExtentions.jl")
+include("manifolds/services/ManifoldSampling.jl")
+
 include("entities/FactorGradients.jl")
 
 # Statistics helpers on manifolds
-include("VariableStatistics.jl")
+include("services/VariableStatistics.jl")
 
 # factors needed for belief propagation on the tree
 include("Factors/MsgPrior.jl")
@@ -201,44 +207,44 @@ include("services/ExplicitDiscreteMarginalizations.jl")
 include("services/EvalFactor.jl")
 include("services/ApproxConv.jl")
 
-# FIXME CONSOLIDATE
-include("ConsolidateParametricRelatives.jl")
 
 include("services/GraphProductOperations.jl")
 include("services/SolveTree.jl")
 include("services/TetherUtils.jl")
 include("services/TreeDebugTools.jl")
 include("CliqueStateMachine/services/CliqStateMachineUtils.jl")
 
+# FIXME CONSOLIDATE
+include("parametric/services/ConsolidateParametricRelatives.jl")
 #EXPERIMENTAL parametric
-include("ParametricCSMFunctions.jl")
-include("ParametricUtils.jl")
-include("ParametricManoptDev.jl")
+include("parametric/services/ParametricCSMFunctions.jl")
+include("parametric/services/ParametricUtils.jl")
+include("parametric/services/ParametricOptim.jl")
+include("parametric/services/ParametricManoptDev.jl")
 include("services/MaxMixture.jl")
 
 #X-stroke
 include("CliqueStateMachine/services/CliqueStateMachine.jl")
 
-include("CanonicalGraphExamples.jl")
+include("services/CanonicalGraphExamples.jl")
 
 include("services/AdditionalUtils.jl")
-include("SolverAPI.jl")
+include("services/SolverAPI.jl")
 
 # Symbolic tree analysis files.
-include("AnalysisTools.jl")
+include("services/AnalysisTools.jl")
 
-include("ManifoldSampling.jl")
 
 # deprecation legacy support
 include("Deprecated.jl")
 
 exportimg(pl) = error("Please do `using Gadfly` to allow image export.")
 function __init__()
   @require InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240" include(
-    "RequireInteractiveUtils.jl",
+    "services/RequireInteractiveUtils.jl",
   )
   @require Gadfly = "c91e804a-d5a3-530f-b6f0-dfbca275c004" include(
-    "EmbeddedPlottingUtils.jl",
+    "services/EmbeddedPlottingUtils.jl",
   )
   @require DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa" include(
     "ODE/DERelative.jl",

src/entities/CalcFactor.jl

@@ -0,0 +1,96 @@
+
+abstract type AbstractMaxMixtureSolver end
+
+
+"""
+$TYPEDEF
+
+User factor interface method for computing the residual values of factors.
+
+Notes
+- Also see #467 on API consolidation
+
+```julia
+function (cf::CalcFactor{<:LinearRelative})(res::AbstractVector{<:Real}, z, xi, xj)
+  cf.variablelist
+  cf.cache
+  # generic on-manifold residual function 
+  return distance(z, distance(xj, xi))
+end
+```
+
+DevNotes
+- Follow the Github project in IIF to better consolidate CCW FMD CPT CF CFM
+
+Related 
+
+[`CalcFactorMahalanobis`](@ref), [`CommonConvWrapper`](@ref)
+"""
+struct CalcFactor{
+  FT <: AbstractFactor, 
+  X, 
+  C, 
+  VT <: Tuple, 
+  M <: AbstractManifold
+}
+  """ the interface compliant user object functor containing the data and logic """
+  factor::FT
+  """ what is the sample (particle) id for which the residual is being calculated """
+  _sampleIdx::Int
+  """ legacy support for variable values old functor residual functions.
+      TBD, this is still being used by DERelative factors. """
+  _legacyParams::X
+  """ allow threading for either sampling or residual calculations (workaround for thread yield issue) """
+  _allowThreads::Bool
+  """ user cache of arbitrary type, overload the [`preambleCache`](@ref) function. NOT YET THREADSAFE """
+  cache::C
+
+  ## TODO Consolidation WIP with FactorMetadata
+  # full list of variables connected to the factor
+  # TODO make sure this list is of the active hypo only
+  fullvariables::VT # Vector{<:DFGVariable} # FIXME change to tuple for better type stability
+  # which index is being solved for?
+  solvefor::Int
+  manifold::M
+end
+
+
+
+"""
+$TYPEDEF
+
+Internal parametric extension to [`CalcFactor`](@ref) used for buffering measurement and calculating Mahalanobis distance
+
+Related
+
+[`CalcFactor`](@ref)
+"""
+struct CalcFactorMahalanobis{N, D, L, S <: Union{Nothing, AbstractMaxMixtureSolver}}
+  faclbl::Symbol
+  calcfactor!::CalcFactor
+  varOrder::Vector{Symbol}
+  meas::NTuple{N, <:AbstractArray}
+  iΣ::NTuple{N, SMatrix{D, D, Float64, L}}
+  specialAlg::S
+end
+
+
+
+
+struct CalcFactorManopt{
+  D,
+  L,
+  FT <: AbstractFactor,
+  M <: AbstractManifold,
+  MEAS <: AbstractArray,
+}
+  faclbl::Symbol
+  calcfactor!::CalcFactor{FT, Nothing, Nothing, Tuple{}, M}
+  varOrder::Vector{Symbol}
+  varOrderIdxs::Vector{Int}
+  meas::MEAS
+  iΣ::SMatrix{D, D, Float64, L}
+  sqrt_iΣ::SMatrix{D, D, Float64, L}
+end
+
+

src/entities/FactorOperationalMemory.jl

@@ -1,68 +1,4 @@
 
-"""
-$TYPEDEF
-
-User factor interface method for computing the residual values of factors.
-
-Notes
-- Also see #467 on API consolidation
-
-```julia
-function (cf::CalcFactor{<:LinearRelative})(res::AbstractVector{<:Real}, z, xi, xj)
-  cf.variablelist
-  cf.cache
-  # generic on-manifold residual function 
-  return distance(z, distance(xj, xi))
-end
-```
-
-DevNotes
-- Follow the Github project in IIF to better consolidate CCW FMD CPT CF CFM
-
-Related 
-
-[`CalcFactorMahalanobis`](@ref), [`CommonConvWrapper`](@ref)
-"""
-struct CalcFactor{
-  FT <: AbstractFactor, 
-  X, 
-  C, 
-  VT <: Tuple, 
-  M <: AbstractManifold
-}
-  """ the interface compliant user object functor containing the data and logic """
-  factor::FT
-  """ what is the sample (particle) id for which the residual is being calculated """
-  _sampleIdx::Int
-  """ legacy support for variable values old functor residual functions.
-      TBD, this is still being used by DERelative factors. """
-  _legacyParams::X
-  """ allow threading for either sampling or residual calculations (workaround for thread yield issue) """
-  _allowThreads::Bool
-  """ user cache of arbitrary type, overload the [`preambleCache`](@ref) function. NOT YET THREADSAFE """
-  cache::C
-
-  ## TODO Consolidation WIP with FactorMetadata
-  # full list of variables connected to the factor
-  # TODO make sure this list is of the active hypo only
-  fullvariables::VT # Vector{<:DFGVariable} # FIXME change to tuple for better type stability
-  # which index is being solved for?
-  solvefor::Int
-  manifold::M
-end
-
-# should probably deprecate the abstract type approach?
-abstract type _AbstractThreadModel end
-
-"""
-$(TYPEDEF)
-"""
-struct SingleThreaded <: _AbstractThreadModel end
-"""
-$(TYPEDEF)
-"""
-struct MultiThreaded <: _AbstractThreadModel end
-
 
 
 """

src/ManifoldSampling.jl renamed to src/manifolds/services/ManifoldSampling.jl

@@ -23,27 +23,6 @@ function Optim.project_tangent!(M::ManifoldWrapper, g, x)
     return g
 end
 
-# experimental
-function optimizeManifold_FD(
-  M::AbstractManifold, 
-  cost::Function,
-  x0::AbstractArray;
-  algorithm = Optim.ConjugateGradient(; manifold=ManifoldWrapper(M))
-)
-  # finitediff setup
-  r_backend = ManifoldDiff.TangentDiffBackend(
-    ManifoldDiff.FiniteDifferencesBackend()
-  )
-  
-  ## finitediff gradient (non-manual)
-  function costgrad_FD!(X,p)
-    X .= ManifoldDiff.gradient(M, cost, p, r_backend)
-    X
-  end
-
-  Optim.optimize(cost, costgrad_FD!, x0, algorithm)
-end
-
 
 ## ================================================================================================
 ## AbstractPowerManifold with N as field to avoid excessive compiling time.

src/ManifoldsExtentions.jl renamed to src/manifolds/services/ManifoldsExtentions.jl

@@ -9,21 +9,7 @@ using SparseArrays
 
 ##
 
-struct CalcFactorManopt{
-  D,
-  L,
-  FT <: AbstractFactor,
-  M <: AbstractManifold,
-  MEAS <: AbstractArray,
-}
-  faclbl::Symbol
-  calcfactor!::CalcFactor{FT, Nothing, Nothing, Tuple{}, M}
-  varOrder::Vector{Symbol}
-  varOrderIdxs::Vector{Int}
-  meas::MEAS
-  iΣ::SMatrix{D, D, Float64, L}
-  sqrt_iΣ::SMatrix{D, D, Float64, L}
-end
+
 
 function CalcFactorManopt(fct::DFGFactor, varIntLabel)
   fac_func = getFactorType(fct)

src/ConsolidateParametricRelatives.jl renamed to src/parametric/services/ConsolidateParametricRelatives.jl

@@ -0,0 +1,21 @@
+
+# experimental
+function optimizeManifold_FD(
+  M::AbstractManifold, 
+  cost::Function,
+  x0::AbstractArray;
+  algorithm = Optim.ConjugateGradient(; manifold=ManifoldWrapper(M))
+)
+  # finitediff setup
+  r_backend = ManifoldDiff.TangentDiffBackend(
+    ManifoldDiff.FiniteDifferencesBackend()
+  )
+  
+  ## finitediff gradient (non-manual)
+  function costgrad_FD!(X,p)
+    X .= ManifoldDiff.gradient(M, cost, p, r_backend)
+    X
+  end
+
+  Optim.optimize(cost, costgrad_FD!, x0, algorithm)
+end