close(exo::ExodusDatabase)

Used to close and ExodusDatabase.

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.

length(n::NodeSet) -> Any

length(s::SideSet) -> Any

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

collects all blocks by default

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

collect all blocks by default

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

collect all blocks by default

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

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

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

epu(file_name::String) -> Base.Process

epu() -> Base.Process

Prints epu help message

exodiff(
    ex_1::String,
    ex_2::String,
    cli_args::Vector{String}
) -> Bool

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() -> Base.Process

Prints exodiff help message

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

read_block(exo::ExodusDatabase, block_name::String) -> Block

read_block_id_map(
    exo::ExodusDatabase{M, I, B, F},
    block_id
) -> 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_blocks(
    exo::ExodusDatabase,
    block_ids::Union{Vector{<:Integer}, var"#s122"} where var"#s122"<:Integer
) -> Any

Helper method for initializing blocks.

TODO: change name to readelementblocks

read_coordinates(exo::ExodusDatabase) -> Matrix

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

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

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

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

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

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

TODO change to not use void_int

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

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_names(
    exo::ExodusDatabase,
    _::Type{S<:Exodus.AbstractExodusSet}
) -> Any

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_number_of_time_steps(exo::ExodusDatabase) -> UInt32

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_qa(exo::ExodusDatabase) -> Matrix{String}

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

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

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

UNTESTED

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_times(exo::ExodusDatabase) -> Vector

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::ExodusDatabase,
    t::Type{NodalVariable},
    timestep::Integer,
    index::Integer
) -> Any

Wrapper method for nodal variables

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

Wrapper method for nodal variables

read_values(
    exo::ExodusDatabase,
    _::Type{NodalVectorVariable},
    timestep::Integer,
    base_name::String
) -> Any

Wrapper method for nodal vector variables

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

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

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

Method to read element variables

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

Method to read global variables

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

Method to read nodal variables

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

Method to read nodeset/sideset variables

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

WARNING: currently does not support edges, faces and attributes

write_block(
    exo::ExodusDatabase,
    block_id::Integer,
    elem_type::String,
    conn::Array{I<:Integer, 2}
)

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

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

Method to write coordinates

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

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

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

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

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

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

WARNING: this methods likely does not have good safe guards

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

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_qa(exo::ExodusDatabase, qa_record::Matrix{String})

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_sets(
    exo::ExodusDatabase,
    sets::Array{T<:Exodus.AbstractExodusSet, 1}
)

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

write_values(
    exo::ExodusDatabase{M, I, B, F},
    t::Type{GlobalVariable},
    timestep::Integer,
    var_values::Array{F, 1}
)

Wrapper method for global variables around the main writevalues method writevalues( exo::ExodusDatabase, t::Type{GlobalVariable}, timestep::Integer, varvalues::Vector{F} ) = 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::ExodusDatabase{M, I, B, F},
    t::Type{NodalVariable},
    timestep::Integer,
    var_index::Integer,
    var_values::Array{F, 1}
)

Wrapper for writing nodal variables by index number

write_values(
    exo::ExodusDatabase{M, I, B, F},
    t::Type{NodalVariable},
    timestep::Integer,
    var_name::String,
    var_values::Array{F, 1}
)

Wrapper method for nodal variables

write_values(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{V<:Exodus.AbstractExodusVariable},
    timestep::Integer,
    id::Integer,
    var_index::Integer,
    var_values::Array{F, 1}
)

write_values(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{V<:Exodus.AbstractExodusVariable},
    timestep::Integer,
    id::Integer,
    var_name::String,
    var_value::Array{F, 1}
)

write_values(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{V<:Exodus.AbstractExodusVariable},
    time_step::Integer,
    set_name::String,
    var_name::String,
    var_value::Array{F, 1}
)

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

bulk_int_mode(exo::Int32) -> Union{Type{Int32}, Type{Int64}}

collect_element_connectivities!(
    conns::Array{Array{B, 1}, 1},
    blocks::Array{Block{I, Array{B, 2}}, 1}
)

collect_element_to_element_connectivities!(
    elem_to_elem::Array{Array{B, 1}, 1},
    node_to_elem::Array{Array{B, 1}, 1},
    conns::Array{Array{B, 1}, 1}
)

