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.

bond_component_size(datafield)

Returns the size of a single bond value, i.e. () for a scalar bond field, (dof,) for a vector one such as Deformed Bond Geometry, and (i_dof, j_dof) for a tensor one.

Bond fields are indexed as field[node][neighbor], the bond value being a number, an SVector or an SMatrix. Nodes without neighbours are skipped, so a boundary node cannot make a vector field look scalar.

Arguments

• datafield: The bond field, indexed by node

Returns

• ::Tuple: The component size

bond_element_id_offset(element_ids, n_bond_elements)

Returns the offset after which this rank numbers its bond elements: bond element ids start after all node elements and are then handed out rank by rank.

rank 0:  base + 1                          ... base + n_0
rank 1:  base + n_0 + 1                    ... base + n_0 + n_1
rank 2:  base + n_0 + n_1 + 1              ... base + n_0 + n_1 + n_2

base is the total number of nodes over all ranks, so the bond ids start behind the node elements. n_r is the bond count of rank r, obtained from an Allgather, so every rank can compute the sum of all lower ranks itself.

Points and FE elements take their global ids from loc_to_glob, because there is exactly one element per node. A node owns many bonds, so that map cannot be reused.

A directed bond i -> j is written only by the rank owning node i, so nothing has to be merged; the ranges only have to be disjoint.

Arguments

• element_ids::AbstractVector: Element ids already assigned on this rank, used as the base in the serial case and for the FE part
• n_bond_elements::Int64: Number of bond elements on this rank

Returns

• ::Int64: Offset for the first bond element id of this rank

bond_export_sizes(bond_blocks)

Returns the numbers needed by create_result_file for a given bond connectivity.

Arguments

• bond_blocks: Result of compute_bond_connectivity

Returns

• n_bond_elements::Int64: Total number of BAR2 elements
• n_bond_blocks::Int64: Number of additional element blocks

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

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

Arguments

• 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(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

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

check_block_selection(blocks, n_blocks)

Verifies that every index of a "Bond Blocks" selection refers to an existing block.

resolve_block_selection only parses; it has no idea which blocks exist. Without this check an out-of-range index is silently skipped by the export loop, and the user gets fewer bond blocks than asked for with no hint why.

Arguments

• blocks::Union{Nothing,AbstractVector{Int64}}: The parsed selection, nothing for all blocks
• n_blocks::Int64: Number of existing material blocks

Returns

• blocks: The unchanged input, so the call can be chained

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

compute_bond_connectivity(block_Id, n_blocks, nlist; blocks = nothing)

Builds the BAR2 connectivity for the bond export once, so that the element count used at initialisation, the connectivity written into the file, and the result values written per time step all follow the same ordering.

Bonds are directed, which is what the peridynamic data structure actually holds: nlist[i] containing j does not imply that nlist[j] contains i, and even when both exist they carry separate state (bond damage, bond forces and so on differ per direction). Each entry of each neighbourhood list therefore becomes its own BAR2 element, owned by the block of node i. Two elements on the same node pair are legal in exodusII; they simply overlap geometrically.

Bonds are owned by the block of node i, and only nodes this rank owns are iterated, so every directed bond exists exactly once across all ranks.

The partner j may be a responder node. Those bonds are written too, which is why the file has to contain the responder nodes as well; see init_write_results, where num_nodes counts them and num_owned_nodes does not.

A selected block with no local bonds is kept with zero elements. Which blocks are selected is the same on every rank, whether they hold bonds locally is not, and epu needs the same block structure in every per-rank file.

Arguments

• block_Id::AbstractVector{Int64}: Block id per owned node
• n_blocks::Int64: Number of material blocks
• nlist::AbstractVector: Neighbourhood list
• blocks: Optional subset of block indices to export bonds for

Returns

• bond_blocks::OrderedDict{Int64,BondBlock}: Block index -> bond block

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

Create and distribute the bond norm

Arguments

• comm::MPI.Comm: MPI communicator
• nlist::NestedNeighborhoodList: The global neighborhood list
• nlist_filtered_ids::NestedNeighborhoodList: The filtered neighborhood list
• distribution::Vector{Int64}: The distribution
• bond_norm::Vector{Float64}: The bond norm
• dof::Int64: The degree of freedom

create_bond_overlap_map!(overlap_map, nlist, distribution, rank)

Adds the flat bond indices exchanged between the ranks to the overlap map. A responder row only holds the bonds to neighbors that exist on its rank, in the order of the global neighborhood list. The owner of the node holds the full row, so for every rank it sends exactly these bonds ("Bond Controller"), and the responder receives its whole rows ("Bond Responder"). Indices refer to flatview of a bond field.

Arguments

• overlap_map: local overlap map, extended in place
• nlist::BondScalarState{Int64}: local neighborhood list
• distribution::Vector{Vector{Int64}}: global node ids of all ranks
• rank::Int64: this rank, starting at 1

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::NestedNeighborhoodList, 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::NestedNeighborhoodList: 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::NestedNeighborhoodList, 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::NestedNeighborhoodList: 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.

glob_to_loc(distribution)

Get the global to local mapping

Arguments

• distribution: The distribution

Returns

• create_global_to_local_mapping: The global to local mapping

create_neighborhoodlist(mesh::DataFrame, blocks::Dict{String,BlockParams}, scaling::Vector{Float64}, dof::Int64)

Create the neighborhood list of the mesh elements.

Arguments

• mesh::DataFrame: The input mesh data represented as a DataFrame.
• blocks::Dict{String,BlockParams}: The blocks of the input deck (horizon per block).
• scaling::Vector{Float64}: Horizon scaling per direction.
• 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, num_nodes, num_dim, num_elem_blks, num_node_sets,
                   num_elements = 0, FEtopology = nothing)

