• Block
• EdgeMap
• ElementMap
• ElementVariable
• ExodusDatabase
• FaceMap
• GlobalVariable
• Initialization
• NodalVariable
• NodeMap
• NodeSet
• NodeSetVariable
• SideSet
• SideSetVariable
• close
• collect_element_connectivities
• collect_element_to_element_connectivities
• collect_node_to_element_connectivities
• copy
• copy_mesh
• decomp
• epu
• exodiff
• length
• read_block
• read_block_id_map
• read_blocks
• read_coordinates
• read_element_type
• read_id_map
• read_ids
• read_info
• read_map
• read_name
• read_names
• read_number_of_time_steps
• read_number_of_variables
• read_qa
• read_set
• read_sets
• read_side_set_node_list
• read_time
• read_times
• read_values
• write_block
• write_blocks
• write_coordinates
• write_id_map
• write_info
• write_name
• write_names
• write_number_of_variables
• write_qa
• write_set
• write_sets
• write_time
• write_values

• id::Any

• num_elem::Int64

• num_nodes_per_elem::Int64

• elem_type::String

• conn::AbstractMatrix

Init method for block container.

• node_cmap_ids::Vector

• node_cmap_node_cnts::Vector

• elem_cmap_ids::Vector

• elem_cmap_elem_cnts::Vector

• cmd::Cmd

• elem_ids::Vector

• side_ids::Vector

• proc_ids::Vector

• cmd::Cmd

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

• error_code::Int32

• error_msg::String

• 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

• mode::String

• cmd::Cmd

• cmd::Cmd

• node_ids::Vector

• proc_ids::Vector

• id::Any

• nodes::AbstractVector

• elem_map_internal::Vector

• elem_map_border::Vector

• node_map_internal::Vector

• node_map_border::Vector

• node_map_external::Vector

• exo::ExodusDatabase

• type::Type

• id::Integer

• exo::ExodusDatabase

• type::Type

• name::String

• id::Any

• elements::AbstractVector

• sides::AbstractVector

• exo::ExodusDatabase

• type::Type

• id::Int64

• 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

close(exo::ExodusDatabase)

Used to close and ExodusDatabase.

close(exo)

copy(
    exo::ExodusDatabase,
    new_file_name::String;
    mesh_only_flag
)

Used to copy an ExodusDatabase. As of right now this is the best way to create a new ExodusDatabase for output. Not all of the put methods have been wrapped and properly tested. This one has though.

copy(exo, new_file_name; mesh_only_flag)

length(n::NodeSet) -> Any

length(n)

length(s::SideSet) -> Any

length(s)

show(io::IO, cmap_params::Exodus.CommunicationMapParameters)

show(io, cmap_params)

show(io::IO, e::Exodus.EPUException)

show(io, e)

show(io::IO, e::Exodus.ExodiffException)

show(io, e)

show(io::IO, e::Exodus.ExodusError)

show(io, e)

show(io::IO, init::Exodus.LoadBalanceParameters)

show(io, init)

show(io::IO, e::Exodus.NemSliceException)

show(io, e)

show(io::IO, e::Exodus.NemSpreadException)

show(io, e)

show(io::IO, e::Exodus.SetIDException)

show(io, e)

show(io::IO, e::Exodus.SetNameException)

show(io, e)

show(io::IO, e::Exodus.VariableIDException)

show(io, e)

show(io::IO, e::Exodus.VariableNameException)

show(io, e)

show(io::IO, node_set::NodeSet)

show(io, node_set)

show(io::IO, sset::SideSet)

show(io, sset)

show(io::IO, block::Block)

show(io, block)

show(io::IO, init::Initialization)

show(io, init)

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

InitializationGlobal(exo)

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

collects all blocks by default

collect_element_connectivities(exo)

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

collect all blocks by default

collect_element_to_element_connectivities(exo)

collect_global_to_color(
    file_name::String,
    n_procs::Int64
) -> Vector{Int64}
collect_global_to_color(
    file_name::String,
    n_procs::Int64,
    n_dofs::Int64
) -> Vector{Int64}

For collecting globaltocolor

collect_global_to_color(file_name, n_procs)
collect_global_to_color(file_name, n_procs, n_dofs)

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

collect all blocks by default

collect_node_to_element_connectivities(exo)

copy_mesh(file_name::String, new_file_name::String)

