Exodus.ExodusModule
Exodus.BlockType
  • id::Any

  • num_elem::Int64

  • num_nodes_per_elem::Int64

  • elem_type::String

  • conn::AbstractMatrix

Exodus.ExodusDatabaseMethod

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

Exodus.LoadBalanceParametersType
  • 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

Exodus.ParallelExodusDatabaseType
  • base_file_name::String

  • exos::Array{ExodusDatabase{M, I, B, F}, 1} where {M, I, B, F}

  • nem::ExodusDatabase{M, I, B, Float32} where {M, I, B}

  • mode::String

  • init_global::Initialization

  • lb_params::Array{Exodus.LoadBalanceParameters{B}, 1} where B

  • cmap_params::Array{Exodus.CommunicationMapParameters{B}, 1} where B

Exodus.SideSetType
  • id::Any

  • elements::AbstractVector

  • sides::AbstractVector

Base.closeMethod
close(p::Exodus.ParallelExodusDatabase)
close(p)
Base.closeMethod
close(exo::ExodusDatabase)

Used to close and ExodusDatabase.

close(exo)
Base.copyMethod
copy(exo::ExodusDatabase, new_file_name::String)

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)
Base.lengthMethod
length(n::NodeSet) -> Any
length(n)
Base.lengthMethod
length(s::SideSet) -> Any
length(s)
Base.showMethod
show(io::IO, cmap_params::Exodus.CommunicationMapParameters)
show(io, cmap_params)
Base.showMethod
show(io::IO, e::Exodus.EPUException)
show(io, e)
Base.showMethod
show(io::IO, e::Exodus.ExodiffException)
show(io, e)
Base.showMethod
show(io::IO, e::Exodus.ExodusError)
show(io, e)
Base.showMethod
show(io::IO, init::Exodus.LoadBalanceParameters)
show(io, init)
Base.showMethod
show(io::IO, e::Exodus.NemSliceException)
show(io, e)
Base.showMethod
show(io::IO, e::Exodus.NemSpreadException)
show(io, e)
Base.showMethod
show(io::IO, e::Exodus.SetIDException)
show(io, e)
Base.showMethod
show(io::IO, e::Exodus.SetNameException)
show(io, e)
Base.showMethod
show(io::IO, e::Exodus.VariableIDException)
show(io, e)
Base.showMethod
show(io::IO, e::Exodus.VariableNameException)
show(io, e)
Base.showMethod
show(io::IO, node_set::NodeSet)
show(io, node_set)
Base.showMethod
show(io::IO, sset::SideSet)
show(io, sset)
Base.showMethod
show(io::IO, block::Block)
show(io, block)
Base.showMethod
show(io::IO, init::Initialization)
show(io, init)
Base.showMethod
show(
    io::IO,
    exo::Exodus.ParallelExodusDatabase{M, I, B, F, N}
)
show(io, exo)
Exodus.InitializationGlobalMethod
InitializationGlobal(
    exo::ExodusDatabase{M, I, B, F}
) -> Initialization
InitializationGlobal(exo)
Exodus.collect_element_connectivitiesMethod
collect_element_connectivities(
    exo::ExodusDatabase{M, I, B, F}
) -> Any

collects all blocks by default

collect_element_connectivities(exo)
Exodus.copy_meshMethod
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)
Exodus.decompMethod
decomp(file_name::String, n_procs::Integer)
decomp(file_name, n_procs)
Exodus.epuMethod
epu(file_name::String)
epu(file_name)
Exodus.epuMethod
epu() -> Any

Prints epu help message

epu()
Exodus.exodiffMethod
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)
Exodus.exodiffMethod
exodiff() -> Any

Prints exodiff help message