Creates an exodus file for the results.

Arguments

• filename::AbstractString: 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: Total number of element blocks (material + bond blocks)
• num_node_sets::Int64: The number of node sets
• num_elements::Int64: Number of additional elements (FE elements + bond elements)
• FEtopology::Union{Nothing,Matrix{Int64}}: FE topology, if a FE part is present

Keywords

• num_owned_nodes::Int64: Master nodes of this rank, one SPHERE element each. Defaults to num_nodes, which is right whenever the file holds no responder nodes.

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}})

Defines the node sets

Arguments

• nsets::Dict{String,Vector{Int64}}: Node sets read from files

delete_files(result_files::Vector{Dict})

Deletes the result files

Arguments

• result_files: The result files

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

Distributes the neighborhood list to the cores.

Arguments

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

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

Distributes the mesh data to the cores

Arguments

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

element_block_sizes(block_Id, n_blocks, bond_blocks)

Returns the number of elements per exodus block id, for both the material (SPHERE) blocks and the bond (BAR2) blocks.

Exodus.jl exposes no truth table API, so an element variable has to be written for every element block, not only for the bond blocks. This mapping supplies the lengths of the zero vectors used for the material blocks. Blocks with no local nodes are kept with a count of zero, because they exist in the file as well.

Arguments

• block_Id::AbstractVector{Int64}: Block id per node
• n_blocks::Int64: Number of material blocks
• bond_blocks::AbstractDict{Int64,BondBlock}: The bond blocks

Returns

• sizes::OrderedDict{Int64,Int64}: exodus block id -> number of elements

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::NestedNeighborhoodList: 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.

exodus_num_nodes(exo::ExodusDatabase)

Number of nodes the database was initialised with.

Exodus.jl carries the initialisation as type parameters, Initialization{num_dim, num_nodes, num_elems, num_elem_blks, num_node_sets, num_side_sets} — the same order create_result_file builds it in. There is no exported accessor, so the parameter is read off the type.

Arguments

