GitHub

Pre-compiling the Caches

There are several available caches that can be precompiled to help speed up multiple analyses. The first is a cache used for intermediate calculations in the pre- and post-processing phases of the analysis. It can be preallocated using allocate_prepost_container_cache

DuctAPE.allocate_prepost_container_cache — Function
allocate_prepost_container_cache(paneling_constants::PanelingConstants)
allocate_prepost_container_cache(problem_dimensions::ProblemDimensions)

Allocate the pre- and post-processing cache (used for intermediate calculations) based on paneling constants or problem dimensions.

Arguments

  • paneling_constants::PanelingConstants : a PanelingConstants object

OR

  • problem_dimensions::ProblemDimensions : a ProblemDimensions object

Keyword Arguments

  • fd_chunk_size::Int=12 : chunk size to use for PreallocationTools caches. Note that the automated chunk size for DuctAPE will always be the ForwardDiff threshold of 12 due to the size of the system, so it will be best to leave this at the default unless further development allows for chunk size selection for individual solvers.
  • levels::Int=1 : levels for nested duals. Note that since ImplicitAD is being used for all solves, there should be no need for more than 1 level.

Returns

  • prepost_container_caching::NamedTuple : a Named Tuple containing:
    • prepost_container_cache::PreallocationTools.DiffCache : the cache
    • prepost_container_cache_dims::NamedTuple : a named tuple containing the dimensions used for reshaping the cache when needed.
source

The second is a cache containing parameters used in the solver, in other words, the results of the pre-processing phase. It can be preallocated using allocate_solve_parameter_cache.

DuctAPE.allocate_solve_parameter_cache — Function
allocate_solve_parameter_cache(
    solve_type::SolverOptionsType,
    paneling_constants::PanelingConstants;
    fd_chunk_size=12,
    levels=1,
)
allocate_solve_parameter_cache(
    solve_type::SolverOptionsType,
    problem_dimensions::ProblemDimensions;
    fd_chunk_size=12,
    levels=1
)

Allocate the solve parameter cache for parameters passed into the solver(s).

Arguments

  • solve_type::SolverOptionsType : Solver options type used for dispatch
  • paneling_constants::PanelingConstants : a PanlingConstants object used for sizing

OR

  • problem_dimensions::ProblemDimensions : a ProblemDimensions object used for sizing

Keyword Arguments

  • fd_chunk_size::Int=12 : chunk size to use for PreallocationTools caches. Note that the automated chunk size for DuctAPE will always be the ForwardDiff threshold of 12 due to the size of the system, so it will be best to leave this at the default unless further development allows for chunk size selection for individual solvers.
  • levels::Int=1 : levels for nested duals. Note that since ImplicitAD is being used for all solves, there should be no need for more than 1 level.

Returns

  • solve_parameter_caching::NamedTuple : a Named Tuple containing:
    • solve_parameter_cache::PreallocationTools.DiffCache : the cache
    • solve_parameter_cache_dims::NamedTuple : a named tuple containing the dimensions used for reshaping the cache when needed.
source

The final precompileable cache is for intermediate calculations within the solve and can be preallocated using allocate_solve_container_cache

DuctAPE.allocate_solve_container_cache — Function
allocate_solve_container_cache(
    solve_type::SolverOptionsType,
    paneling_constants::PanelingConstants;
    fd_chunk_size=12,
    levels=1,
)
allocate_solve_container_cache(
    solve_type::SolverOptionsType,
    problem_dimensions::ProblemDimensions;
    fd_chunk_size=12,
    levels=1,
)

Allocate the solve cache (used for intermediate calculations) based on paneling constants or problem dimensions.

Arguments

  • paneling_constants::PanelingConstants : a PanelingConstants object

OR

  • problem_dimensions::ProblemDimensions : a ProblemDimensions object

Keyword Arguments

  • fd_chunk_size::Int=12 : chunk size to use for PreallocationTools caches. Note that the automated chunk size for DuctAPE will always be the ForwardDiff threshold of 12 due to the size of the system, so it will be best to leave this at the default unless further development allows for chunk size selection for individual solvers.
  • levels::Int=1 : levels for nested duals. Note that since ImplicitAD is being used for all solves, there should be no need for more than 1 level.

Returns

  • solve_container_caching::NamedTuple : a Named Tuple containing:
    • solve_container_cache::PreallocationTools.DiffCache : the cache
    • solve_container_cache_dims::NamedTuple : a named tuple containing the dimensions used for reshaping the cache when needed.