exodiff()
Exodus.exodus_error_checkMethod
exodus_error_check(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(error_code, method_name)
Exodus.nem_sliceMethod
nem_slice(file_name::String, n_procs::Integer) -> Any
nem_slice(file_name, n_procs)
Exodus.nem_spreadMethod
nem_spread(file_name::String, n_procs::Integer) -> Any
nem_spread(file_name, n_procs)
Exodus.open_exodus_fileMethod
open_exodus_file(file_name::String, mode) -> Int32

Helper method for opening exodus database

open_exodus_file(file_name, mode)
Exodus.read_blockMethod
read_block(exo::ExodusDatabase, block_id::Integer) -> Block
read_block(exo, block_id)
Exodus.read_blockMethod
read_block(exo::ExodusDatabase, block_name::String) -> Block
read_block(exo, block_name)
Exodus.read_block_connectivityMethod
read_block_connectivity(
    exo::ExodusDatabase{M, I, B, F},
    block_id::Integer,
    conn_length::Integer
) -> Vector
read_block_connectivity(exo, block_id, conn_length)
Exodus.read_block_id_mapMethod
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)
Exodus.read_block_parametersMethod
read_block_parameters(
    exo::ExodusDatabase{M, I, B, F},
    block_id::Integer
) -> Tuple{String, Vararg{Any, 5}}
read_block_parameters(exo, block_id)
Exodus.read_blocks!Method
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)
Exodus.read_blocksMethod
read_blocks(
    exo::ExodusDatabase,
    block_ids::Union{Vector{<:Integer}, var"#s9354"} where var"#s9354"<:Integer
) -> Any

Helper method for initializing blocks.

TODO: change name to readelementblocks

read_blocks(exo, block_ids)
Exodus.read_coordinate_namesMethod
read_coordinate_names(exo::ExodusDatabase) -> Any

Method to read coordinates names Returns a vector of strings

read_coordinate_names(exo)
Exodus.read_coordinatesMethod
read_coordinates(exo::Exodus.ParallelExodusDatabase) -> Any
read_coordinates(exo)
Exodus.read_coordinatesMethod
read_coordinates(exo::ExodusDatabase) -> Matrix

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

read_coordinates(exo)
Exodus.read_element_typeMethod
read_element_type(
    exo::ExodusDatabase,
    block_id::Integer
) -> String
read_element_type(exo, block_id)
Exodus.read_id_mapMethod
read_id_map(
    exo::ExodusDatabase{M, I, B, F},
    type::Type{MAP<:Exodus.AbstractExodusMap}
) -> Any
read_id_map(exo, type)
Exodus.read_idsMethod
read_ids(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{S<:Exodus.AbstractExodusSet}
) -> Any
read_ids(exo, _)
Exodus.read_idsMethod
read_ids(
    exo::Exodus.ParallelExodusDatabase,
    type::Type{T<:Exodus.AbstractExodusSet}
) -> Any
read_ids(exo, type)
Exodus.read_infoMethod
read_info(exo::ExodusDatabase) -> Vector{String}
read_info(exo)
Exodus.read_init_infoMethod
read_init_info(
    exo::ExodusDatabase
) -> Tuple{Int32, Int32, String}
read_init_info(exo)
Exodus.read_mapMethod
read_map(exo::ExodusDatabase{M, I, B, F}) -> Any

TODO change to not use void_int