• exo::ExodusDatabase: The exodus file

Returns

• ::Int64: Node count of the file

external_topology_file(d, path)

File name of the external element topology, or nothing. Aborts if the file does not exist in path.

extrude_surface_mesh(mesh::DataFrame, extrusion::Union{Nothing,SurfaceExtrusionParams})

extrude the mesh at the surface of the block

Arguments

• mesh::DataFrame: The input mesh data represented as a DataFrame.
• extrusion::Union{Nothing,SurfaceExtrusionParams}: The Surface Extrusion section, or nothing.

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

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

Returns

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

gather_bond_values(field, bond_block, dof)

Extracts the values of one bond variable in exactly the order of the bond connectivity.

field[node][neighbor] is the bond value: a number for a scalar field, an SVector for a vector field such as Deformed Bond Geometry and an SMatrix for a tensor field.

Arguments

• field: The bond field
• bond_block::BondBlock: The bond block
• dof: nothing for scalars, an Integer for vectors, a 2-element collection for tensors

Returns

• values::Vector{Float64}: One value per bond

get_block_nodes(block_Id::AbstractVector{Int64}, block::Int64)

Returns the nodes of a block as a 1 x n matrix, which is the layout exodusII expects for a SPHERE block (one node per element).

Arguments

• block_Id::AbstractVector{Int64}: The block Id
• block::Int64: The block

Returns

• nodes::Matrix{Int64}: The nodes of the block, shaped 1 x n

get_bond_geometry()

Gets the bond geometry

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,)

Get global values.

Arguments

• output::Dict: The output

Returns

• global_values::Vector: The global values

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_local_element_topology(topology::Vector{Vector{Int64}}, distribution::Vector{Int64})

Get the local element topology

Arguments

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

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::NestedNeighborhoodList)

Get the number of neighbors for each node.

Arguments

• nlist::NestedNeighborhoodList: 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(input::PeriLabInput, path::String)

Gets the results mapping

Arguments

• input::PeriLabInput: The typed input deck
• path::String: The path

Returns

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

global_value_avg(field::Union{NodeScalarField{Float64},NodeVectorField{Float64}}, dof::Union{Int64,Vector{Int64}}, nodes::AbstractVector{Int64})

Calculate the global average of a field for given nodes.

Arguments

• field::Union{NodeScalarField{Float64},NodeVectorField{Float64}}: Field.
• dof::Union{Int64,Vector{Int64}}: Degree of freedom
• nodes::AbstractVector{Int64}: Nodes.

Returns

• returnValue::Vector: Global value.

global_value_max(field::Union{NodeScalarField{Float64},NodeVectorField{Float64}}, dof::Union{Int64,Vector{Int64}}, nodes::AbstractVector{Int64})

Calculate the global maximum of a field for given nodes.

Arguments

• field::Union{NodeScalarField{Float64},NodeVectorField{Float64}}: Field.
• dof::Union{Int64,Vector{Int64}}: Degree of freedom
• nodes::AbstractVector{Int64}: Nodes.

Returns

• returnValue::Vector: Global value.

global_value_min(field::Union{NodeScalarField{Float64},NodeVectorField{Float64}}, dof::Union{Int64,Vector{Int64}}, nodes::AbstractVector{Int64})

Calculate the global minimum of a field for given nodes.

Arguments

• field::Union{NodeScalarField{Float64},NodeVectorField{Float64}}: Field.
• dof::Union{Int64,Vector{Int64}}: Degree of freedom
• nodes::AbstractVector{Int64}: Nodes.

Returns

• returnValue::Vector: Global value.

global_value_sum(field::Union{NodeScalarField{Float64},NodeVectorField{Float64},NodeTensorField{Float64}}, dof::Union{Int64,Vector{Int64}}, nodes::AbstractVector{Int64})

Calculate the global sum of a field for given nodes.

Arguments