Simpler copy method to only copy a mesh for output later on

copy_mesh(file_name, new_file_name)

decomp(file_name::String, n_procs::Integer)

decomp(file_name, n_procs)

epu(file_name::String)

epu(file_name)

epu() -> Any

Prints epu help message

epu()

epu_error(cmd::Cmd)

epu_error(cmd)

exodiff(ex_1::String, ex_2::String; command_file) -> Bool

Return true if the two files pass the exodiff test. Otherwise it returns false

exodiff(ex_1, ex_2; command_file)

exodiff() -> Any

Prints exodiff help message

exodiff()

exodiff_error(cmd::Cmd)

exodiff_error(cmd)

exodus_error_check(
    exo::Int32,
    error_code::Integer,
    method_name::String
)

Generic error handling method.

Arguments

• error_code::T: error code, usually negative means something went bad
• method_name::String: method name that called this

exodus_error_check(exo, error_code, method_name)

nem_slice() -> Any

nem_slice()

nem_slice(file_name::String, n_procs::Integer) -> Any

nem_slice(file_name, n_procs)

nem_slice_error(cmd::Cmd)

nem_slice_error(cmd)

nem_spread() -> Any

nem_spread()

nem_spread(file_name::String, n_procs::Integer) -> Any

nem_spread(file_name, n_procs)

nem_spread_error(cmd::Cmd)

nem_spread_error(cmd)

open_exodus_file(file_name::String, mode) -> Int32

Helper method for opening exodus database

open_exodus_file(file_name, mode)

read_block(
    exo::ExodusDatabase,
    block_id::Integer
) -> Block{_A, Matrix{_A1}} where {_A, _A1}

read_block(exo, block_id)

read_block(
    exo::ExodusDatabase,
    block_name::String
) -> Block{_A, Matrix{_A1}} where {_A, _A1}

read_block(exo, block_name)

read_block_connectivity(
    exo::ExodusDatabase{M, I, B, F},
    block_id::Integer,
    conn_length::Integer
) -> Vector

read_block_connectivity(exo, block_id, conn_length)

read_block_id_map(
    exo::ExodusDatabase,
    block_id::Integer
) -> Any

TODO do this one later... it depends on a few things

TODO fix this to not use void_int... use a proper type

read_block_id_map(exo, block_id)

read_block_parameters(
    exo::ExodusDatabase{M, I, B, F},
    block_id::Integer
) -> Tuple{String, Vararg{Any, 5}}

read_block_parameters(exo, block_id)

read_blocks!(
    blocks::Array{B<:Block, 1},
    exo::ExodusDatabase,
    block_ids::Array{I<:Integer, 1}
)

TODO: change name to readelementblocks!

read_blocks!(blocks, exo, block_ids)

read_blocks(
    exo::ExodusDatabase,
    block_ids::Union{Vector{<:Integer}, var"#s10317"} where var"#s10317"<:Integer
) -> Any

Helper method for initializing blocks.

TODO: change name to readelementblocks

read_blocks(exo, block_ids)

read_coordinate_names(exo::ExodusDatabase) -> Any

Method to read coordinates names Returns a vector of strings

read_coordinate_names(exo)

read_coordinates(exo::ExodusDatabase) -> Matrix

Method to read coordinates. Returns a matrix that is ndim x nnodes.

read_coordinates(exo)

read_element_type(
    exo::ExodusDatabase,
    block_id::Integer
) -> String

read_element_type(exo, block_id)

read_id_map(
    exo::ExodusDatabase{M, I, B, F},
    type::Type{MAP<:Exodus.AbstractExodusMap}
) -> Any

read_id_map(exo, type)

read_ids(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{S<:Exodus.AbstractExodusSet}
) -> Any

read_ids(exo, _)

read_info(exo::ExodusDatabase) -> Vector{String}

read_info(exo)

read_init_info(
    exo::ExodusDatabase
) -> Tuple{Int32, Int32, String}

read_init_info(exo)

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

TODO change to not use void_int

read_map(exo)

read_name(
    exo::ExodusDatabase,
    _::Type{S<:Exodus.AbstractExodusSet},
    id::Integer
) -> String

read_name(exo, _, id)

read_name(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable},
    var_index::Integer
) -> String

General method to read the name of a variable in index var_index for a given variable type V.

Examples: julia> readname(exo, ElementVariable, 1) "stressxx"