read_map(exo)
Exodus.read_nameMethod
read_name(
    exo::ExodusDatabase,
    _::Type{S<:Exodus.AbstractExodusSet},
    id::Integer
) -> String
read_name(exo, _, id)
Exodus.read_nameMethod
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)
Exodus.read_namesMethod
read_names(
    exo::ExodusDatabase,
    _::Type{S<:Exodus.AbstractExodusSet}
) -> Any
read_names(exo, _)
Exodus.read_namesMethod
read_names(
    exo::Exodus.ParallelExodusDatabase,
    type::Type{T<:Union{Exodus.AbstractExodusVariable, Exodus.AbstractExodusSet}}
) -> Any
read_names(exo, type)
Exodus.read_namesMethod
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, _)
Exodus.read_node_set_nodesMethod
read_node_set_nodes(
    exo::ExodusDatabase{M, I, B, F},
    set_id::Integer
) -> Any
read_node_set_nodes(exo, set_id)
Exodus.read_number_of_variablesMethod
read_number_of_variables(
    exo::Exodus.ParallelExodusDatabase,
    type::Type{T<:Exodus.AbstractExodusVariable}
) -> Any
read_number_of_variables(exo, type)
Exodus.read_number_of_variablesMethod
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, _)
Exodus.read_partial_block_connectivityMethod
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
)
Exodus.read_partial_coordinatesMethod
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)
Exodus.read_partial_coordinates_componentMethod
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
)
Exodus.read_qaMethod
read_qa(exo::ExodusDatabase) -> Matrix{String}
read_qa(exo)
Exodus.read_setMethod
read_set(
    exo::ExodusDatabase,
    type::Type{S<:Exodus.AbstractExodusSet},
    set_id
) -> Any
read_set(exo, type, set_id)
Exodus.read_setMethod
read_set(
    exo::Exodus.ParallelExodusDatabase,
    type::Type{T},
    id
) -> Any
read_set(exo, type, id)
Exodus.read_set_parametersMethod
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, _)
Exodus.read_sets!Method
read_sets!(
    sets::Array{T<:Exodus.AbstractExodusSet, 1},
    exo::ExodusDatabase,
    ids::Array{I, 1}
)
read_sets!(sets, exo, ids)
Exodus.read_setsMethod
read_sets(
    exo::ExodusDatabase{M, I, B, F},
    type::Type{S<:Exodus.AbstractExodusSet}
) -> Any
read_sets(exo, type)
Exodus.read_setsMethod
read_sets(
    exo::Exodus.ParallelExodusDatabase,
    type::Type{T<:Exodus.AbstractExodusSet}
) -> Any
read_sets(exo, type)
Exodus.read_side_set_elements_and_sidesMethod
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)
Exodus.read_side_set_node_listMethod
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)
Exodus.read_timeMethod
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)
Exodus.read_timesMethod
read_times(exo::ExodusDatabase) -> Vector
read_times(exo)
Exodus.read_valuesMethod
read_values(
    exo::Exodus.ParallelExodusDatabase,
    t::Type{GlobalVariable},
    timestep::Integer
) -> Any

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

Example: read_values(exo, GlobalVariable, 1)

read_values(exo, t, timestep)
Exodus.read_valuesMethod
read_values(
    exo::Exodus.ParallelExodusDatabase,
    t::Type{NodalVariable},
    timestep::Integer,
    index::Integer
) -> Any

Wrapper method for nodal variables

read_values(exo, t, timestep, index)
Exodus.read_valuesMethod
read_values(
    exo::Exodus.ParallelExodusDatabase,
    t::Type{NodalVariable},
    timestep::Integer,
    name::String
) -> Any

Wrapper method for nodal variables

read_values(exo, t, timestep, name)
Exodus.read_valuesMethod
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)
Exodus.read_valuesMethod
read_values(
    exo::ExodusDatabase,
    t::Type{NodalVariable},
    timestep::Integer,
    index::Integer
) -> Any

Wrapper method for nodal variables

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

Wrapper method for nodal variables

read_values(exo, t, timestep, name)
Exodus.read_valuesMethod
read_values(
    exo::Exodus.ParallelExodusDatabase,
    type::Type{T<:Exodus.AbstractExodusSet},
    time_step::Int64,
    id::Int64,
    var_index::Int64
) -> Any
read_values(exo, type, time_step, id, var_index)
Exodus.read_valuesMethod
read_values(
    exo::Exodus.ParallelExodusDatabase,
    type::Type{V<:Exodus.AbstractExodusVariable},
    time_step::Integer,
    id::Integer,
    var_name::String
) -> Any
read_values(exo, type, time_step, id, var_name)
Exodus.read_valuesMethod
read_values(
    exo::Exodus.ParallelExodusDatabase,
    type::Type{V<:Exodus.AbstractExodusVariable},
    time_step::Integer,
    set_name::String,
    var_name::String
)
read_values(exo, type, time_step, set_name, var_name)
Exodus.read_valuesMethod
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)
Exodus.read_valuesMethod
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)
Exodus.read_valuesMethod
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)
Exodus.read_valuesMethod
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)
Exodus.read_valuesMethod
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)
Exodus.read_valuesMethod
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)
Exodus.write_blockMethod
write_block(exo::ExodusDatabase, block::Block)