• field::Union{NodeScalarField{Float64},NodeVectorField{Float64},NodeTensorField{Float64}}: Field.
• dof::Union{Int64,Vector{Int64}: Degree of freedom
• nodes::AbstractVector{Int64}: Nodes.

Returns

• returnValue::Vector: Global value.

init_bond_information_export(block_Id, n_blocks, nlist, parameter)

Convenience wrapper: evaluates the "Bond Export" parameter and returns the bond blocks together with the sizes required at initialisation.

Arguments

• block_Id::AbstractVector{Int64}: Block id per node
• n_blocks::Int64: Number of material blocks
• nlist::AbstractVector: Neighbourhood list
• parameter::Dict: Output parameter block, may contain "Bond Export" and "Bond Blocks" (whitespace separated indices, e.g. 1 3). Without "Bond Blocks" every block is exported.

Returns

• bond_blocks::OrderedDict{Int64,BondBlock}: Bond blocks (empty if disabled)
• n_bond_elements::Int64: Total number of BAR2 elements
• n_bond_blocks::Int64: Number of additional element blocks

init_data(input::PeriLabInput, path::String, comm::MPI.Comm)

Initializes the data for the mesh.

Arguments

• input::PeriLabInput: The typed input deck.
• path::String: The path to the mesh file.
• comm::MPI.Comm: The MPI communicator.

init_orientations(blocks::Dict{String,BlockParams})

Initialize orientations.

init_results_in_exodus(exo, dof, output, coords, block_Id, all_block_name_list,
                       nsets, global_ids, PERILAB_VERSION, qa_vector,
                       fem_block = nothing, topology = nothing,
                       elem_global_ids = nothing;
                       bond_blocks = ..., bond_output_names = String[],
                       bond_id_offset = -1)

Initializes the results in exodus.

Works with and without bond export: leaving both keywords out writes a plain nodal result file, exactly as before the bond export existed. The FE arguments keep their old positional places.

Arguments

• exo::ExodusDatabase: The exodus database
• dof: Degrees of freedom
• output::Dict: The output definition
• coords::Union{Matrix{Int64},Matrix{Float64}}: The coordinates
• block_Id::Vector{Int64}: The block Id per node
• all_block_name_list::Vector{String}: The block names
• nsets::Dict{String,Vector{Int64}}: The node sets
• global_ids::Vector{Int64}: The global ids
• PERILAB_VERSION::String: PeriLab version string
• qa_vector::Vector{String}: Additional QA records (at most 2 are stored)
• fem_block::Union{Nothing,Vector{Bool}}: Per-node flag marking FE nodes
• topology::Union{Nothing,Matrix{Int64}}: FE topology
• elem_global_ids::Union{Nothing,Vector{Int64}}: Global element ids for the FE part

Keywords

• bond_blocks: Bond blocks, see compute_bond_connectivity. Empty means no bond export.
• bond_output_names::Vector{String}: Names of the bond variables, written as element variables
• bond_id_offset::Int64: First bond element id minus one, from bond_element_id_offset. Negative means single rank, then the local maximum is used.

Returns

• exo::ExodusDatabase: The exodus file

init_write_results(input::PeriLabInput, output_dir::String, path::String, PERILAB_VERSION::String, qa_vector::Vector{String}, reuse::Bool)

Initialize write results.

Arguments

• input::PeriLabInput: The typed input deck
• output_dir::String: The output directory.
• path::String: The path
• PERILAB_VERSION::String: The PeriLab version
• qa_vector::Vector{String}: Additional QA records

Returns

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

initialize_data(filename, filedirectory, comm; no_strict = false, raw_deck = nothing)

Initialize data.

Arguments

• filename::String: The name of the input file.
• filedirectory::String: The directory of the input file.
• comm::MPI.Comm: The MPI communicator
• no_strict::Bool: Report unknown input keys as warnings instead of errors.
• raw_deck: The already parsed yaml file, if any (it is not parsed again).

Returns

• input::PeriLabInput: The typed input
• steps::Vector{Int64}: The solver steps

is_bond_field_type(field_type)

Returns whether a field type produced by Data_Manager.get_field_type describes a bond field.

Arguments

• field_type: The field type

Returns

• ::Bool: true for bond fields

load_and_evaluate_mesh(input::PeriLabInput, path::String, ranksize::Int64)

Load and evaluate the mesh data.

Arguments

• input::PeriLabInput: The typed input deck.
• path::String: The path to the mesh file.
• ranksize::Int64: The number of ranks.

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(create_global_to_local_mapping::Dict{Int,Int}, global_nodes::Vector{Int64})

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

Arguments

• create_global_to_local_mapping::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::AbstractString)

