IO - Functions

_init_overlap_map_(size)

Initialize the overlap map.

Arguments

• size::Int64: The number of ranks.

Returns

• overlap_map::Dict{Int64,Dict{Int64,Dict{String,Vector{Int64}}}}: The overlap map.

apply_bond_filters(nlist::Vector{Vector{Int64}}, mesh::DataFrame, params::Dict, dof::Int64)

Apply the bond filters to the neighborhood list.

Arguments

• nlist::Vector{Vector{Int64}}: The neighborhood list.
• mesh::DataFrame: The mesh.
• params::Dict: The parameters.
• dof::Int64: The degrees of freedom.

Returns

• nlist::Vector{Vector{Int64}}: The filtered neighborhood list.
• nlist_filtered_ids::Vector{Vector{Int64}}: The filtered neighborhood list.

area_of_polygon(vertices)

Calculate the area of a polygon.

Arguments

• vertices: The vertices of the polygon.

Returns

• area: The area of the polygon.

bond_intersect_infinite_plane(p0::Vector{Float64}, p1::Vector{Float64}, lower_left_corner::Vector{Float64}, normal::Vector{Float64})

Check if a line segment intersects an infinite plane.

Arguments

• p0::Vector{Float64}: The start point of the line segment.
• p1::Vector{Float64}: The end point of the line segment.
• lower_left_corner::Vector{Float64}: The lower left corner of the plane.
• normal::Vector{Float64}: The normal of the plane.

Returns

• Bool: True if the line segment intersects the plane, False otherwise.

bond_intersect_rectangle_plane(x::Vector{Float64}, lower_left_corner::Vector{Float64}, bottom_unit_vector::Vector{Float64}, normal::Vector{Float64}, side_length::Float64, bottom_length::Float64)

Check if a bond intersects a rectangle plane.

Arguments

• x::Vector{Float64}: The point.
• lower_left_corner::Vector{Float64}: The lower left corner of the rectangle.
• bottom_unit_vector::Vector{Float64}: The unit vector along the bottom of the rectangle.
• normal::Vector{Float64}: The normal of the plane.
• side_length::Float64: The side length of the rectangle.
• bottom_length::Float64: The bottom length of the rectangle.

Returns

• Bool: True if the point is inside the rectangle, False otherwise.

bond_intersects_disc(p0::Vector{Float64}, p1::Vector{Float64}, center::Vector{Float64}, normal::Vector{Float64}, radius::Float64)

Check if a line segment intersects a disk.

Arguments

• p0::Vector{Float64}: The start point of the line segment.
• p1::Vector{Float64}: The end point of the line segment.
• center::Vector{Float64}: The center of the disk.
• normal::Vector{Float64}: The normal of the plane.
• radius::Float64: The radius of the disk.

Returns

• Bool: True if the line segment intersects the disk, False otherwise.

calculate_block(datamanager::Module, field_key::String, dof::Int64, calculation_type::String, block::Int64)

Calculate the global value of a field for a given block.

Arguments

• datamanager::Data_manager: Datamanager.
• field_key::String: Field key.
• dof::Union{Int64,Vector{Int64}}: Degree of freedom
• calculation_type::String: Calculation type.
• block::Int64: Block number.

Returns

• value::Float64: Global value.
• nnodes::Int64: Number of nodes.

calculate_nodelist(datamanager::Module, field_key::String, dof::Union{Int64,Vector{Int64}}, calculation_type::String, local_nodes::Vector{Int64})

Calculate the global value of a field for a given set of nodes.

Arguments

• datamanager::Data_manager: Datamanager.
• field_key::String: Field key.
• dof::Union{Int64,Vector{Int64}}: Degree of freedom
• calculation_type::String: Calculation type.
• local_nodes::Vector{Int64}: Node set.

Returns

• value::Vector: Global value.
• nnodes::Int64: Number of nodes.

calculate_volume(element_type::String, vertices::Vector{Vector{Float64}})

Calculate the volume of a element.

Arguments

• element_type: The element type of the element.
• vertices: The vertices of the element.

Returns

• volume: The volume of the element.

check_for_duplicate_in_dataframe(mesh::DataFrame)

check duplicated entries and throws an error if one is there. If not everything is ok.

Arguments

• mesh::DataFrame: The input mesh data represented as a DataFrame.

check_mesh_elements(mesh, dof)

Process and analyze mesh data to create an dictionary containing information about mesh elements for further processing.

Arguments

• mesh::DataFrame: The input mesh data represented as a DataFrame.
• dof::Int64: The degrees of freedom (DOF) for the mesh elements.

Returns

A dictionary containing information about mesh elements, which can be used for further processing or uploading.

Example