WARNING: currently does not support edges, faces and attributes

write_block(exo, block)
Exodus.write_block_connectivityMethod
write_block_connectivity(
    exo::ExodusDatabase,
    block_id::Integer,
    conn::Array{I<:Integer, 2}
)
write_block_connectivity(exo, block_id, conn)
Exodus.write_blocksMethod
write_blocks(exo::ExodusDatabase, blocks::Vector{<:Block})
write_blocks(exo, blocks)
Exodus.write_coordinate_namesMethod
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)
Exodus.write_coordinatesMethod
write_coordinates(
    exo::ExodusDatabase,
    coords::Union{Array{F<:AbstractFloat, 1}, Array{F<:AbstractFloat, 2}}
)

Method to write coordinates

write_coordinates(exo, coords)
Exodus.write_id_mapMethod
write_id_map(
    exo::ExodusDatabase{M, I, B, F},
    type::Type{MAP<:Exodus.AbstractExodusMap},
    map::Array{M, 1}
)
write_id_map(exo, type, map)
Exodus.write_infoMethod
write_info(exo::ExodusDatabase, info::Vector{String})
write_info(exo, info)
Exodus.write_initialization!Method
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)
Exodus.write_nameMethod
write_name(
    exo::ExodusDatabase{M, I, B, F},
    set::Exodus.AbstractExodusSet,
    name::String
)
write_name(exo, set, name)
Exodus.write_nameMethod
write_name(
    exo::ExodusDatabase{M, I, B, F},
    _::Type{S<:Exodus.AbstractExodusSet},
    set_id::Integer,
    name::String
)
write_name(exo, _, set_id, name)
Exodus.write_nameMethod
write_name(
    exo::ExodusDatabase,
    _::Type{V<:Exodus.AbstractExodusVariable},
    var_index::Integer,
    var_name::String
)
write_name(exo, _, var_index, var_name)
Exodus.write_namesMethod
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)
Exodus.write_namesMethod
write_names(
    exo::ExodusDatabase,
    type::Type{V<:Exodus.AbstractExodusVariable},
    var_names::Vector{String}
)
write_names(exo, type, var_names)
Exodus.write_number_of_variablesMethod
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)
Exodus.write_partial_coordinatesMethod
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)
Exodus.write_partial_coordinates_componentMethod
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
)
Exodus.write_partial_coordinates_componentMethod
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
)
Exodus.write_qaMethod
write_qa(exo::ExodusDatabase, qa_record::Matrix{String})
write_qa(exo, qa_record)
Exodus.write_setMethod
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)
Exodus.write_set_parametersMethod
write_set_parameters(
    exo::ExodusDatabase{M, I, B, F},
    set::Exodus.AbstractExodusSet
)

WARNING: currently doesn't support distance factors

write_set_parameters(exo, set)
Exodus.write_setsMethod
write_sets(
    exo::ExodusDatabase,
    sets::Array{T<:Exodus.AbstractExodusSet, 1}
)
write_sets(exo, sets)
Exodus.write_timeMethod
write_time(
    exo::ExodusDatabase,
    time_step::Integer,
    time_value::AbstractFloat
)
write_time(exo, time_step, time_value)
Exodus.write_valuesMethod
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)
Exodus.write_valuesMethod
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)
Exodus.write_valuesMethod
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)
Exodus.write_valuesMethod
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)
Exodus.write_valuesMethod
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)
Exodus.write_valuesMethod
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
)