List of all functions

These are all functions that are available in the package, which can roughly be divided into two groups (running & reading LaMEM)

Julia interface to LaMEM

Running LaMEM

LaMEM.Run.deactivate_multithreading Method

deactivate_multithreading(cmd)

This deactivates multithreading

source

LaMEM.Run.execute_command Function

str = execute_command(command="ls")

Executes a command-line code and returns the output as a string

source

LaMEM.Run.extract_info_logfile Method

value = extract_info_logfile(lines, keyword::String; entry=1, LaMEM=true)

Internal function to extract information from the logfile

Note that the LaMEM keywords should contain ":" at the end, while the PETSc keywords should not, but we have to indicate the entry number for the PETSc keywords. Example LaMEM keyword:

julia> val = extract_info_logfile(lines, "Fine grid cells [nx, ny, nz]         :")
"[512, 256, 256]"

Example PETSc keyword:

julia> coarse_grid_solve = extract_info_logfile(lines, "MGSmooth Level 0", LaMEM=false, entry=3)
9.9174

source

LaMEM.Run.read_LaMEM_logfile Method

read_LaMEM_logfile(Filename::String; ID=nothing, header=true)

Reads a LaMEM logfile (provided it was run with "-log_view") and collects key results from it; mostly for scalability tests on HPC machines. It prints a markdown summary table with grid sizes, core counts, multigrid levels, solver iterations, and timing information.

You can also pass a vector of filenames to compare multiple runs:

julia> read_LaMEM_logfile(["logfile_64cpu_1234.out", "logfile_128cpu_5678.out"])

source

LaMEM.Run.remove_popup_messages_mac Method

remove_popup_messages_mac()

On a Mac with firewall enabled, running LaMEM will result in a popup window that says: "Accept incoming connections" which you should Allow or Deny. This is a bit annoying, so this julia script fixes that. Note that you must have administrator rights on your machine as we need to run "sudo"

Run this script from the terminal with

julia> remove_popup_messages_mac()

You need to do this once (every time a new version is installed)

source

LaMEM.Run.run_lamem Function

run_lamem(ParamFile::String, cores::Int64=1, args:String=""; wait=true, deactivate_multithreads=true)

This starts a LaMEM simulation, for using the parameter file ParamFile on cores number of cores. Optional additional command-line parameters can be specified with args.

Example:

You can call LaMEM with:

julia> using LaMEM
julia> ParamFile="../../input_models/BuildInSetups/FallingBlock_Multigrid.dat";
julia> run_lamem(ParamFile)

Do the same on 2 cores with a command-line argument as:

julia> ParamFile="../../input_models/BuildInSetups/FallingBlock_Multigrid.dat";
julia> run_lamem(ParamFile, 2, "-nstep_max = 1")

source

LaMEM.Run.run_lamem_save_grid Function

ProcessorPartFile = run_lamem_save_grid(ParamFile::String, cores::Int64=1; verbose=true, directory=pwd())

This calls LaMEM simulation, for using the parameter file ParamFile and creates processor partitioning file "ProcessorPartitioning_Xcpu_X.Y.Z.bin" for {X} number of cores.

Example:

julia> using LaMEM
julia> ParamFile="../../input_models/BuildInSetups/FallingBlock_Multigrid.dat";
julia> ProcessorPartFile = run_lamem_save_grid(ParamFile, 2)

source

LaMEM.Run.show_paths_LaMEM Method

show_paths_LaMEM()

The downloaded LaMEM binaries can also be called from outside julia (directly from the terminal). In that case, you will need to set load correct dynamic libraries (such as PETSc) and call the correct binaries.

This function shows this for your system.

source

Reading LaMEM output back into julia

LaMEM.IO_functions.ArrayToTuple Method

data_Field = ArrayToTuple(data_Field)

Transfers a 3D array (n>1) to a tuple of length n.

source

LaMEM.IO_functions.ReadField_3D_pVTR Method

output, isCell = ReadField_3D_pVTR(data, FieldName::String)

Extracts a 3D data field from a pVTR data structure data

Input:

• data: Data structure obtained with Read_VTR_File

• FieldName: Exact name of the field as specified in the *.vtr file

Output:

• data_field, isCell: 3D field with data, and a flag that indicates whether it is Cell data (PointData otherwise) data_field is a tuple of size 1, or 3 depending on whether it is a scalar or vector field

source

LaMEM.IO_functions.ReadField_3D_pVTS Method

data_out, isCell = ReadField_3D_pVTS(pvts, FieldName)

internal routine to read a 3D pvts file

source

LaMEM.IO_functions.ReadField_3D_pVTU Method

output, isCell = ReadField_3D_pVTU(data, FieldName::String)

Extracts a 3D data field from a pVTU data structure data Input:

• data: Data structure obtained with Read_VTR_File

• FieldName: Exact name of the field as specified in the *.vtr file

Output:

• data_field: Array with data, data_field is a tuple of size 1, 3 or 9 depending on whether it is a scalar, vector or tensor field

source

LaMEM.IO_functions.changefolder Method

changefolder()

Starts a GUI on Windowss or Mac machines, which allows you to change our working directory

source

LaMEM.IO_functions.clean_directory Function

clean_directory(DirName)