```julia meshdata = DataFrame(x1 = [1.0, 2.0, 3.0], x2 = [4.0, 5.0, 6.0], volume = [10.0, 20.0, 30.0]) dof = 3 result = checkmeshelements(meshdata, dof)

check_types_in_dataframe(mesh::DataFrame)

check if block_id in mesh contains only int.

Arguments

• mesh::DataFrame: The input mesh data represented as a DataFrame.

clearNP1(name::String)

Clears the NP1 from the name

Arguments

• name::String: The name

Returns

• name::String: The cleared name

close_result_file(result_file::Dict)

Closes the result file

Arguments

• result_file::Dict: The result file

close_result_files(result_files::Vector{Dict}, outputs::Dict{Int64,Dict{}})

Closes the result files if the flush_file flag is not set

Arguments

• result_files::Vector{Dict}: The result files
• outputs::Dict{Int64,Dict{}}: The output settings

close_result_files(result_files::Vector{Dict})

Closes the result files

Arguments

• result_files::Vector{Dict}: The result files

Returns

• true: File is closed
• false: File was already closed

create_and_distribute_bond_norm(comm::MPI.Comm, datamanager::Module, nlist_filtered_ids::Vector{Vector{Int64}}, distribution::Vector{Int64}, bond_norm::Vector{Float64}, dof::Int64)

Create and distribute the bond norm

Arguments

• comm::MPI.Comm: MPI communicator
• datamanager::Module: Data manager
• nlist_filtered_ids::Vector{Vector{Int64}}: The filtered neighborhood list
• distribution::Vector{Int64}: The distribution
• bond_norm::Vector{Float64}: The bond norm
• dof::Int64: The degree of freedom

create_distribution(nnodes::Int64, size::Int64)

Calculate the initial size of each chunk for a nearly equal number of nodes vs. cores this algorithm might lead to the problem, that the last core is not equally loaded

Arguments

• nnodes::Int64: The number of nodes.
• size::Int64: The number of cores.

Returns

• distribution::Array{Int64,1}: The distribution of the nodes.
• point_to_core::Array{Int64,1}: The number of nodes in each rank.

create_distribution_neighbor_based(nnodes::Int64,nlist::Vector{Vector{Int64}}, size::Int64)

Calculate the initial size of each chunk for a nearly equal number of nodes vs. cores this algorithm might lead to the problem, that the last core is not equally loaded

Arguments

• nnodes::Int64: The number of nodes.
• nlist::Vector{Vector{Int64}}: The neighborhood list.
• size::Int64: The number of cores.

Returns

• distribution::Array{Int64,1}: The distribution of the nodes.
• point_to_core::Array{Int64,1}: The number of nodes in each rank.

create_distribution_node_based(nnodes::Int64,nlist::Vector{Vector{Int64}}, size::Int64)

Calculate the initial size of each chunk for a nearly equal number of nodes vs. cores this algorithm might lead to the problem, that the last core is not equally loaded

Arguments

• nnodes::Int64: The number of nodes.
• nlist::Vector{Vector{Int64}}: The neighborhood list.
• size::Int64: The number of cores.

Returns

• distribution::Array{Int64,1}: The distribution of the nodes.
• point_to_core::Array{Int64,1}: The number of nodes in each rank.

create_neighborhoodlist(mesh::DataFrame, params::Dict, dof::Int64)

Create the neighborhood list of the mesh elements.

Arguments

• mesh::DataFrame: The input mesh data represented as a DataFrame.
• params::Dict: The input parameters.
• dof::Int64: The degrees of freedom (DOF) for the mesh elements.

Returns

• nlist::Array{Array{Int64,1},1}: The neighborhood list of the mesh elements.

create_overlap_map(distribution, ptc, size)

Create the overlap map.

Arguments

• distribution::Array{Int64,1}: The distribution of the nodes.
• ptc::Array{Int64,1}: The number of nodes in each rank.
• size::Int64: The number of ranks.

Returns

• overlap_map::Dict{Int64,Dict{Int64,Dict{String,Vector{Int64}}}}: The overlap map.

create_result_file(filename::Union{AbstractString,String}, num_nodes::Int64, num_dim::Int64, num_elem_blks::Int64, num_node_sets::Int64)

Creates a exodus file for the results

Arguments

• filename::Union{AbstractString,String}: The name of the file to create
• num_nodes::Int64: The number of nodes
• num_dim::Int64: The number of dimensions
• num_elem_blks::Int64: The number of element blocks
• num_node_sets::Int64: The number of node sets

Returns

• result_file::Dict{String,Any}: A dictionary containing the filename and the exodus file

create_result_file(filename::String, outputs::Dict)

Creates a csv file for the results

Arguments

• filename::String: The name of the file to create
• outputs::Dict: The outputs dictionary

Returns

• Dict: The result file

csv_reader(filename::String)

Read csv and return it as a DataFrame.

Arguments

• filename::String: The path to the mesh file.

Returns

• csvData::DataFrame: The csv data a DataFrame.

define_nsets(nsets::Dict{String,Vector{Int64}}, datamanager::Module)

Defines the node sets

Arguments

• nsets::Dict{String,Vector{Int64}}: Node sets read from files
• datamanager::Module: Data manager

delete_files(result_files::Vector{Dict})

Deletes the result files

Arguments

• result_files: The result files

disk_filter(nnodes::Int64, data::Matrix{Float64}, filter::Dict, nlist::Vector{Vector{Int64}}, dof::Int64)

Apply the disk filter to the neighborhood list.

Arguments

• nnodes::Int64: The number of nodes.
• data::Matrix{Float64}: The data.
• filter::Dict: The filter.
• nlist::Vector{Vector{Int64}}: The neighborhood list.
• dof::Int64: The degrees of freedom.

Returns

• filter_flag::Vector{Bool}: The filter flag.
• normal::Vector{Float64}: The normal vector of the disk.

distribute_neighborhoodlist_to_cores(comm::MPI.Comm, datamanager::Module, nlist, distribution)

Distributes the neighborhood list to the cores.

Arguments

• comm::MPI.Comm: MPI communicator
• datamanager::Module: Data manager
• nlist: neighborhood list
• distribution Array{Int64}: global nodes distribution at cores

Returns

• datamanager::Module: data manager

distribution_to_cores(comm::MPI.Comm, datamanager::Module, mesh, distribution, dof::Int64)

Distributes the mesh data to the cores

Arguments

• comm::MPI.Comm: MPI communicator
• datamanager::Module: Data manager
• mesh: Mesh
• distribution Array{Int64}: global nodes distribution at cores
• dof::Int64: Degree of freedom

Returns

• datamanager::Module: data manager

element_distribution(topology::Vector{Vector{Int64}}, ptc::Vector{Int64}, size::Int64)

Create the distribution of the finite elements. Is needed to avoid multiple element calls. Each element should run only one time at the cores.

Arguments

• topology::Vector{Vector{Int64}}: The topology list of the mesh elements.
• nlist::Vector{Vector{Int64}}: The neighborhood list of the mesh elements.
• size::Int64: The number of ranks.

Returns

• distribution::Vector{Vector{Int64}}: The distribution of the nodes.
• etc::Vector{Int64}: The number of nodes in each rank.

extrude_surface_mesh(mesh::DataFrame)

extrude the mesh at the surface of the block

Arguments

• mesh::DataFrame: The input mesh data represented as a DataFrame.
• params::Dict: The input parameters.

find_and_set_core_value_avg(comm::MPI.Comm, value::Union{Float64,Int64})

Find and set core value avg

Arguments

• comm::MPI.Comm: The MPI communicator
• value::Union{Float64,Int64}: The value

Returns

• recv_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The received message

find_and_set_core_value_max(comm::MPI.Comm, value::Union{Float64,Int64})

Find and set core value max

Arguments

• comm::MPI.Comm: The MPI communicator
• value::Union{Float64,Int64}: The value

Returns

• recv_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The received message

find_and_set_core_value_min(comm::MPI.Comm, value::Union{Float64,Int64})

Find and set core value min

Arguments

• comm::MPI.Comm: The MPI communicator
• value::Union{Float64,Int64}: The value

Returns

• recv_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The received message

find_and_set_core_value_sum(comm::MPI.Comm, value::Union{Float64,Int64})

Find and set core value sum

Arguments

• comm::MPI.Comm: The MPI communicator
• value::Union{Float64,Int64}: The value

Returns

• recv_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The received message

find_global_core_value!(global_value::Union{Int64,Float64}, calculation_type::String, nnodes::Int64, datamanager::Module)

Find global core value.

Arguments

• global_value::Union{Int64,Float64}: The global value
• calculation_type::String: The calculation type
• nnodes::Int64: The number of nodes
• datamanager::Module: The datamanager

Returns

• global_value::Union{Int64,Float64}: The global value

gather_values(comm::MPI.Comm, value::Any)

Gather values

Arguments

• comm::MPI.Comm: The MPI communicator
• value::Any: The value

Returns

• recv_msg::Any: The received message

get_block_nodes(block_Id::Union{SubArray,Vector{Int64}}, block::Int64)

Returns the nodes of a block

Arguments

• block_Id::Union{SubArray,Vector{Int64}}: The block Id
• block::Int64: The block

Returns

• nodes::Vector{Int64}: The nodes of the block

get_bond_geometry(datamanager::Module)

Gets the bond geometry

Arguments

• datamanager::Module: Data manager

Returns

• datamanager::Module: data manager

get_file_size(result_files::Vector{Dict})

Gets the file size of the result files

Arguments

• result_files: The result files

Returns

• total_file_size: The total file size

get_global_values(output::Dict, datamanager::Module)

Get global values.

Arguments

• output::Dict: The output
• datamanager::Module: The datamanager

Returns

• global_values::Vector: The global values

get_local_element_topology(datamanager::Module, topology::Vector{Vector{Int64}}, distribution::Vector{Int64})

Get the local element topology

Arguments

• datamanager::Module: The datamanager
• topology::Vector{Vector{Int64}}: The topology
• distribution::Vector{Int64}: The distribution

Returns

• datamanager::Module: The datamanager

get_local_neighbors(mapping, nlist_core)

Gets the local neighborhood list from the global neighborhood list

Arguments

• mapping: mapping function
• nlist_core: global neighborhood list

Returns

• nlist_core: local neighborhood list

get_local_overlap_map()

Changes entries in the overlap map from the global numbering to the local computer core one.

Arguments

• overlap_map::Dict{Int64, Dict{Int64, String}}: overlap map with global nodes.
• distribution::Vector{Vector{Int64}}: global nodes distribution at cores, needed for the gobal to local mapping
• ranks Array{Int64} : number of used computer cores

Returns

• overlap_map::Dict{Int64, Dict{Int64, String}}: returns overlap map with local nodes.

Example:

get_local_overlap_map(overlap_map, distribution, ranks)  # returns local nodes

get_mpi_rank_string(rank::Int64, max_rank::Int64)

Get MPI rank string.

Arguments

• value::Int64: The rank
• max_rank::Int64: The max rank

Returns

• result::String: The result

get_number_of_neighbornodes(nlist::Vector{Vector{Int64}})

Get the number of neighbors for each node.

Arguments

• nlist::Vector{Vector{Int64}}: The neighborhood list of the mesh elements.

Returns

• length_nlist::Vector{Int64}: The number of neighbors for each node.

get_paraview_coordinates(dof::Int64, refDof::Int64)

Returns the paraview specific dof

Arguments

• dof::Int64: The degrees of freedom
• refDof::Int64: The reference degrees of freedom

Returns

• paraview_specifics::String: The paraview specific dof

get_results_mapping(params::Dict, path::String, datamanager::Module)

Gets the results mapping

Arguments

• params::Dict: The parameters
• path::String: The path
• datamanager::Module: The datamanager

Returns

• output_mapping::Dict{Int64,Dict{}}: The results mapping

glob_to_loc(distribution)

Get the global to local mapping

Arguments

• distribution: The distribution

Returns

• glob_to_loc: The global to local mapping

global_value_avg(field::Union{Vector{Float64},Matrix{Float64}}, dof::Union{Int64,Vector{Int64}}, nodes::Union{SubArray,Vector{Int64}})

Calculate the global average of a field for given nodes.

Arguments

• field::Union{Vector{Float64},Matrix{Float64}}: Field.
• dof::Union{Int64,Vector{Int64}}: Degree of freedom
• nodes::Union{SubArray,Vector{Int64}}: Nodes.

Returns

• returnValue::Vector: Global value.

global_value_max(field::Union{Vector{Float64},Matrix{Float64}}, dof::Union{Int64,Vector{Int64}}, nodes::Union{SubArray,Vector{Int64}})

Calculate the global maximum of a field for given nodes.

Arguments

• field::Union{Vector{Float64},Matrix{Float64}}: Field.
• dof::Union{Int64,Vector{Int64}}: Degree of freedom
• nodes::Union{SubArray,Vector{Int64}}: Nodes.

Returns

• returnValue::Vector: Global value.

global_value_min(field::Union{Vector{Float64},Matrix{Float64}}, dof::Union{Int64,Vector{Int64}}, nodes::Union{SubArray,Vector{Int64}})

Calculate the global minimum of a field for given nodes.

Arguments

• field::Union{Vector{Float64},Matrix{Float64}}: Field.
• dof::Union{Int64,Vector{Int64}}: Degree of freedom
• nodes::Union{SubArray,Vector{Int64}}: Nodes.

Returns

• returnValue::Vector: Global value.

global_value_sum(field::Union{Vector{Float64},Matrix{Float64}}, dof::Union{Int64,Vector{Int64}}, nodes::Union{SubArray,Vector{Int64}})

Calculate the global sum of a field for given nodes.

Arguments

• field::Union{Vector{Float64},Matrix{Float64}}: Field.
• dof::Union{Int64,Vector{Int64}: Degree of freedom
• nodes::Union{SubArray,Vector{Int64}}: Nodes.

Returns

• returnValue::Vector: Global value.

hex8volume(hexvertices)

Calculate the volume of a hex.

Arguments

• hex_vertices: The vertices of the wedge.

Returns

• volume: The volume of the wedge.

init_data(params::Dict, path::String, datamanager::Module, comm::MPI.Comm, to::TimerOutput)

Initializes the data for the mesh.

Arguments

• params::Dict: The parameters for the simulation.
• path::String: The path to the mesh file.
• datamanager::Data_manager: The data manager.
• comm::MPI.Comm: The MPI communicator.
• to::TimerOutput: The timer output.

Returns

• datamanager::Data_manager: The data manager.
• params::Dict: The parameters for the simulation.

init_orientations(datamanager::Module)

Initialize orientations.

Arguments

• datamanager::Module: The datamanager

init_results_in_exodus(exo::ExodusDatabase, output::Dict{}, coords::Union{Matrix{Int64},Matrix{Float64}}, block_Id::Vector{Int64}, uniqueBlocks::Vector{Int64}, nsets::Dict{String,Vector{Int64}}, global_ids::Vector{Int64}, PERILAB_VERSION::String)

Initializes the results in exodus

Arguments

• exo::ExodusDatabase: The exodus database
• output::Dict{String,Any}: The output
• coords::Union{Matrix{Int64},Matrix{Float64}}: The coordinates
• block_Id::Vector{Int64}: The block Id
• uniqueBlocks::Vector{Int64}: The unique blocks
• nsets::Dict{String,Vector{Int64}}: The node sets
• global_ids::Vector{Int64}: The global ids

Returns

• result_file::Dict{String,Any}: The result file

init_write_results(params::Dict, output_dir::String, path::String, datamanager::Module, nsteps::Int64, PERILAB_VERSION::String)

Initialize write results.

Arguments

• params::Dict: The parameters
• output_dir::String: The output directory.
• path::String: The path
• datamanager::Module: The datamanager
• nsteps::Int64: The number of steps

Returns

• result_files::Array: The result files
• outputs::Dict: The outputs

initialize_data(filename::String, filedirectory::String, datamanager::Module, comm::MPI.Comm, to::TimerOutputs.TimerOutput)

Initialize data.

Arguments

• filename::String: The name of the input file.
• filedirectory::String: The directory of the input file.
• datamanager::Module: The datamanager
• comm::MPI.Comm: The MPI communicator
• to::TimerOutputs.TimerOutput: The TimerOutput

Returns

• data::Dict: The data

load_and_evaluate_mesh(params::Dict, path::String, ranksize::Int64, to::TimerOutput)

Load and evaluate the mesh data.

Arguments

• params::Dict: The input parameters.
• path::String: The path to the mesh file.
• ranksize::Int64: The number of ranks.
• to::TimerOutput: The timer output

Returns

• distribution::Array{Int64,1}: The distribution of the mesh elements.
• mesh::DataFrame: The mesh data as a DataFrame.
• ntype::Dict: The type of the mesh elements.
• overlap_map::Array{Array{Int64,1},1}: The overlap map of the mesh elements.
• nlist::Array{Array{Int64,1},1}: The neighborhood list of the mesh elements.
• dof::Int64: The degrees of freedom (DOF) for the mesh elements.
• nsets::Dict: The node sets
• topology::Int64::Array{Int64,nelement:nodes}`: The topology of elements.
• el_distribution::Array{Int64,1}: The distribution of the finite elements.

