struct Block{I, A<:(AbstractMatrix)} <: Exodus.AbstractExodusSet{I, A<:(AbstractMatrix)}

• id::Any

• num_elem::Int64

• num_nodes_per_elem::Int64

• elem_type::String

• conn::AbstractMatrix

Block(exo::ExodusDatabase, block_id::Integer) -> Block

Init method for block container.

Block(exo::ExodusDatabase, name::String) -> Block

struct EdgeMap <: Exodus.AbstractExodusMap

struct ElementMap <: Exodus.AbstractExodusMap

struct ElementVariable <: Exodus.AbstractExodusVariable

struct ExodusDatabase{M, I, B, F}

• exo::Int32

• mode::String

• file_name::String

• init::Initialization

• block_name_dict::Dict{String}

• nset_name_dict::Dict{String}

• sset_name_dict::Dict{String}

• element_var_name_dict::Dict{String}

• global_var_name_dict::Dict{String}

• nodal_var_name_dict::Dict{String}

• nset_var_name_dict::Dict{String}

• sset_var_name_dict::Dict{String}

ExodusDatabase(
    file_name::String,
    mode::String
) -> ExodusDatabase

Type unstable helper to eliminate annoying lines of code to get type stability.

If you're looking for a type stable way to to open an exodus file, Simple copy past some of this into a barrier function

ExodusDatabase(
    file_name::String,
    mode::String
) -> ExodusDatabase

ExodusDatabase(
    file_name::String,
    mode::String
) -> ExodusDatabase

struct FaceMap <: Exodus.AbstractExodusMap

struct GlobalVariable <: Exodus.AbstractExodusVariable

struct Initialization{B}

Type that holds initialization information.

Initialization(exo::Int32, _::Type{B}) -> Initialization

Initialization(
    exo::ExodusDatabase{M, I, B, F}
) -> Initialization

Initialization(_::Type{B<:Integer}) -> Initialization

Initialization(_)

struct NodalVariable <: Exodus.AbstractExodusVariable

struct NodalVectorVariable <: Exodus.AbstractExodusVariable

struct NodeMap <: Exodus.AbstractExodusMap

struct NodeSet{I, A<:(AbstractVector)} <: Exodus.AbstractExodusSet{I, A<:(AbstractVector)}

• id::Any

• nodes::AbstractVector

NodeSet(exo::ExodusDatabase, name::String) -> NodeSet

NodeSet(
    exo::ExodusDatabase{M, I, B, F},
    id::Integer
) -> NodeSet

struct NodeSetVariable <: Exodus.AbstractExodusVariable

struct SideSet{I, A<:(AbstractVector)} <: Exodus.AbstractExodusSet{I, A<:(AbstractVector)}

• id::Any

• elements::AbstractVector

• sides::AbstractVector

• num_nodes_per_side::AbstractVector

• side_nodes::AbstractVector

SideSet(exo::ExodusDatabase, name::String) -> SideSet

SideSet(
    exo::ExodusDatabase{M, I, B, F},
    id::Integer
) -> SideSet

struct SideSetVariable <: Exodus.AbstractExodusVariable

abstract type AbstractExodusMap <: Exodus.AbstractExodusType

abstract type AbstractExodusSet{I, A} <: Exodus.AbstractExodusType

abstract type AbstractExodusType

abstract type AbstractExodusVariable <: Exodus.AbstractExodusType

struct CommunicationMapParameters{B}

• node_cmap_ids::Vector

• node_cmap_node_cnts::Vector

• elem_cmap_ids::Vector

• elem_cmap_elem_cnts::Vector

CommunicationMapParameters(
    exo::ExodusDatabase{M, I, B, F},
    lb_params::Exodus.LoadBalanceParameters{B},
    processor::Integer
) -> Exodus.CommunicationMapParameters

struct EPUException <: Exception

• cmd::Cmd

struct ElementCommunicationMap{B}

• elem_ids::Vector

• side_ids::Vector

• proc_ids::Vector

ElementCommunicationMap(
    exo::ExodusDatabase{M, I, B, F},
    elem_map_id::Integer,
    elem_cnt,
    processor::Integer
) -> Exodus.ElementCommunicationMap

struct ExodiffException <: Exception

• cmd::Cmd

struct ExodusError <: Exception

• error_code::Int32

• error_msg::String

struct ExodusWindowsError <: Exception

struct LoadBalanceParameters{B}

• num_int_nodes::Any

• num_bor_nodes::Any

• num_ext_nodes::Any

• num_int_elems::Any

• num_bor_elems::Any

• num_node_cmaps::Any

• num_elem_cmaps::Any

• processor::Int32

LoadBalanceParameters(
    exo::ExodusDatabase{M, I, B, F},
    processor::Integer
) -> Exodus.LoadBalanceParameters

struct ModeException <: Exception

• mode::String

struct NemSliceException <: Exception

• cmd::Cmd

struct NemSpreadException <: Exception

• cmd::Cmd

struct NodalVariable <: Exodus.AbstractExodusVariable

struct NodeCommunicationMap{B}

• node_ids::Vector

• proc_ids::Vector

NodeCommunicationMap(
    exo::ExodusDatabase{M, I, B, F},
    node_map_id,
    node_cnt,
    processor
) -> Exodus.NodeCommunicationMap

struct ProcessorElementMaps{B}

• elem_map_internal::Vector

• elem_map_border::Vector

ProcessorElementMaps(
    exo::ExodusDatabase{M, I, B, F},
    processor
) -> Exodus.ProcessorElementMaps

struct ProcessorNodeMaps{B}

• node_map_internal::Vector

• node_map_border::Vector

• node_map_external::Vector

ProcessorNodeMaps(
    exo::ExodusDatabase{M, I, B, F},
    processor
) -> Exodus.ProcessorNodeMaps

struct SetIDException{M, I, B, F, V, I1<:Integer} <: Exception

• exo::ExodusDatabase

• type::Type

• id::Integer

struct SetNameException{M, I, B, F, V} <: Exception

• exo::ExodusDatabase

• type::Type

• name::String

struct VariableIDException{M, I, B, F, V} <: Exception

• exo::ExodusDatabase

• type::Type

• id::Int64

struct VariableNameException{M, I, B, F, V} <: Exception

• exo::ExodusDatabase

• type::Type

• name::String

ex_entity_type

Entity type enums (exentitytype in exodusII.h)

ex_inquiry

Inquiry enums (ex_inquiry in exodusII.h).

void_int = Cvoid