Utils

various utilities

allocfree_permutedims!(dest::AbstractArray{T1,N}, src::AbstractArray{T2,N}, perm::NTuple{N,Int}) where {T1,T2,N}

Copy data from src to dest with the dimensions permuted according to perm. The dest array is expected to be preallocated and have the same size as src after permutation. This function has the same functionality as permutedims!, but has much lower allocation overhead for views of arrays (there is still one allocation left somewhere...).

Example

```julia julia> src = rand(3, 4) julia> dest = zeros(10, 10) julia> allocfree_permutedims!(@view(dest[1:4,2:4]), src, (2, 1))

amdmkl(reset::Bool=false)

Create a modified libmkl_rt.so and libmkl_core.so to make MKL work fast on "Zen" AMD machines (e.g., Ryzen series). Solution is based on this forum post.

This function is only needed on AMD machines. In order to execute it, call amdmkl() in a separate Julia session (not in the same session where you want to run calculations). For example, your workflow could look like this:

> julia -e 'using ElemCo; ElemCo.amdmkl()'
> julia input.jl

where input.jl is your script that uses ElemCo.jl. The changes can be reverted by calling amdmkl(true).

argmaxN(vals, N; by::Function=identity)

Return the indices of the N largest elements in vals.

The order of equal elements is preserved. The keyword argument by can be used to specify a function to compare the elements, i.e., the function is applied to the elements before comparison.

Example

julia> argmaxN([1,2,3,4,5,6,7,8,9,10], 3)
3-element Vector{Int64}:
 10
  9
  8
julia> argmaxN([1,2,3,4,5,-6,-7,-8,-9,-10], 3; by=abs)
3-element Vector{Int64}:
 10
  9
  8
julia> argmaxN([1.0, 1.10, 1.112, -1.113, 1.09], 3; by=x->round(abs(x),digits=2))
3-element Vector{Int64}:
 3
 4
 2

draw_endline()

Print a line of ═.

draw_line(n = 63)

Print a thick line of n characters.

free_memory()

Return the amount of free memory in bytes.

kwarg_provided_in_macro(kwargs, key::Symbol)

Check whether key is in kwargs.

This is used in macros to check whether a keyword argument is passed. The keyword argument in question key is passed as a symbol, e.g. :thr. kwargs is the keyword argument list passed to the macro.

last_energy(energies::OutDict)

Return the last energy in energies.

mainname(file::String)

Return the main name of a file, i.e. the part before the last dot and the extension.

Examples:

julia> mainname("~/test.xyz")
("test", "xyz")

julia> mainname("test")
("test", "")

print_info(info::AbstractString, additional_info::AbstractString="")

Print info between two lines.

If additional not empty: additional info after main.

print_memory(EC::AbstractECInfo, mem1, info::AbstractString, verb::Int)

Print memory usage with message info if verbosity verb is smaller than PrintOptions.memory.

Note that memory is also used by other processes and the operating system, so the memory usage reported here is merely an estimate.

print_time(EC::AbstractECInfo, t1, info::AbstractString, verb::Int)

Print time with message info if verbosity verb is smaller than PrintOptions.time.

reshape_buf(buf::AbstractVector, dims...)

Reshape a buffer buf of type AbstractVector to the given dimensions dims.... The buffer is expected to be large enough to fit the reshaped data.

Example

```julia julia> buf = zeros(1000) julia> reshapedbuf = reshapebuf(buf, 10, 10)

subspace_in_space(subspace, space)

Return the positions of subspace in space (with respect to space)

subspace and space are lists of indices with respect to the full space (e.g., 1:norb).

Examples

julia> get_subspace_of_space([1,3,5], [1,3,4,5])
3-element Array{Int64,1}:
  1
  2 
  4

subspace_in_space(subspace::UnitRange{Int}, space::UnitRange{Int})

Return the positions of subspace in space (with respect to space)

subspace and space are ranges of indices with respect to the full space (e.g., 1:norb).

Examples

julia> get_subspace_of_space(4:6, 2:7)
3:5

substr(string::AbstractString, start::Int, len::Int=-1)

Return substring of string starting at start spanning len characters (including unicode). If len is not given, the substring spans to the end of string.

Example:

julia> substr("λabδcd", 2, 3)
"abδ"

substr(string::AbstractString, range::UnitRange{Int})

Return substring of string defined by range (including unicode).

Example:

julia> substr("λabδcd", 2:4)
"abδ"

warn(msg::AbstractString, err=false)

Print a warning message. If err is true, the message is printed as an error message.

The message is printed with a scull emoji.

Example

julia> warn("This is a warning message.")

xpath(xpath::AbstractString, node::Node)

Search for nodes matching the XPath xpath in the XML node. Returns a vector of nodes that match the XPath expression. If xpath is an empty string, it returns the node itself.

Supports basic XPath 1.0 syntax:

• /tag1/tag2 - absolute path from root (here: root == current node)
• tag1/tag2 - relative path from current node
• //tag - descendant-or-self axis (recursive search)
• / - root node (here: root == current node)
• * - any element node
• tag[@attr=value] - elements with specific attribute values

Examples:

• /node/child - child elements named 'child' under the root 'node'
• //item - all 'item' elements anywhere in the tree
• parent/child - 'child' elements that are direct children of 'parent'
• //variable[@name="x"] - variable elements with name attribute equal to "x"

OutDict

An ordered descriptive dictionary that maps keys of type String to values of type Float64.

@istoplevel

Macro to check if the current scope is the top level scope.

(from https://discourse.julialang.org/t/is-there-a-way-to-determine-whether-code-is-toplevel)

draw_thin_line(n = 63)

Print a thin line of n characters.

evaluate_predicate(predicate::AbstractString, node::Node)

Evaluate a predicate against a node. Currently supports:

• @attr=value

matches_predicates(node::Node, predicates::Vector{String})

Check if a node matches all given predicates.

parse_step_with_predicate(step::AbstractString)

Parse a step that may contain predicates like "tag[@attr=value]". Returns (tag_name, predicates) where predicates is a vector of predicate strings.

xspyder(xtag::AbstractString, node::Node)

Recursively search for nodes matching the xml tag xtag in the XML node. Returns a vector of nodes that match the tag. If xtag is an empty string, it returns the node itself.