• logger::Cthonios.CthoniosLogger

• timer::Cthonios.CthoniosTimer

• backend::Cthonios.CthoniosBackend

CthoniosCommon(
    file_name::String,
    backend::Cthonios.CthoniosBackend
) -> Cthonios.CthoniosCommon

CthoniosCommon(file_name, backend)

• logger::LoggingExtras.FormatLogger

CthoniosLogger(file_name::String) -> Cthonios.CthoniosLogger

CthoniosLogger(file_name)

• timer::TimerOutputs.TimerOutput

CthoniosTimer() -> Cthonios.CthoniosTimer

CthoniosTimer()

Constructor for post processor

closes exodus db by default, needs to be re-opend downstream this is mainly for debuggin purposes

end_section(section_name::String)

end_section(section_name)

load_input_file(input_file::String) -> Dict{Symbol, Any}

This method is a barrier method for type stability

load_input_file(input_file)

minimize_trust_region_sub_problem!(
    z,
    solver::Cthonios.TrustRegionSolver,
    domain,
    common::Cthonios.CthoniosCommon,
    x::AbstractVector,
    r_in::AbstractVector,
    tr_size::Float64
) -> Tuple{Symbol, Int64}

minimize r * z + 0.5 * z * J * z

minimize_trust_region_sub_problem!(
    z,
    solver,
    domain,
    common,
    x,
    r_in,
    tr_size
)

new_section(section_name::String)

new_section(section_name)

parse_boundary_conditions(
    input_settings::Dict{Symbol, Any},
    domain_key::Symbol
) -> Dict{Symbol, Any}

Barrier for type stability. Returns inputsettings[:boundaryconditions] but also replaces function names with function input settings.

parse_boundary_conditions(input_settings, domain_key)

parse_domains(
    input_settings::Dict{Symbol, Any}
) -> Dict{Symbol, Any}

Helper to parse a domain and all settings need to set it up

parse_domains(input_settings)

parse_domains(
    input_settings::Dict{Symbol, Any}
) -> Dict{Symbol, Any}

Helper to parse one domain

parse_domains(input_settings, key)

parse_domains(input_settings)

parse_functions(
    input_settings::Dict{Symbol, Any}
) -> Dict{Symbol, Any}

Barrier for type stability. Simply returns input_settings[:functions]

parse_functions(input_settings)

parse_input_file(input_file::String) -> Dict{Symbol, Any}

Main entry point for parsing

parse_input_file(input_file)

parse_linear_solvers(
    input_settings::Dict{Symbol, Any}
) -> Dict{Symbol, Any}

Barrier for type stability. Simply returns input_settings[Symbol("linear solvers")]

parse_linear_solvers(input_settings)

parse_materials(
    input_settings::Dict{Symbol, Any}
) -> Dict{Symbol, Any}

Barrier for type stability. Simply returns input_settings[:materials]

parse_materials(input_settings)

parse_mesh(
    input_settings::Dict{Symbol, Any},
    domain_key::Symbol
) -> Dict{Symbol, String}

Barrier for type stability. Simply returns input_settings[:mesh]

parse_mesh(input_settings, domain_key)

parse_nonlinear_solvers(
    input_settings::Dict{Symbol, Any}
) -> Dict{Symbol, Any}

Barrier for type stability. Simply returns input_settings[Symbol("nonlinear solvers")]

parse_nonlinear_solvers(input_settings)

parse_problems(
    input_settings::Dict{Symbol, Any},
    domain_settings::Dict{Symbol, Any},
    linear_solver_settings::Dict{Symbol, Any},
    nonlinear_solver_settings::Dict{Symbol, Any}
) -> Any

Helper to parse problems

parse_problems(
    input_settings,
    domain_settings,
    linear_solver_settings,
    nonlinear_solver_settings
)

parse_sections(
    input_settings::Dict{Symbol, Any},
    domain_key::Symbol
) -> Vector{Dict{Symbol, Any}}

Barrier for type stability. Returns input_settings[:sections] but replaces material names with material definitions

parse_sections(input_settings, domain_key)

parse_time_stepper(
    input_settings::Dict{Symbol, Any},
    domain_key::Symbol
) -> Dict{Symbol, Any}

Barrier for type stability. Simple returns input_settings[Symbol("time stepper")]

parse_time_stepper(input_settings, domain_key)

update_unknown_dofs!(d::Cthonios.QuasiStaticDomain) -> Any

This methods assumes the bc dofs and func ids are already properly set in the domain coming in

update_unknown_dofs!(d)

with_logger(f, common::Cthonios.CthoniosCommon) -> Any

with_logger(f, common)

with_logger(f, logger::Cthonios.CthoniosLogger) -> Any

with_logger(f, logger)