source

You may run all these simultaneously using the initialize_all_caches function.

DuctAPE.initialize_all_caches — Function
initialize_all_caches(solver_options, paneling_constants)

Convenience function to initialize all caches before calling analysis.

Arguments

  • solver_options::SolverOptionsType : solver options used for cache allocation dispatch
  • paneling_constants::PanelingConstants : PanelingConstants object upon which all cache sizing depends

Keyword Arguments

  • fd_chunk_size::Int=12 : chunk size to use for PreallocationTools caches. Note that the automated chunk size for DuctAPE will always be the ForwardDiff threshold of 12 due to the size of the system, so it will be best to leave this at the default unless further development allows for chunk size selection for individual solvers.
  • levels::Int=1 : levels for nested duals. Note that since ImplicitAD is being used for all solves, there should be no need for more than 1 level.

Returns

  • prepost_container_caching::NamedTuple : A named tuple containing the PreallocationTools DiffCache and a named tuple with relevant dimensions for accessing the cache.
  • solve_parameter_caching::NamedTuple : A named tuple containing the PreallocationTools DiffCache and a named tuple with relevant dimensions for accessing the cache.
  • solve_container_caching::NamedTuple : A named tuple containing the PreallocationTools DiffCache and a named tuple with relevant dimensions for accessing the cache.
source

As an example of how to run this function, we'll grab solver options and paneling constants from previous examples

# - grab an object of SolverOptionsType defined in a previous example - #
aero_solver_options = DuctAPE.NLsolveOptions(;
    algorithm=:newton,
    atol=1e-10,
    iteration_limite=30,
    linesearch_method=LineSearches.BackTracking, #don't include parentheses on method handle
    linesearch_kwargs=(; order=3, maxstep=1e6),
    additional_kwargs=(; autoscale=false),
)

# - grab an object of PanelingConstants type from the Getting Started tutorial - #
# number of panels for the duct inlet
nduct_inlet = 30

# number of panels for the center body inlet
ncenterbody_inlet = 30

# number of panels from:
#  - rotor to duct trailing edge
#  - duct trailing edge to center body trailing edge
#  - center body trailing edge to end of wake
npanels = [30, 1, 30]

# the duct trailing edge is ahead of the centerbody trailing edge.
dte_minus_cbte = -1.0

# number of wake sheets (one more than blade elements to use)
nwake_sheets = 11

# non-dimensional wake length aft of rear-most trailing edge
wake_length = 0.8

# assemble paneling constants
paneling_constants = DuctAPE.PanelingConstants(
    nduct_inlet, ncenterbody_inlet, npanels, dte_minus_cbte, nwake_sheets, wake_length
)

# - Initialize Caches - #
prepost_container_caching, solve_parameter_caching, solve_container_caching = DuctAPE.initialize_all_caches(aero_solver_options, paneling_constants)

How to pass the caches into an analysis

The precompiled caches can be passed in via keyword arguments to the analysis functions. If they are not, they are generated as the first step in the analysis.

DuctAPE.analyze — Function
analyze(
    ducted_rotor::DuctedRotor,
    operating_point::OperatingPoint,
    reference_parameters::ReferenceParameters,
    options::Options=set_options();
    prepost_container_caching=nothing,
    solve_parameter_caching=nothing,
    solve_container_caching=nothing,
    return_inputs=false,
)

Analyze ducted_rotor, including preprocessing.

Arguments

  • ducted_rotor::DuctedRotor : DuctedRotor input object (see docstring for DuctedRotor type)
  • operating_point::OperatingPoint : OperatingPoint input object (see docstring for OperatingPoint type)
  • reference_parameters::ReferenceParameters : ReferenceParameters input object (see docstring for ReferenceParameters type)
  • options::Options=set_options() : Options object (see set_options and related functions)

Keyword Arguments

  • prepost_container_caching=nothing : Output of allocate_prepost_container_cache
  • solve_parameter_caching=nothing : Output of allocate_solve_parameter_container_cache
  • solve_container_caching=nothing : Output of allocate_solve_container_cache
  • return_inputs=false : flag as to whether or not to return the pre-processed inputs

Returns

  • outs::NamedTuple : Named Tuple of various analysis outputs (see docstring for postprocess for details), note, if linear system decomposition fails, no solve is performed and an empty vector is returned.
  • ins::NamedTuple : Named Tuple of various pre-processed inputs (e.g. panels and body linear system), will only be returned if return_inputs=true
  • convergence_flag : Flag for successful solve convergence
source