collect_node_to_element_connectivities!(
    node_to_elem::Array{Array{B, 1}, 1},
    conns::Array{Array{B, 1}, 1}
)

copy_transient(file_name::String, new_file_name::String)

entries(s::SideSet) -> AbstractVector

epu_error(cmd::Cmd)

exodiff_error(cmd::Cmd)

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

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_type_check(sym, context, type1, type2)

extras(s::SideSet) -> AbstractVector

float_mode(
    exo::Int32
) -> Union{Type{Float32}, Type{Float64}}

get_bulk_int_type(_::ExodusDatabase{M, I, B, F}) -> Any

get_file_id(exo::ExodusDatabase) -> Int32

get_float_type(_::ExodusDatabase{M, I, B, F}) -> Any

get_id_int_type(_::ExodusDatabase{M, I, B, F}) -> Any

get_init(exo::ExodusDatabase) -> Initialization

get_map_int_type(_::ExodusDatabase{M, I, B, F}) -> Any

get_mode(exo::ExodusDatabase) -> String

id_error(exo, _::Type{t<:Exodus.AbstractExodusSet}, id)

id_error(exo, _::Type{t<:Exodus.AbstractExodusVariable}, id)

id_int_mode(exo::Int32) -> Union{Type{Int32}, Type{Int64}}

initialization(exo::ExodusDatabase) -> Initialization

map_int_mode(exo::Int32) -> Union{Type{Int32}, Type{Int64}}

mode_error(mode::String)

name_error(exo, _::Type{t<:Exodus.AbstractExodusSet}, name)

name_error(
    exo,
    _::Type{t<:Exodus.AbstractExodusVariable},
    name
)

nem_slice(
    file_name::String,
    n_procs::Integer;
    use_nodal
) -> Base.Process

nem_slice_error(cmd::Cmd)

nem_spread(
    file_name::String,
    n_procs::Integer
) -> Base.Process

nem_spread_error(cmd::Cmd)

num_dimensions(init::Initialization) -> Any

num_element_blocks(init::Initialization) -> Any

num_elements(init::Initialization) -> Any

num_node_sets(init::Initialization) -> Any

num_nodes(init::Initialization) -> Any

num_side_sets(init::Initialization) -> Any

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

Helper method for opening exodus database

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

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

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

TODO: change name to readelementblocks!

read_coordinate_names(exo::ExodusDatabase) -> Any

Method to read coordinates names Returns a vector of strings

read_ghost_nodes_and_procs(rank, exo) -> Tuple{Any, Any}

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

read_internal_nodes_and_procs(rank, exo) -> Tuple{Any, Any}

read_node_cmaps(rank, exo) -> Any

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

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

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_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::ExodusDatabase,
    start_node_num::Integer,
    n_nodes::Integer,
    component::String
) -> Vector

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

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

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

read_values!(
    values::Array{F, 1},
    exo::ExodusDatabase{M, I, B, F},
    _::Type{V<:Exodus.AbstractExodusVariable},
    timestep::Integer,
    id::Integer,
    var_index::Integer
) -> Vector

Method to read element variables with pre-allocated array

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

set_name_dict(
    exo::ExodusDatabase,
    _::Type{Block}
) -> Dict{String}

set_name_dict(
    exo::ExodusDatabase,
    _::Type{NodeSet}
) -> Dict{String}

set_name_dict(
    exo::ExodusDatabase,
    _::Type{SideSet}
) -> Dict{String}

var_name_dict(
    exo::ExodusDatabase,
    _::Type{ElementVariable}
) -> Dict{String}

var_name_dict(
    exo::ExodusDatabase,
    _::Type{GlobalVariable}
) -> Dict{String}

var_name_dict(
    exo::ExodusDatabase,
    _::Type{NodalVariable}
) -> Dict{String}

var_name_dict(
    exo::ExodusDatabase,
    _::Type{NodeSetVariable}
) -> Dict{String}

var_name_dict(
    exo::ExodusDatabase,
    _::Type{SideSetVariable}
) -> Dict{String}

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

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

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

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_partial_coordinates(
    exo::ExodusDatabase,
    start_node_num::Integer,
    coords::Union{Array{F<:AbstractFloat, 1}, Array{F<:AbstractFloat, 2}}
)

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

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

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

WARNING: currently doesn't support distance factors