Merges the exodus file

Arguments

• file_name::AbstractString: 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, blocks::Dict{String,BlockParams}, scaling::Vector{Float64}, 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.
• blocks::Dict{String,BlockParams}: The blocks of the input deck (horizon per block).
• scaling::Vector{Float64}: Horizon scaling per direction.
• 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::NestedNeighborhoodList, size::Int64)

Create the distribution of the nodes.

Arguments

• nlist::NestedNeighborhoodList: 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

• The parsed yaml file (a Dict for a valid input deck)

read_input_deck(filename; directory = dirname(filename), no_strict = false,
                raw_deck = nothing)

Reads and validates the input deck; returns the typed PeriLabInput. raw_deck is the already parsed YAML of filename; if given, the file is not parsed again.

read_node_sets(d, path, mesh_df)

Node sets of the discretization: from an Exodus mesh, or from Node Sets entries (node id, id list, range a:b, coordinate expression in x/y/z, All, or a node set file).

resolve_block_selection(blocks)

Normalises the "Bond Blocks" entry into a list of block indices.

The entry is written as a plain, whitespace separated list of indices in the input deck, e.g. Bond Blocks: 1 3. A single index and an already parsed collection of integers are accepted as well. nothing or an empty entry means "all blocks".

Arguments

• blocks: The selection taken from the output parameters

Returns

• Union{Nothing,Vector{Int64}}: Block indices, or nothing for "all blocks"

set_angles(blocks::Dict{String,BlockParams})

Sets the node angles from the block angles of the input deck.

Arguments

• blocks::Dict{String,BlockParams}: The blocks of the input deck

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.

set_fallback_output_frequency(input::PeriLabInput, nsteps::Int64, step_id::Int64, dt::Float64, fallback_dt::Float64)

Sets the output frequencies and counters when a fallback solver with nsteps steps of fallback_dt takes over from steps of dt; see InputDeck.fallback_output_frequencies.

set_output_frequency(input::PeriLabInput, nsteps::Int64, step_id::Int64, reuse::Bool)

Sets the output frequency.

Arguments

• input::PeriLabInput: The typed input deck
• nsteps::Int64: The number of steps
• step_id::Int64: The step id

show_block_summary(models::Vector{String}, blocks::Dict{String,BlockParams}, log_file::String, silent::Bool, comm::MPI.Comm)

Show block summary.

Arguments

• models::Vector{String}: The model categories of the step
• blocks::Dict{String,BlockParams}: The blocks of the input deck
• log_file::String: The log file
• silent::Bool: The silent flag
• comm::MPI.Comm: The Comm_rank

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

Show MPI summary.

Arguments

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

split_output_fields(fields::Dict)

Splits an output field definition into its nodal, bond and global parts.

Arguments

• fields::Dict: The "Fields" entry of an output definition

Returns

• nodal::Dict, bond::Dict, global_::Dict

validate_input(params; directory = "", no_strict = false) -> (deck, input)

Validates a loaded input deck against the typed input declarations. Reports every problem at once and aborts if there is an error. Returns the params["PeriLab"] dict and the typed PeriLabInput.