local_nodes_from_dict(glob_to_loc::Dict{Int,Int}, global_nodes::Vector{Int64})

Changes entries in the overlap map from the global numbering to the local computer core one.

Arguments

• glob_to_loc::Dict{Int,Int}: global to local mapping
• global_nodes::Vector{Int64}: global nodes

Returns

• overlap_map::Dict{Int64, Dict{Int64, String}}: returns overlap map with local nodes.

merge_exodus_file(file_name::Union{AbstractString,String})

Merges the exodus file

Arguments

• file_name::Union{AbstractString,String}: The name of the file to merge

Returns

• exo::ExodusDatabase: The exodus file

merge_exodus_files(result_files::Vector{Any}, output_dir::String)

Merges exodus output files

Arguments

• result_files::Vector{Any}: The result files
• output_dir::String: The file directory

neighbors(mesh, params::Dict, coor)

Compute the neighbor list for each node in a mesh based on their proximity using a BallTree data structure.

Arguments

• mesh: A mesh data structure containing the coordinates and other information.
• params: paramss needed for computing the neighbor list.
• coor: A vector of coordinate names along which to compute the neighbor list.

Returns

An array of neighbor lists, where each element represents the neighbors of a node in the mesh.

node_distribution(nlist::Vector{Vector{Int64}}, size::Int64)