Removes all LaMEM timesteps & *.pvd files from the directory DirName

source

LaMEM.IO_functions.compress_pvd Method

compress_pvd(filename_pvd::String; Dir=pwd(), delete_original_files=false)

This compresses all LaMEM VTR files in a simulation.

source

LaMEM.IO_functions.compress_vtr_file Method

filename_compressed::String =  compress_vtr_file(filename::String; Dir=pwd(), delete_original_files=false)

Compresses a LaMEM VTR file (loads parallel files & save them again )

source

LaMEM.IO_functions.passivetracer_time Function

PT = passivetracer_time(ID::Union{Vector{Int64},Int64}, FileName::String, DirName::String="")

This reads passive tracers with ID from a LaMEM simulation, and returns a named tuple with the temporal evolution of these passive tracers. We return x,y,z coordinates and all fields specified in the FileName for particles number ID.

source

LaMEM.IO_functions.project_onto_crosssection Method

data_projected = project_onto_crosssection(data::CartData, Cross::CartData)

This function is helpful if you used the cross_section routine of the GeophysicalModelGenerator package to create a 2D cross-section through a 3D model, which "flattens" the cross-section to a 2D model. If you later want to visualize the LaMEM model results in the original 3D context (along with topography, for example), you need to project the 2D model back onto the 3D model. This function does that.

source

LaMEM.IO_functions.project_onto_crosssection Method

project_onto_crosssection(simulation_name::String, Cross::CartData)

Reads the output of a LaMEM simulation and projects it onto a 2D cross-section Cross

source

LaMEM.IO_functions.readPVD Method

FileNames, Time, Timestep = readPVD(FileName::String)

This reads a PVD file & returns the FileNames, Time and Timesteps

source

LaMEM.IO_functions.read_LaMEM_PVTR_file Method

data_output = read_LaMEM_PVTR_file(DirName, FileName; fields=nothing)

Reads a 3D LaMEM timestep from a parallel VTR file FileName, located in directory DirName. By default, it will read all fields. If you want you can only read a specific field. See the function fieldnames to get a list with all available fields in the file.

It will return data_output which is a CartData output structure.

source

LaMEM.IO_functions.read_LaMEM_PVTS_file Method

data_output = read_LaMEM_PVTS_file(DirName, FileName; field=nothing)

Reads a 3D LaMEM timestep from VTS file FileName, located in directory DirName. Typically this is done to read passive tracers back into julia. By default, it will read all fields. If you want you can only read a specific field. See the function fieldnames to get a list with all available fields in the file.

It will return data_output which is a CartData output structure.

source

LaMEM.IO_functions.read_LaMEM_PVTU_file Method

data_output = read_LaMEM_PVTU_file(DirName, FileName; fields=nothing)

Reads a 3D LaMEM timestep from VTU file FileName, located in directory DirName. Typically this is done to read passive tracers back into julia. By default, it will read all fields. If you want you can only read a specific field. See the function fieldnames to get a list with all available fields in the file.

It will return data_output which is a CartData output structure.

source

LaMEM.IO_functions.read_LaMEM_VTR_file Method

data_output = read_LaMEM_VTR_file(DirName, FileName; fields=nothing, verbose=false)

Reads a 3D LaMEM timestep from VTR or VTS file FileName, located in directory DirName. By default, it will read all fields. If you want you can only read a specific field. See the function fieldnames to get a list with all available fields in the file.

It will return data_output which is a CartData output structure.

source

LaMEM.IO_functions.read_LaMEM_fieldnames Function

read_LaMEM_fieldnames(FileName::String, DirName_base::String=""; phase=false, surf=false, tracers=false)

Returns the names of the datasets stored in FileName

source

LaMEM.IO_functions.read_LaMEM_simulation Function

Timestep, FileNames, Time = read_LaMEM_simulation(FileName::String, DirName::String=""; phase=false, surf=false, passive_tracers=false)

Reads a LaMEM simulation FileName in directory DirName and returns the timesteps, times and filenames of that simulation.

source

LaMEM.IO_functions.read_LaMEM_timestep Function

data, time = read_LaMEM_timestep(FileName::String, TimeStep::Int64=0, DirName::String=""; fields=nothing, phase=false, surf=false, last=false)

This reads a LaMEM timestep.

Input Arguments:

• FileName: name of the simulation, w/out extension

• Timestep: timestep to be read, unless last=true in which case we read the last one

• DirName: name of the main directory (i.e. where the *.pvd files are located)

• fields: Tuple with optional fields; if not specified all will be loaded

• phase: Loads the phase information of LaMEM if true

• surf: Loads the free surface of LaMEM if true

• passive_tracers: Loads passive tracers if true

• last: Loads the last timestep

Output:

• data: Cartesian data struct with LaMEM output

• time: The time of the timestep

source

LaMEM.IO_functions.read_phase_diagram Method

out = read_phase_diagram(name::String)

Reads a phase diagram from a file name and returns a NamedTuple with temperature T, pressure P, melt density ρ_melt, solid density ρ_solid, density ρ and melt fraction ϕ

source

LaMEM.IO_functions.split_path_name Method

dir, file = split_path_name(DirName_base::String, FileName::String)

Routine that splits the name in a directory DirName_base and a filename FileName

source