julia> readname(exo, GlobalVariable, 2) "reactionforce"

julia> readname(exo, NodalVariable, 1) "displx"

julia> readname(exo, NodeSetVariable, 1) "nsetdispl_x"

julia> read_name(exo, SideSetVariable, 1) "pressure"

read_name(exo, _, var_index)

read_names(
    exo::ExodusDatabase,
    _::Type{S<:Exodus.AbstractExodusSet}
) -> Any

read_names(exo, _)

read_names(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable}
) -> Vector{String}

General method to read the names of variables for a given variable type V.

Examples: julia> readnames(exo, ElementVariable) "stressxx" "stressyy" "stresszz" "stressxy" "stressyz" "stress_zx"

julia> readnames(exo, GlobalVariable) "globaldispl" "reaction_force"

julia> readnames(exo, NodalVariable) "displx" "disply" "displz"

julia> readname(exo, NodeSetVariable) "nsetdisplx" "nsetdisply" "nsetdispl_z"

julia> read_name(exo, SideSetVariable) "pressure"

read_names(exo, _)

read_node_set_nodes(
    exo::ExodusDatabase{M, I, B, F},
    set_id::Integer
) -> Any

read_node_set_nodes(exo, set_id)

read_number_of_time_steps(exo::ExodusDatabase) -> UInt32

read_number_of_time_steps(exo)

read_number_of_variables(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable}
) -> Int32

General method to read the number of variables for a given variable type V.

Examples: julia> readnumberof_variables(exo, ElementVariable) 6

julia> readnumberof_variables(exo, GlobalVariable) 5

julia> readnumberof_variables(exo, NodalVariable) 3

julia> readnumberof_variables(exo, NodeSetVariable) 3

julia> readnumberof_variables(exo, SideSetVariable) 6

read_number_of_variables(exo, _)

read_partial_block_connectivity(
    exo::ExodusDatabase,
    block_id::Integer,
    start_num::Integer,
    num_ent::Integer
) -> Any

read_partial_block_connectivity(
    exo,
    block_id,
    start_num,
    num_ent
)

read_partial_coordinates(
    exo::ExodusDatabase,
    start_node_num::Integer,
    n_nodes::Integer
) -> Matrix

Method to read a partial set of coordinates that are contiguous. Returns a matrix that is ndim x nnodes

read_partial_coordinates(exo, start_node_num, n_nodes)

read_partial_coordinates_component(
    exo::ExodusDatabase,
    start_node_num::Integer,
    n_nodes::Integer,
    component::Integer
) -> Vector

Method to read a specific component of a partial set of coordinates that are contiguous. Returns a vector of length n_nodes TODO change to not use Cvoid

read_partial_coordinates_component(
    exo,
    start_node_num,
    n_nodes,
    component
)

read_qa(exo::ExodusDatabase) -> Matrix{String}

read_qa(exo)

read_set(
    exo::ExodusDatabase,
    type::Type{S<:Exodus.AbstractExodusSet},
    set_id
) -> Any

read_set(exo, type, set_id)

read_set_parameters(
    exo::ExodusDatabase{M, I, B, F},
    set_id::Integer,
    _::Type{S<:Union{NodeSet, SideSet}}
) -> Tuple{Any, Any}

read_set_parameters(exo, set_id, _)

read_sets!(
    sets::Array{T<:Exodus.AbstractExodusSet, 1},
    exo::ExodusDatabase,
    ids::Array{I, 1}
)

read_sets!(sets, exo, ids)

read_sets(
    exo::ExodusDatabase{M, I, B, F},
    type::Type{S<:Exodus.AbstractExodusSet}
) -> Any

read_sets(exo, type)

read_side_set_elements_and_sides(
    exo::ExodusDatabase{M, I, B, F},
    set_id::Integer
) -> Tuple{Any, Any}

read_side_set_elements_and_sides(exo, set_id)

read_side_set_node_list(
    exo::ExodusDatabase{M, I, B, F},
    side_set_id::Integer
) -> Tuple{Any, Vector}

UNTESTED

read_side_set_node_list(exo, side_set_id)

read_time(exo::ExodusDatabase, time_step::Integer) -> Any

TODO figure out how to make this not use a vector of length 1 - either a ref or a ptr

read_time(exo, time_step)

read_times(exo::ExodusDatabase) -> Vector

read_times(exo)