write_bond_results_in_exodus(exo, step, output, bond_blocks, block_Id, n_blocks)

Writes the bond results in the exodus file, as element variables on the BAR2 blocks.

A bond can carry the same variable types as a point (scalar, vector, tensor); the component selection in output therefore follows the same "dof" / "i_dof" + "j_dof" convention as the nodal output. The values are gathered in the order of the bond connectivity, so bond k of a block always refers to the same element that was written at initialisation.

Because Exodus.jl offers no truth table, the same variable is also written to the material blocks — as zeros.

Arguments

• exo::ExodusDatabase: The exodus file
• step::Int64: The step
• output::Dict: The bond output definitions
• bond_blocks::AbstractDict{Int64,BondBlock}: The bond blocks
• block_Id::AbstractVector{Int64}: Block id per node
• n_blocks::Int64: Number of material blocks

Returns

• exo::ExodusDatabase: The exodus file

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)

Writes the nodal results in the exodus file

Arguments

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

Returns

• exo::ExodusDatabase: The exodus file

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

Write results.

Arguments

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

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

BondBlock

Holds everything needed to write one bond block, built once in compute_bond_connectivity.

The three fields are aligned column by column: bond k runs from nodes[k] to the second entry of conn[:, k], and corresponds to entry neighbor_index[k] of the owning node's neighbourhood list. Keeping the neighbour index around is what makes the result output reproduce exactly the order used for the connectivity — otherwise bond values and bond elements silently drift apart.

Bonds are directed, so the same node pair may appear twice, once per direction, each with its own values. The owning node is always conn[1, k].

Fields

• conn::Matrix{Int64}: 2 x n_bonds BAR2 connectivity
• nodes::Vector{Int64}: owning node of each bond
• neighbor_index::Vector{Int64}: position of the bond inside nlist[node]

Merges the options of several solver steps: a field is computed if any step asks for it.

active_computes(computes, field_keys)

The compute classes whose Variable is an existing field (directly or as <Variable>NP1); the others are skipped with a warning.

Names of the node sets of a boundary condition (Node Set joined with +).

Solver steps a boundary condition applies to, or nothing (all steps).

block_angles(name, block, dof)

Block rotation: nothing if Angle X is not given, Angle X in 2D, and [Angle X, Angle Y, Angle Z] in 3D (all three are required then).

block_by_id(blocks, block_id) -> (name, block)

The block with Block ID block_id.

block_names_and_ids(blocks, mesh_block_ids, mpi) -> (names, ids)

Names and IDs of the blocks present in the mesh, ordered by ID. Blocks of the input deck that are missing in the mesh are skipped (with a warning unless running under MPI).

The registered bond filter name, or nothing.

check_for_duplicates(filenames)

Check for duplicate filenames.

Arguments

• filenames::Vector{String}: The filenames

Names of the compute classes, sorted.

Sorted ids of all blocks that take part in a contact group.

Global search frequency of a contact group; falls back to Globals.

describe(name; template = false)
describe(io, name; template = false)

Prints the parameters of a section (e.g. "Solver") or a registered model (e.g. "Correspondence Plastic"). With template = true, prints a YAML block to copy into an input deck: required keys with a placeholder, optional keys commented out with their default; sections of named entries (e.g. "Blocks") get one placeholder entry.

end_time(s, current_time)

End time of the solver step: Final Time, or Additional Time after the current time.

fallback_output_frequencies(outputs, nsteps, step_id, frequencies, counters, dt, fallback_dt)

Output frequencies and counters, in values(outputs) order, when a fallback solver with nsteps steps of fallback_dt takes over from a solver with steps of dt and the given frequencies and counters. Fallback Number of Output Steps (which wins) and Fallback Output Frequency set the frequency like their counterparts; without them an output keeps its interval in time. The counter keeps the time since the last output. Frequencies are clamped to nsteps.

Polynomial degrees of the FEM elements as written: one value, or one per direction.