Create the distribution of the nodes.

Arguments

• nlist::Vector{Vector{Int64}}: The neighborhood list of the mesh elements.
• size::Int64: The number of ranks.
• distribution_type::String: The distribution type.

Returns

• distribution::Vector{Vector{Int64}}: The distribution of the nodes.
• ptc::Vector{Int64}: Defines at which core / rank each node lies.
• ntype::Dict: The type of the nodes.

open_result_file(result_file::Dict)

Opens the result file

Arguments

• result_file::Dict: The result file

paraview_specifics(dof::Int64)

Returns the paraview specific dof

Arguments

• dof::Int64: The degrees of freedom

Returns

• paraview_specifics::String: The paraview specific dof

read_external_topology(filename::String)

Read external topoloy data from a file and return it as a DataFrame.

Arguments

• filename::String: The path to the mesh file.

Returns

• external_topology::DataFrame: The external topology data as a DataFrame.

read_input(filename::String)

Reads the input deck from a yaml file

Arguments

• filename::String: The name of the yaml file

Returns

• params::Dict{String,Any}: The parameters read from the yaml file

read_input_file(filename::String)

Reads the input deck from a yaml file

Arguments

• filename::String: The name of the yaml file

Returns

• Dict{String,Any}: The validated parameters read from the yaml file.