read_values(
    exo::ExodusDatabase,
    t::Type{GlobalVariable},
    timestep::Integer
) -> Vector

Wrapper method for global variables around the main readvalues method readvalues(exo::ExodusDatabase, t::Type{GlobalVariable}, timestep::Integer) = read_values(exo, t, timestep, 1, 1)

Example: read_values(exo, GlobalVariable, 1)

read_values(exo, t, timestep)

read_values(
    exo::ExodusDatabase,
    t::Type{NodalVariable},
    timestep::Integer,
    index::Integer
) -> Any

Wrapper method for nodal variables

read_values(exo, t, timestep, index)

read_values(
    exo::ExodusDatabase,
    t::Type{NodalVariable},
    timestep::Integer,
    name::String
) -> Any

Wrapper method for nodal variables

read_values(exo, t, timestep, name)

read_values(
    exo::ExodusDatabase,
    _::Type{V<:Union{ElementVariable, NodalVariable, NodeSetVariable, SideSetVariable}},
    time_step::Integer,
    id::Integer,
    var_name::String
) -> Any

read_values(exo, _, time_step, id, var_name)

read_values(
    exo::ExodusDatabase,
    _::Type{V<:Union{ElementVariable, NodeSetVariable, SideSetVariable}},
    time_step::Integer,
    set_name::String,
    var_name::String
) -> Any

read_values(exo, _, time_step, set_name, var_name)

read_values(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{V<:ElementVariable},
    timestep::Integer,
    id::Integer,
    var_index::Integer
) -> Any

Method to read element variables

read_values(exo, _, timestep, id, var_index)

read_values(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{V<:GlobalVariable},
    timestep::Integer,
    id::Integer,
    var_index::Integer
) -> Vector

Method to read global variables

read_values(exo, _, timestep, id, var_index)

read_values(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{V<:NodalVariable},
    timestep::Integer,
    id::Integer,
    var_index::Integer
) -> Any

Method to read nodal variables

read_values(exo, _, timestep, id, var_index)

read_values(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{V<:Union{NodeSetVariable, SideSetVariable}},
    timestep::Integer,
    id::Integer,
    var_index::Integer
) -> Any

Method to read nodeset/sideset variables

read_values(exo, _, timestep, id, var_index)

set_exodus_max_name_length(exoid::Int32, len::Int32)

set_exodus_max_name_length(exoid, len)

set_exodus_options(options)

set_exodus_options(options)

write_block(exo::ExodusDatabase, block::Block)

WARNING: currently does not support edges, faces and attributes

write_block(exo, block)

write_block_connectivity(
    exo::ExodusDatabase,
    block_id::Integer,
    conn::Array{I<:Integer, 2}
)

write_block_connectivity(exo, block_id, conn)

write_blocks(exo::ExodusDatabase, blocks::Vector{<:Block})

write_blocks(exo, blocks)

write_coordinate_names(
    exo::ExodusDatabase,
    coord_names::Vector{String}
)

Method to write coordinate names, e.g. x, y, z

write_coordinate_names(exo, coord_names)

write_coordinates(
    exo::ExodusDatabase,
    coords::Union{Array{F<:AbstractFloat, 1}, Array{F<:AbstractFloat, 2}}
)

Method to write coordinates

write_coordinates(exo, coords)

write_id_map(
    exo::ExodusDatabase{M, I, B, F},
    type::Type{MAP<:Exodus.AbstractExodusMap},
    map::Array{M, 1}
)

write_id_map(exo, type, map)

write_info(exo::ExodusDatabase, info::Vector{String})

write_info(exo, info)

write_initialization!(exoid::Int32, init::Initialization)

Used to set up a exodus database in write mode

The ccall signatures should reall be B (bulk int type of exo) instead of Clonglong

write_initialization!(exoid, init)

write_name(
    exo::ExodusDatabase{M, I, B, F},
    set::Exodus.AbstractExodusSet,
    name::String
)

write_name(exo, set, name)

write_name(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{S<:Exodus.AbstractExodusSet},
    set_id::Integer,
    name::String
)

write_name(exo, _, set_id, name)

write_name(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable},
    var_index::Integer,
    var_name::String
)

write_name(exo, _, var_index, var_name)

write_names(
    exo::ExodusDatabase,
    _::Type{S<:Exodus.AbstractExodusSet},
    names::Vector{String}
)