Gcode block assignment: block id => condition, or nothing.

generate_parameter_docs(dir)

Writes the input reference pages input_sections.md (the deck's sections) and input_models.md (shared keys and every registered model per category, plus the pre-calculation switches) into dir and returns their paths.

mesh_node_fields(d, directory)

Node fields the mesh of d defines before it is read: the header columns of a text mesh (e.g. Bulk_Modulus); nothing for Exodus meshes, whose nodal variables are only known once the mesh is read.

Horizon scaling per direction, 1.0 where not given.

Active model categories, in the order the models are evaluated.

output_fieldnames(variables, field_keys, compute_names, output_type)

The selected output variables as [name, "Constant"] or [name, "NP1"]. CSV outputs only take compute classes.

output_filenames(outputs, output_dir)

Result file names in values(outputs) order (.csv for CSV outputs, .e otherwise). Aborts if a name is used twice.

output_frequencies(outputs, nsteps, step_id)

Output frequency (write every n-th step) per output, in values(outputs) order. Number of Output Steps wins over Output Frequency; a value given as a string holds one entry per solver step; the result is clamped to nsteps.

parse_contact(raw, path, ctx)

Reads the Contact section: Globals (search settings for all contact models, defaults if absent) and the named contact models; contact models cannot be combined with +.

Typed models of section (e.g. "Material Models"), keyed by name; errors go to ctx.

parse_pre_calculation_switches(raw, path, ctx)

Pre-calculation switches (name: true/false); names are the registered pre-calculation models.

Typed models of section that cannot be combined with +.

read_input(deck, directory = ""; strict = true) -> (input, ctx)

Reads the content of the PeriLab: key of an input deck. directory is the deck's directory (for relative data files). All problems are collected in ctx; input is nothing if any of them is an error. Does not abort — call ParameterSpec.report!(ctx) for that.

register_bond_filter(name, run; required = String[])

Makes bond filter name available as Type of a Bond Filters entry. run is called as run(nnodes, data, filter::BondFilterParams, nlist, dof) and returns the bond flags and the filter normal. required lists the BondFilterParams keys the filter needs (Z components only in 3D are checked by the filter itself). Call it from the filter module's __init__().

Registered name of the solver whose options are o.

Solver parameters of step step_id (-1: the single Solver).

Step IDs to run, sorted; [-1] for a single Solver.

start_time(s, current_time)

Start time of the solver step: Initial Time, or the current time if that is later or Initial Time is not given (later steps of a multistep run).

A value given per solver step as a string ("n1 n2") is the entry of step_id.

to_json_schema(PeriLabInput)

JSON Schema (draft 2020-12) of an input deck, generated from the @params declarations and the registered models (installed and licensed modules). Model entries list the category's shared keys; the keys of a single named model are added for exactly that name (models combined with + are checked only for the shared keys).

A registered bond filter: the YAML keys its Type needs and the function that applies it.

Which stress and strain fields the models compute.

ContactInput

The typed Contact section: globals and the contact models by name, each a ParameterSpec.WithBase (shared keys in base, the model's own keys in model, its Type in name).

FallbackParams

The solver that takes over when a step of the main solver fails; it recomputes the failed step and runs to the final time of the solver step.

PeriLabInput

A validated input deck. materials holds the typed material models (ParameterSpec.WithBase), keyed by name; damages, additives and degradations hold the typed damage, additive and degradation models; thermals the typed thermal models (WithBase); pre_calculation_global and pre_calculations the pre-calculation switches; globals is the unvalidated Globals escape hatch.

SolverOptions

Options section of one solver. A solver module declares @params struct MyParams <: SolverOptions (explicit solvers by convention with safety_factor, fixed_dt (-1 if not given) and numerical_damping) and registers it with register_solver(name, MyParams) in its __init__(); the input deck names the solver by that key inside Solver or a Multistep Solver step.

Used for Solver and for every step of Multistep Solver.