read_mesh(filename::String, params::Dict)

Read mesh data from a file and return it as a DataFrame.

Arguments

• filename::String: The path to the mesh file.
• params::Dict: The input parameters.

Returns

• mesh::DataFrame: The mesh data as a DataFrame.

rectangular_plane_filter(nnodes::Int64, data::Matrix{Float64}, filter::Dict, nlist::Vector{Vector{Int64}}, dof::Int64)

Apply the rectangular plane filter to the neighborhood list.

Arguments

• nnodes::Int64: The number of nodes.
• data::Matrix{Float64}: The data.
• filter::Dict: The filter.
• nlist::Vector{Vector{Int64}}: The neighborhood list.
• dof::Int64: The degrees of freedom.

Returns

• filter_flag::Vector{Bool}: The filter flag.
• normal::Vector{Float64}: The normal vector of the disk.

send_single_value_from_vector(comm::MPI.Comm, controller::Int64, values::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}, type::Type)

Sends a single value from a vector to a controller

Arguments

• comm::MPI.Comm: The MPI communicator
• controller::Int64: The controller
• values::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The values
• type::Type: The type

Returns

• recv_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The received message

send_value(comm::MPI.Comm, controller, send_msg)

Sends a value to a controller

Arguments

• comm::MPI.Comm: The MPI communicator
• controller::Int64: The controller
• send_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The send message

Returns

• recv_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The received message

send_vector_from_root_to_core_i(comm::MPI.Comm, send_msg, recv_msg, distribution)

Sends a vector from the root to the core i

Arguments

• comm::MPI.Comm: The MPI communicator
• send_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The send message
• recv_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The receive message
• distribution::Vector{Int64}: The distribution

Returns

• recv_msg::Union{Int64,Vector{Float64},Vector{Int64},Vector{Bool}}: The received message

set_dof(mesh::DataFrame)

Set the degrees of freedom (DOF) for the mesh elements.

Arguments

• mesh::DataFrame: The input mesh data represented as a DataFrame.

Returns

• dof::Int64: The degrees of freedom (DOF) for the mesh elements.

show_block_summary(solver_options::Dict, params::Dict, log_file::String, silent::Bool, comm::MPI.Comm, datamanager::Module)

Show block summary.

Arguments

• solver_options::Dict: The solver options
• params::Dict: The params
• log_file::String: The log file
• silent::Bool: The silent flag
• comm::MPI.Comm: The comm
• datamanager::Module: The datamanager

show_mpi_summary(log_file::String, silent::Bool, comm::MPI.Comm, datamanager::Module)

Show MPI summary.

Arguments

• log_file::String: The log file
• silent::Bool: The silent flag
• comm::MPI.Comm: The comm
• datamanager::Module: The datamanager

split_vector(input, row_nums, dof)

Split a vector into a vector of matrices

Arguments

• input::Vector: The input vector
• row_nums::Vector: The row numbers
• dof::Int: The degree of freedom

