List of all functions

deactivate_multithreading(cmd)

This deactivates multithreading

str = execute_command(command="ls")

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

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

This 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 returns a markdown summary

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)

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

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)

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.

data_Field = ArrayToTuple(data_Field)

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

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

data_out, isCell = ReadField_3D_pVTS(pvts, FieldName)

internal routine to read a 3D pvts file

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

changefolder()

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

clean_directory(DirName)

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

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

This compresses all LaMEM VTR files in a simulation.

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 )

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.

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

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

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

Reads a 3D LaMEM timestep from 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.

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.

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.

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

Returns the names of the datasets stored in FileName

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.

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

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 ϕ

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

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