WARNING: this methods likely does not have good safe guards

write_names(exo, _, names)

write_names(
    exo::ExodusDatabase,
    type::Type{V<:Exodus.AbstractExodusVariable},
    var_names::Vector{String}
)

write_names(exo, type, var_names)

write_number_of_variables(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable},
    num_vars::Integer
)

General method to write the number of variables for a given variable type V.

Examples: julia> writenumberof_variables(exo, ElementVariable, 6)

julia> writenumberof_variables(exo, GlobalVariable, 5)

julia> writenumberof_variables(exo, NodalVariable, 3)

julia> writenumberof_variables(exo, NodeSetVariable, 3)

julia> writenumberof_variables(exo, SideSetVariable, 6)

write_number_of_variables(exo, _, num_vars)

write_partial_coordinates(
    exo::ExodusDatabase,
    start_node_num::Integer,
    coords::Union{Array{F<:AbstractFloat, 1}, Array{F<:AbstractFloat, 2}}
)

write_partial_coordinates(exo, start_node_num, coords)

write_partial_coordinates_component(
    exo::ExodusDatabase,
    start_node_num::Integer,
    component::Integer,
    coords::Array{F<:AbstractFloat, 1}
)

write_partial_coordinates_component(
    exo,
    start_node_num,
    component,
    coords
)

write_partial_coordinates_component(
    exo::ExodusDatabase,
    start_node_num::Integer,
    component::String,
    coords::Array{F<:AbstractFloat, 1}
)

write_partial_coordinates_component(
    exo,
    start_node_num,
    component,
    coords
)

write_qa(exo::ExodusDatabase, qa_record::Matrix{String})

write_qa(exo, qa_record)

write_set(
    exo::ExodusDatabase{M, I, B, F},
    set::Exodus.AbstractExodusSet
)

Typing ensures we don't write a set with non-matching types to the exodus file.

write_set(exo, set)

write_set_parameters(
    exo::ExodusDatabase{M, I, B, F},
    set::Exodus.AbstractExodusSet
)

WARNING: currently doesn't support distance factors

write_set_parameters(exo, set)

write_sets(
    exo::ExodusDatabase,
    sets::Array{T<:Exodus.AbstractExodusSet, 1}
)

write_sets(exo, sets)

write_time(
    exo::ExodusDatabase,
    time_step::Integer,
    time_value::AbstractFloat
)

write_time(exo, time_step, time_value)

write_values(
    exo::ExodusDatabase,
    t::Type{GlobalVariable},
    timestep::Integer,
    var_values::Vector{<:AbstractFloat}
)

Wrapper method for global variables around the main writevalues method writevalues( exo::ExodusDatabase, t::Type{GlobalVariable}, timestep::Integer, varvalues::Vector{<:AbstractFloat} ) = writevalues(exo, t, timestep, 1, 1, var_values)

Note: you need to first run writenumberof_variables(exo, GlobalVariable, n) where n is the number of variables.

Example: writenumberofvariables(exo, GlobalVariable, 5) writevalues(exo, GlobalVariable, 1, [10.0, 20.0, 30.0, 40.0, 50.0])

write_values(exo, t, timestep, var_values)

write_values(
    exo::ExodusDatabase,
    t::Type{NodalVariable},
    timestep::Integer,
    var_index::Integer,
    var_values::Vector{<:AbstractFloat}
)

Wrapper for writing nodal variables by index number

write_values(exo, t, timestep, var_index, var_values)

write_values(
    exo::ExodusDatabase,
    t::Type{NodalVariable},
    timestep::Integer,
    var_name::String,
    var_values::Vector{<:AbstractFloat}
)

Wrapper method for nodal variables

write_values(exo, t, timestep, var_name, var_values)

write_values(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable},
    timestep::Integer,
    id::Integer,
    var_index::Integer,
    var_values::Vector{<:AbstractFloat}
)

write_values(exo, _, timestep, id, var_index, var_values)

write_values(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable},
    timestep::Integer,
    id::Integer,
    var_name::String,
    var_value::Vector{<:AbstractFloat}
)

write_values(exo, _, timestep, id, var_name, var_value)

write_values(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable},
    time_step::Integer,
    set_name::String,
    var_name::String,
    var_value::Vector{<:AbstractFloat}
)

write_values(
    exo,
    _,
    time_step,
    set_name,
    var_name,
    var_value
)