Returns

• result::Vector: The result vector

synch_controller_bonds_to_responder(comm::MPI.Comm, overlapnodes, array, dof)

Synch the controller bonds to the responder

Arguments

• comm::MPI.Comm: The MPI communicator
• overlapnodes::Dict: The overlap nodes
• array::Array: The array
• dof::Int: The degree of freedom

Returns

• array::Array: The array

synch_controller_bonds_to_responder_flattened(comm::MPI.Comm, overlapnodes, array, dof)

Synch the controller bonds to the responder

Arguments

• comm::MPI.Comm: The MPI communicator
• overlapnodes::Dict: The overlap nodes
• array::Array: The array
• dof::Int: The degree of freedom

Returns

• array::Array: The array

synch_controller_to_responder(comm::MPI.Comm, overlapnodes, vector, dof)

Synch the controller to the responder

Arguments

• comm::MPI.Comm: The MPI communicator
• overlapnodes::Dict: The overlap nodes
• vector::Vector: The vector
• dof::Int: The degree of freedom

Returns

• vector::Vector: The vector

synch_responder_to_controller(comm::MPI.Comm, overlapnodes, vector, dof)

Synch the responder to the controller

Arguments

• comm::MPI.Comm: The MPI communicator
• overlapnodes::Dict: The overlap nodes
• vector::Vector: The vector
• dof::Int: The degree of freedom

Returns

• vector::Vector: The vector

tetrahedron_volume(tet_vertices)

Calculate the volume of a tetrahedron.

Arguments

• tet_vertices: The vertices of the tetrahedron.

Returns

• volume: The volume of the tetrahedron.

wedge6_volume(wedge_vertices)

Calculate the volume of a wedge.

Arguments

• wedge_vertices: The vertices of the wedge.

Returns

• volume: The volume of the wedge.

write_global_results_in_csv(csv_file::IOStream, time::Float64, global_values)

Writes the global results to the csv file

Arguments

• csv_file::IOStream: The csv file
• global_values: The global values

write_global_results_in_exodus(exo::ExodusDatabase, step::Int64, global_values)

Writes the global results in the exodus file

Arguments

• exo::ExodusDatabase: The exodus file
• step::Int64: The step
• global_values: The global values

Returns

• exo::ExodusDatabase: The exodus file

write_nodal_results_in_exodus(exo::ExodusDatabase, step::Int64, output::Dict, datamanager::Module)

Writes the nodal results in the exodus file

Arguments

• exo::ExodusDatabase: The exodus file
• step::Int64: The step
• output::Dict: The output
• datamanager::Module: The datamanager

Returns

• exo::ExodusDatabase: The exodus file

write_results(result_files::Vector{Any}, time::Float64, max_damage::Float64, outputs::Dict, datamanager::Module)

Write results.

Arguments

• result_files::Vector{Any}: The result files
• time::Float64: The time
• max_damage::Float64: The maximum damage
• outputs::Dict: The outputs
• datamanager::Module: The datamanager

Returns

• result_files::Vector{Any}: The result files

write_step_and_time(exo::ExodusDatabase, step::Int64, time::Float64)

Writes the step and time in the exodus file

Arguments

• exo::ExodusDatabase: The exodus file
• step::Int64: The step
• time::Float64: The time

Returns

• exo::ExodusDatabase: The exodus file

compute_deformation_gradients!(nodes::Union{SubArray, Vector{Int64}}, nlist, volume, omega, bond_damage, undeformed_bond, deformed_bond, inverse_shape_tensor, deformation_gradient)

Calculate the deformation gradient tensor for a set of nodes in a computational mechanics context.

Arguments

• nodes::Union{SubArray, Vector{Int64}}: A vector of integers representing node IDs.
• dof::Int64: An integer representing the degrees of freedom.
• nlist: A data structure (e.g., a list or array) representing neighboring node IDs for each node.
• volume: A vector or array containing volume information for each node.
• omega: A vector or array containing omega information for each node.
• bond_damage: A data structure representing bond damage for each node.
• undeformed_bond: A data structure representing bond geometries for each node.
• deformed_bond: A data structure representing deformed bond properties for each node.
• inverse_shape_tensor: A data structure representing the inverse shape tensors for each node.
• deformation_gradient: A preallocated 3D array to store the deformation gradient tensors for each node.

Output

• deformation_gradient: An updated deformation_gradient array with calculated deformation gradient tensors.

Description

This function calculates the deformation gradient tensor for a set of nodes in a computational mechanics context. The deformation gradient tensor characterizes the deformation of a material.

For each node in nodes, the function iterates through degrees of freedom (dof) and computes elements of the deformation gradient tensor based on bond damage, deformed bond properties, bond geometries, volume, and omega information. The calculated deformation gradient tensor is stored in deformation_gradient.

Example

```julia nodes = [1, 2, 3] dof = 3 nlist = [[2, 3], [1, 3], [1, 2]] volume = [0.1, 0.2, 0.3] omega = [0.5, 0.4, 0.6] bonddamage = zeros(Float64, length(nodes), length(nlist[1])) undeformedbond = rand(Float64, length(nodes), length(nlist[1]), dof) deformedbond = rand(Float64, length(nodes), length(nlist[1]), dof) inverseshapetensor = rand(Float64, length(nodes), dof, dof) deformationgradient = zeros(Float64, length(nodes), dof, dof)

compute_shape_tensors!(nodes::Union{SubArray, Vector{Int64}}, nlist, volume, omega, bond_damage, undeformed_bond, shape_tensor, inverse_shape_tensor)

Calculate the shape tensor and its inverse for a set of nodes in a computational mechanics context.

Arguments

• nodes::Union{SubArray, Vector{Int64}}: A vector of integers representing node IDs.
• dof::Int64: An integer representing the degrees of freedom.
• nlist: A data structure (e.g., a list or array) representing neighboring node IDs for each node.
• volume: A vector or array containing volume information for each node.
• omega: A vector or array containing omega information for each node.
• bond_damage: A data structure representing bond damage for each node.
• undeformed_bond: A data structure representing bond geometries for each node.
• shape_tensor: A preallocated 3D array to store the shape tensors for each node.
• inverse_shape_tensor: A preallocated 3D array to store the inverse shape tensors for each node.

Output

• shape_tensor: An updated shape_tensor array with calculated shape tensors.
• inverse_shape_tensor: An updated inverse_shape_tensor array with calculated inverse shape tensors.

Description

This function calculates the shape tensor and its inverse for a set of nodes in a computational mechanics context. The shape tensor is a key quantity used in continuum mechanics to describe material deformation. It is calculated based on bond damage, bond geometries, volume, and omega information for each node.

For each node in nodes, the function iterates through degrees of freedom (dof) and computes elements of the shape tensor. The inverse of the shape tensor is also calculated and stored in inverse_shape_tensor.

Example

```julia nodes = [1, 2, 3] dof = 3 nlist = [[2, 3], [1, 3], [1, 2]] volume = [0.1, 0.2, 0.3] omega = [0.5, 0.4, 0.6] bonddamage = zeros(Float64, length(nodes), length(nlist[1])) undeformedbond = rand(Float64, length(nodes), length(nlist[1]), dof) shapetensor = zeros(Float64, length(nodes), dof, dof) inverseshape_tensor = zeros(Float64, length(nodes), dof, dof)

function compute_strain(nodes::Union{Base.OneTo{Int64},Vector{Int64}, SubArray}, deformation_gradient, strain)

Calculate strains for specified nodes based on deformation gradients.

Arguments

• nodes::Union{SubArray, Vector{Int64}}: List of nodes
• deformation_gradient: Deformation gradient at current time step (2D or 3D array).

Returns

• Updated strain array containing strains.

This function iterates over the specified nodes and computes strain at each node using the given deformation gradients.

function rotation_tensor(angles::Vector{Float64})

Creates the rotation tensor for 2D or 3D applications. Uses Rotations.jl package.

Arguments

• angles::Vector{Float64}: Vector of angles definede in degrees of length one or three

Returns

• Rotation tensor

check_for_duplicates(filenames)

Check for duplicate filenames.

Arguments

• filenames::Vector{String}: The filenames

get_all_keys(params::Dict)

Get all the keys in the parameters

Arguments

• params::Dict: The parameters dictionary.

Returns

• keys_list::Array: The keys list

get_bc_definitions(params::Dict)

Get the boundary condition definitions

Arguments

• params::Dict: The parameters

Returns

• bcs::Dict{String,Any}: The boundary conditions

get_block_models(params::Dict, block_id::Int64)

Get the models of a block.

Arguments

• params::Dict: The parameters
• block_id::Int64: The ID of the block

Returns

• modelDict::Dict{String,String}: The models of the block

get_bond_filters(params::Dict)

Returns the bond filters from the parameters

Arguments

• params::Dict: The parameters

Returns

• check::Bool: Whether the bond filters are defined
• bfList::Dict{String,Dict{String,Any}}: The bond filters

get_calculation_options(params::Dict)

Get the calculation options

Arguments

• params::Dict: The parameters dictionary.

Returns

• solver_options::Dict: The solver options

get_computes(params::Dict, variables::Vector{String})

Get the computes.

Arguments

• params::Dict: The parameters dictionary.
• variables::Vector{String}: The variables.

Returns

• computes::Dict{String,Dict{Any,Any}}: The computes.

get_computes_names(params::Dict)

Get the names of the computes.

Arguments

• params::Dict: The parameters dictionary.

Returns

• computes_names::Vector{String}: The names of the computes.

get_density(params::Dict, block_id::Int64)

Get the density of a block.

Arguments

• params::Dict: The parameters
• block_id::Int64: The ID of the block

Returns

• density::Float64: The density of the block

get_external_topology_name(params::Dict)

Returns the name of the mesh file from the parameters

Arguments

• params::Dict: The parameters

Returns

• String: The name of the finite element topology file

get_fem_block(params::Dict, block_id::Int64)

Get the fem_block of a block.

Arguments

• params::Dict: The parameters
• block_id::Int64: The ID of the block

Returns

• fem_block::Float64: The fem_block of the block

get_final_time(params::Dict)

Get the final time

Arguments

• params::Dict: The parameters dictionary.

Returns

• final_time::Float64: The final time

get_fixed_dt(params::Dict)

Get the fixed time step

Arguments

• params::Dict: The parameters dictionary.

Returns

• fixed_dt::Float64: The fixed time step

get_flush_file(outputs::Dict, output::String)

Gets the flush file.

Arguments

• outputs::Dict: The outputs
• output::String: The output

Returns

• flush_file::Bool: The flush file

get_header(filename::Union{String,AbstractString})

Returns the header line and the header.

Arguments

• filename::Union{String,AbstractString}: The filename of the file.

Returns

• header_line::Int: The header line.
• header::Vector{String}: The header.

get_heat_capacity(params::Dict, block_id::Int64)

Get the heat capacity of a block.

Arguments

• params::Dict: The parameters
• block_id::Int64: The ID of the block

Returns

• heat_capacity::Float64: The heat capacity of the block

get_horizon(params::Dict, block_id::Int64)

Get the horizon of a block.

Arguments

• params::Dict: The parameters
• block_id::Int64: The ID of the block

Returns

• horizon::Float64: The horizon of the block

get_initial_time(params::Dict)

Get the initial time

Arguments

• params::Dict: The parameters dictionary.

Returns

• initial_time::Float64: The initial time

getmaxdamage(params::Dict)

Get the maximum damage.

Arguments

• params::Dict: The parameters dictionary.

Returns

• write_after_damage::Bool: The value

get_mesh_name(params::Dict)

Returns the name of the mesh file from the parameters

Arguments

• params::Dict: The parameters

Returns

• String: The name of the mesh file

get_model_options(params::Dict)

Get the solver options

Arguments

• params::Dict: The parameters dictionary.

Returns

• solver_options::Dict: The solver options

get_model_parameter(params, model, id)

Retrieve a model parameter from a dictionary of parameters.

This function retrieves a specific model parameter from a dictionary of parameters based on the provided model and identifier (id).

Arguments

• params::Dict: A dictionary containing various parameters.

• model::String: The model type for which the parameter is sought.

• id::String: The identifier (name) of the specific model parameter.

Returns

• parameter::Any: The retrieved model parameter, or nothing if the parameter is not found.

Errors

• If the specified model is defined in blocks but no model definition block exists, an error message is logged, and the function returns nothing.

• If the model with the given identifier is defined in blocks but missing in the model's definition, an error message is logged, and the function returns nothing.

Example

```julia params = Dict( "Models" => Dict( "Models" => Dict( "ModelA" => 42, "ModelB" => 24 ) ) )

model = "Models" id = "ModelA"

result = getmodelparameter(params, model, id) if result !== nothing println("Parameter id: result") else println("Parameter not found.") end

get_node_sets(params::Dict, path::String)

Returns the node sets from the parameters

Arguments

• params::Dict: The parameters
• path::String: The path to the mesh file

Returns

• nsets::Dict{String,Any}: The node sets

get_nsteps(params::Dict)

Get the fixed time step

Arguments

• params::Dict: The parameters dictionary.

Returns

• nsteps::Int64: The fixed time step

get_number_of_blocks(params::Dict)

Get the number of blocks.

Arguments

• params::Dict: The parameters

Returns

• number_of_blocks::Int64: The number of blocks

get_numerical_damping(params::Dict)

Get the numerical damping

Arguments

• params::Dict: The parameters dictionary.

Returns

• numerical_damping::Float64: The numerical damping

get_output_fieldnames(outputs::Dict, variables::Vector{String}, computes::Vector{String}, output_type::String)

Gets the output fieldnames.

Arguments

• outputs::Dict: The outputs
• variables::Vector{String}: The variables
• computes::Vector{String}: The computes
• output_type::String: The output type

Returns

• output_fieldnames::Vector{String}: The output fieldnames

get_output_filenames(params::Dict, output_dir::String)

Gets the output filenames.

Arguments

• params::Dict: The parameters
• output_dir::String: The file directory

Returns

• filenames::Vector{String}: The filenames

get_output_frequency(params::Dict, nsteps::Int64)

Gets the output frequency.

Arguments

• params::Dict: The parameters
• nsteps::Int64: The number of steps

Returns

• freq::Vector{Int64}: The output frequency

get_output_type(outputs::Dict, output::String)

Gets the output type.

Arguments

• outputs::Dict: The outputs
• output::String: The output

Returns

• output_type::String: The output type

get_output_variables(output::String, variables::Vector{String})

Get the output variable.

Arguments

• output::String: The output variable.
• variables::Vector{String}: The variables.

Returns

• output::String: The output variable.

get_outputs(params::Dict, variables::Vector{String}, compute_names::Vector{String})

Gets the outputs.

Arguments

• params::Dict: The parameters
• variables::Vector{String}: The variables
• compute_names::Vector{String}: The compute names

Returns

• outputs::Dict: The outputs

get_safety_factor(params::Dict)

Get the safety factor

Arguments

• params::Dict: The parameters dictionary.

Returns

• safety_factor::Float64: The safety factor

get_solver_name(params::Dict)

Get the name of the solver

Arguments

• params::Dict: The parameters dictionary.

Returns

• solver_name::String: The name of the solver

get_values(params::Dict, block_id::Int64, valueName::String, defaultValue::Union{Float64,Bool,Nothing})

Get the value of a block.

Arguments

• params::Dict: The parameters
• block_id::Int64: The ID of the block
• valueName::String: The name of the value
• defaultValue::Union{Float64,Bool,Nothing: The default value

Returns

• value::Float64: The value of the block

get_write_after_damage(outputs::Dict, output::String)

Get the write after damage.

Arguments

• outputs::Dict: The outputs
• output::String: The output

Returns

• write_after_damage::Bool: The value

validate_structure_recursive(expected::Dict, actual::Dict, validate::Bool, checked_keys::Array, path::String="")

Validates the parameters against the expected structure

Arguments

• expected::Dict: The expected structure
• actual::Dict: The actual structure
• validate::Bool: The validation results
• checked_keys::Array: The keys that have been checked
• path::String: The current path

Returns

• validate::Bool: The validation result
• checked_keys::Array: The keys that have been checked

validate_yaml(params::Dict)

Validates the parameters against the expected structure

Arguments

• params::Dict: The parameters dictionary.

Returns

• params::Dict: The parameters dictionary.