NXRefine 0.1.1__py3-none-any.whl

nxrefine/__init__.py

@@ -0,0 +1,9 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2022, Argonne National Laboratory.
+#
+# Distributed under the terms of an Open Source License.
+#
+# The full license is in the file LICENSE.pdf, distributed with this software.
+# -----------------------------------------------------------------------------
+
+from ._version import version as __version__

nxrefine/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
+
+__commit_id__ = commit_id = None

nxrefine/julia/GeneralMK3D.jl

@@ -0,0 +1,258 @@
+
+# functions: nablasq_3d_grid, return_boundary_nodes, 
+# return_boundary_nodes_3D, punch_holes_nexus_Cartesian, 
+# Matern_3d_Grid, Laplace_3D_grid,
+# parallel_Matern_3DGrid, parallel_Laplace_3Dgrid
+
+# Internal settings for caching
+mutable struct Settings
+  A_matrix_STORE_MAX::Int64
+end
+
+# There may be up to 15 A_matrices for a 3d grid
+const SETTINGS = Settings(15) 
+
+# Dict for storing A_matrices
+const A_matrix = Dict{Tuple{Int64, Int64, Int64, Int64, Float64, Float64, Float64,
+                            Float64}, Matrix{Float64}}()
+"""
+  nablasq_3d_grid(Nx,Ny)
+
+Construct the 3D Laplace matrix
+
+# Arguments
+  - `Nx::Int64`: The number of nodes in the first dimension
+  - `Ny::Int64`: The number of nodes in the second dimension
+  - `Nz::Int64`: The number of nodes in the third dimension
+  - `h::Float64`: Grid spacing in the first dimension
+  - `k::Float64`: Grid spacing in the second dimension
+  - `l::Float64`: Grid spacing in the third dimension
+
+# Outputs 
+
+  - `-nablasq` (discrete Laplacian, real-symmetric positive-definite) on Nx×Ny×Nz grid
+
+"""
+function nablasq_3d_grid(Nx, Ny, Nz, h, k, l)
+    #haskey(A_matrix, (Nx, Ny, Nz, 1, 0.0, h, k, l)) && return A_matrix[(Nx, Ny, Nz, 1, 0.0, h, k, l)]
+    o₁ = ones(Nx) / h
+    del1 = spdiagm_nonsquare(Nx + 1, Nx, -1 => -o₁, 0 => o₁)
+    o₂ = ones(Ny) / k
+    del2 = spdiagm_nonsquare(Ny + 1, Ny, -1 => -o₂,0 => o₂)
+    O3 = ones(Nz) / l
+    del3 = spdiagm_nonsquare(Nz + 1, Nz, -1 => -O3, 0 => O3)
+    A3D = (kron(sparse(I, Nz, Nz), sparse(I, Ny, Ny), del1'*del1) + 
+            kron(sparse(I, Nz, Nz), del2' * del2, sparse(I, Nx, Nx)) + 
+            kron(del3' * del3, sparse(I, Ny, Ny), sparse(I, Nx, Nx)))
+    BoundaryNodes, xneighbors, yneighbors, zneighbors = 
+            return_boundary_nodes(Nx, Ny, Nz)
+    count = 1
+    for i in BoundaryNodes
+        A3D[i, i] = 0.0
+        A3D[i, i] = A3D[i, i] + xneighbors[count] / h ^ 2 + 
+                     yneighbors[count] / k ^ 2 + zneighbors[count] / l ^ 2
+        count = count + 1
+    end
+    #length(A_matrix) <  SETTINGS.A_matrix_STORE_MAX && (A_matrix[(Nx, Ny, Nz, 1, 0.0, h, k, l)] = A3D)
+    #if length(A_matrix) == SETTINGS.A_matrix_STORE_MAX
+    #  @warn "A_matrix cache full, no longer caching Laplace interpolation matrices."
+    #end
+    return A3D
+end
+
+""" Helper function to give the matern matrix """
+function _Matern_matrix(Nx, Ny, Nz, m, eps, h, k, l)
+    #haskey(A_matrix, (Nx, Ny, Nz, m, eps, h, k, l)) && return A_matrix[(Nx, Ny, Nz, m, eps, h, k, l)]
+    A3D = nablasq_3d_grid(Nx, Ny, Nz, h, k, l) 
+    sizeA = size(A3D, 1)
+    for i = 1:sizeA
+        A3D[i, i] = A3D[i, i] + eps^2
+    end
+    A3DMatern = A3D^m
+    #length(A_matrix) <  SETTINGS.A_matrix_STORE_MAX && (A_matrix[(Nx, Ny, Nz, m, eps, h, k, l)] = A3DMatern)
+    #if length(A_matrix) == SETTINGS.A_matrix_STORE_MAX
+    #  @warn "A_matrix cache full, no longer caching Laplace interpolation matrices."
+    #end
+    A3DMatern
+end
+
+"""
+
+  matern_3d_grid(imgg, discard, m, eps, h, k, l)
+
+Interpolates a single punch
+
+...
+# Arguments
+  - `imgg`: the matrix containing the image
+  - `discard::Union{Vector{CartesianIndex{3}}}, Vector{Int64}}`: the linear or 
+       Cartesian indices of the values to be filled 
+  - `m::Int64 = 1` : Matern parameter 
+  - `eps::Float64 = 0.0`: Matern parameter eps
+  - `h = 1.0`: Aspect ratio in the first dimension
+  - `k = 1.0`: Aspect ratio in the second dimension
+  - `l = 1.0`: Aspect ratio in the third dimension 
+
+# Outputs
+  - array containing the restored image
+...
+
+"""
+function matern_3d_grid(imgg, discard::Union{Vector{CartesianIndex{3}}, Vector{Int64}},
+                m::Int64 = 1,  eps::Float64 = 0.0, 
+                h = 1.0, k = 1.0, l = 1.0) 
+    Nx, Ny, Nz = size(imgg)
+    A3D = (eps == 0.0)&&(m == 1) ? 
+                nablasq_3d_grid(Nx, Ny, Nz, h, k, l) :
+                _Matern_matrix(Nx, Ny, Nz, m, eps, h, k, l) 
+    totalsize = Nx * Ny * Nz
+    C = sparse(I, totalsize, totalsize)
+    rhs_a = copy(imgg)[:]
+    for i in discard
+        j = (typeof(i) <: CartesianIndex) ? LinearIndices(imgg)[i] : i
+        C[j, j] = 0.0
+        rhs_a[j] = 0.0
+    end
+    Id = sparse(I, totalsize, totalsize)    
+    u = ((C - (Id - C) * A3D)) \ rhs_a
+    return reshape(u, Nx, Ny, Nz)
+end
+
+# Add m pixels around the punch and then intersect with the size of the full
+# image (3D only)
+function pad_intersect(discard, m, Nx, Ny, Nz)
+    B = bounding_box(discard)
+    fi, li = (first(B) - CartesianIndex(m, m, m), last(B) + CartesianIndex(m, m, m))
+    return intersect_box(fi:li, CartesianIndices((Nx,Ny,Nz)))
+end
+
+function get_Qw_maxmin(wpoints)
+    Qw_min, Qw_max = (Int64(floor(minimum(wpoints))), Int64(ceil(maximum(wpoints))))
+end
+
+"""
+
+  matern_w_punch(imgg, Qh_min, Qh_max, Qk_min, Qk_max, Ql_min, Ql_max, m, eps, h, k, l, symm)
+
+Interpolate, in serial, multiple punches
+
+...
+# Arguments
+  - `imgg`: the matrix containing the image
+  - ` Qh_min, Qh_max, Qk_min, Qk_max, Ql_min, Ql_max::Int64`: the extents in h,k,l resp 
+  - `m::Int64 = 1` : Matern parameter 
+  - `eps::Float64 = 0.0`: Matern parameter eps
+  - `h = 1.0`: Aspect ratio in the first dimension
+  - `k = 1.0`: Aspect ratio in the second dimension
+  - `l = 1.0`: Aspect ratio in the third dimension 
+
+# Outputs
+  - array containing the interpolated image
+
+# Example
+
+```<julia-repl>
+h = k = l = 1.0
+symm = 'A'
+Nx = Ny = Nz = 61
+radius = (0.5, 0.5, 0.5 )
+Qh_min = Qk_min = Ql_min = -3.0
+Qh_max = Qk_max = Ql_max = 3.0
+xpoints = ypoints = zpoints = LinRange(Qh_min, Qh_max, Nx)
+imgg = rand(Nx, Ny, Nz)
+m = 1
+eps = 0.0
+interp = matern_w_punch(imgg, #Qh_min, Qh_max, Qk_min, Qk_max, Ql_min, Ql_max, radius,
+                      radius, xpoints, ypoints, zpoints, m, eps, 
+                      h, k, l, symm);
+```
+
+...
+"""
+function matern_w_punch(imgg, radius, xpoints, ypoints, zpoints,
+                        m = 1, eps = 0.0, h = 1.0, k = 1.0, l = 1.0, symm = 'G';
+                        return_punch_locs = false)
+    Qh_min, Qh_max = get_Qw_maxmin(xpoints)
+    Qk_min, Qk_max = get_Qw_maxmin(ypoints)
+    Ql_min, Ql_max = get_Qw_maxmin(zpoints)
+    radius_x, radius_y, radius_z = (typeof(radius) <: Tuple) ? radius : 
+                                                (radius, radius, radius)
+    dx, dy, dz = (xpoints[2] - xpoints[1], ypoints[2] - ypoints[1], 
+                  zpoints[2] - zpoints[1])
+    rpx, rpy, rpz = (Int64(round(radius_x/dx)) + m, Int64(round(radius_y/dy)) + m,
+                  Int64(round(radius_z/dz))+ m)
+    Nx, Ny, Nz = (length(xpoints), length(ypoints), length(zpoints))
+    new_imgg = copy(imgg);
+    exclusion_rule = center_check(symm)
+    # find the first center
+    (cpx, cpy, cpz) = (findmin(abs.(xpoints .- Qh_min))[2], 
+                                  findmin(abs.(ypoints .- Qk_min))[2],
+                                  findmin(abs.(zpoints .- Ql_min))[2])
+    stridex, stridey, stridez = (-cpx, -cpy, -cpz) .+ (findmin(abs.(xpoints .- (Qh_min + 1)))[2], 
+                                  findmin(abs.(ypoints .- (Qk_min + 1)))[2],
+                                  findmin(abs.(zpoints .- (Ql_min + 1)))[2])
+    punch_locs = return_punch_locs ? ones(Int64, size(imgg)) : nothing
+    # Threads.@threads for c in centers
+    for (ih, h) in enumerate(Qh_min:Qh_max) 
+        minpx = maximum([1, cpx + (ih - 1) * stridex - rpx])
+        maxpx = minimum([cpx + (ih - 1) * stridex + rpx, Nx])
+        for (ik, k) in enumerate(Qk_min:Qk_max) 
+            minpy = maximum([1, cpy + (ik - 1) * stridey - rpy])
+            maxpy = minimum([cpy + (ik - 1) * stridey + rpy, Ny])
+            for (il, l) in enumerate(Ql_min:Ql_max)
+                minpz = maximum([1, cpz + (il - 1) * stridez - rpz])
+                maxpz = minimum([cpz + (il - 1) * stridez + rpz, Nz])
+                if exclusion_rule(h, k, l)
+                    d = punch_3D_cart((h,k,l), radius, xpoints[minpx:maxpx], 
+                                      ypoints[minpy:maxpy], 
+                                      zpoints[minpz:maxpz])
+                    # Interpolate
+                    new_imgg[minpx:maxpx, minpy:maxpy, minpz:maxpz] = matern_3d_grid(
+                                imgg[minpx:maxpx, minpy:maxpy, minpz:maxpz], d, m, 
+                                eps, h, k, l);
+                    if return_punch_locs
+                      punch_locs[d] .= 0
+                    end
+                end
+            end
+        end
+    end
+    if return_punch_locs
+      return new_imgg, punch_locs
+    else
+      return new_imgg
+    end
+end
+# function matern_w_punch(imgg, Qh_min, Qh_max, Qk_min, Qk_max, Ql_min, Ql_max, radius,
+                      # xpoints, ypoints, zpoints,
+                        # m = 1, eps = 0.0, h = 1.0, k = 1.0, l = 1.0, symm = 'G')
+    # centers = center_list(symm, Qh_min, Qh_max, Qk_min, Qk_max, Ql_min, Ql_max)
+    # radius_x, radius_y, radius_z = (typeof(radius) <: Tuple) ? radius : 
+                                                # (radius, radius, radius)
+    # dx, dy, dz = (xpoints[2] - xpoints[1], ypoints[2] - ypoints[1], 
+                  # zpoints[2] - zpoints[1])
+    # rpx, rpy, rpz = (Int64(round(radius_x/dx)), Int64(round(radius_y/dy)),
+                  # Int64(round(radius_z/dz)))
+    # Nx, Ny, Nz = (length(xpoints), length(ypoints), length(zpoints))
+    # new_imgg = copy(imgg);
+    # # Threads.@threads for c in centers
+    # for c in centers
+        # (cpx, cpy, cpz) = (findmin(abs.(xpoints .- c[1]))[2], 
+                                      # findmin(abs.(ypoints .- c[2]))[2],
+                                      # findmin(abs.(zpoints .- c[3]))[2])
+        # minpx, minpy, minpz = (maximum([1, cpx - (rpx + m)]), 
+                               # maximum([1, cpy - (rpy + m)]), 
+                               # maximum([1, cpz - (rpz + m)]))
+        # maxpx, maxpy, maxpz = (minimum([Nx, cpx + (rpx + m)]),
+                               # minimum([Ny, cpy + (rpx + m)]),
+                               # minimum([Nz, cpz + (rpz + m)]))
+        # d = punch_3D_cart(c, radius, xpoints[minpx:maxpx], ypoints[minpy:maxpy], 
+                          # zpoints[minpz:maxpz])
+        # # Interpolate
+        # new_imgg[minpx:maxpx, minpy:maxpy, minpz:maxpz] = matern_3d_grid(
+                    # imgg[minpx:maxpx, minpy:maxpy, minpz:maxpz], d, m, eps, h, k, l);
+    # end
+    # return new_imgg
+# end
+
+

nxrefine/julia/LaplaceInterpolation.jl

@@ -0,0 +1,25 @@
+module LaplaceInterpolation
+
+  using LinearAlgebra, SparseArrays
+
+  include("Matern1D2D.jl")
+  export nablasq_grid, bdy_nodes, matern_1d_grid, matern_2d_grid 
+
+  include("GeneralMK3D.jl")
+  export nablasq_3d_grid, matern_3d_grid, matern_w_punch
+
+  include("MaternKernelApproximation.jl")
+  export spdiagm_nonsquare, return_boundary_nodes
+  export Matern3D_Grid, Parallel_Matern3D_Grid
+
+  include("punch.jl")
+  export punch_holes_3D, punch_holes_2D, punch_3d_cart, center_list 
+
+  include("nexus.jl")
+  # These functions are unexported
+
+  # Only works with juliia v 1.6 and higher
+  include("arbitrary_dim.jl")
+  export nablasq_arb, interp
+
+end

nxrefine/julia/Matern1D2D.jl

@@ -0,0 +1,229 @@
+
+# Helper code
+
+"""
+  spdiagm_nonsquare(m, n, args...)
+
+Construct a sparse diagonal matrix from Pairs of vectors and diagonals. Each
+vector arg.second will be placed on the arg.first diagonal. By default (if
+size=nothing), the matrix is square and its size is inferred from kv, but a
+non-square size m×n (padded with zeros as needed) can be specified by passing
+m,n as the first arguments.
+
+# Arguments
+  - `m::Int64`: First dimension of the output matrix
+  - `n::Int64`: Second dimension of the output matrix
+  - `args::Tuple{T} where T<:Pair{<:Integer,<:AbstractVector}` 
+
+# Outputs 
+
+  - sparse matrix of size mxn containing the values in args 
+
+"""
+function spdiagm_nonsquare(m, n, args...)
+    I, J, V = SparseArrays.spdiagm_internal(args...)
+    return sparse(I, J, V, m, n)
+end
+
+# One-dimensional codes
+
+""" 
+    nablasq_grid(n, h)
+
+Laplacian matrix on a 1D grid
+
+# Arguments:
+    - `n`: Number of points
+    - `h`: Aspect ratio
+
+# Outputs:
+    - discrete Laplacian matrix
+"""
+function nablasq_grid(n::Int64, h::Float64 = 1.0)
+  o = ones(n) / h
+  del = spdiagm_nonsquare(n + 1, n, -1 => -o, 0 => o)
+  A1D = del' * del
+  A1D[1, 1] = 1.0 / h ^ 2
+  A1D[n, n] = 1.0 / h ^ 2
+  return A1D
+end
+
+""" 
+
+   matern_1d_grid(y, idx, m, eps, h)
+
+Matern Interpolation in one dimension
+
+# Arguments:
+  - `y`: the vector of y's for which the values are known
+  - `idx`: the vector of indices for which values are to be interpolated
+  - `m::Int64 = 1`: Matern parameter m
+  - `eps = 0.0`: Matern parameter eps
+  - `h = 1.0`: aspect ratio
+
+# Outputs:
+  - vector of interpolated data
+
+# Example:
+```<julia-repl>
+x = 1:100
+h = x[2] - x[1]
+y = sin.(2 * pi * x * 0.2)
+discard = randperm(100)[1:50]
+# Laplace interpolation
+y_lap = matern_1d_grid(y, discard, 1, 0.0, h)
+# Matern interpolation
+y_mat = matern_1d_grid(y, discard, 2, 0.1, h)
+```
+  
+"""
+function matern_1d_grid(y::Vector{T}, idx::Vector{Int64}, 
+                        m::Int64 = 1, eps = 0.0, h::Float64 = 1.0) where{T<:Number}
+  n = length(y)
+  A1D = nablasq_grid(n, h)
+  C = sparse(I, n, n)
+  for i in idx
+    C[i, i] = 0.0
+  end
+  if ((eps == 0)||(eps == 0.0)) && (m == 1)
+    # Laplace Interpolation
+    return ((C - (sparse(I, n, n) - C) * A1D)) \ (C * y)
+  else
+    # Matern Interpolation
+    for i = 1:size(A1D,1)
+      A1D[i, i] = A1D[i, i] + eps^2
+    end
+    A1DM = A1D ^ m
+    return ((C - (sparse(I, n, n) - C) * A1DM)) \ (C * y)
+  end
+end
+
+# Two dimensional codes
+
+"""
+  bdy_nodes(Nx, Ny)
+
+...
+# Arguments
+
+  - `Nx::Int64`: the number of points in the first dimension
+  - `Ny::Int64`: the number of points in the second dimension
+...
+
+...
+# Outputs
+  - vector containing the indices of coordinates on the boundary of the 2D rectangle
+...
+
+"""
+function bdy_nodes(Nx, Ny)
+  bdy = []
+  xnb = []
+  ynb = []
+  counter = 0
+      for j = 1:Ny
+          for i = 1:Nx
+              counter += 1
+              if (j == 1 || j == Ny || i == 1 || i == Nx)
+                  bdy = push!(bdy, counter)
+                  if (j == 1 || j == Ny)
+                      push!(ynb, 1)
+                  else
+                      push!(ynb, 2)
+                  end
+                  if (i == 1 || i == Nx)
+                      push!(xnb, 1)
+                  else
+                      push!(xnb, 2)
+                  end
+              end
+          end
+      end
+  return bdy, xnb, ynb
+end
+
+""" 
+    nablasq_grid(Nx, Ny, h, k)
+
+Laplacian matrix on a 2D grid
+
+# Arguments:
+    - `Nx::Int64`: Number of points in first dimension
+    - `Ny::Int64`: Number of points in second dimension
+    - `h::Float64`: Aspect ratio in first dimension
+    - `k::Float64`: Aspect ratio in second dimension
+
+# Outputs:
+    - discrete Laplacian matrix in 2D
+"""
+function nablasq_grid(Nx::Int64, Ny::Int64, h::Float64, k::Float64)
+  o1 = ones(Nx) / h
+  del1 = spdiagm_nonsquare(Nx + 1, Nx, -1 => -o1, 0 => o1)
+  o2 = ones(Ny) / k
+  del2 = spdiagm_nonsquare(Ny + 1, Ny, -1 => -o2,0 => o2)
+  A2D = (kron(sparse(I, Ny, Ny), del1' * del1) + 
+          kron(del2' * del2, sparse(I, Nx, Nx)))
+  bdy, xnb, ynb = bdy_nodes(Nx, Ny)
+  count = 1
+  for i in bdy
+      A2D[i, i] = 0.0
+      A2D[i, i] = A2D[i, i] + xnb[count] / h ^ 2 + ynb[count] / k ^ 2 
+      count += 1
+  end
+  return A2D
+end
+
+"""
+
+  matern_2d_grid(mat, discard, m, eps, h, k)
+
+...
+# Arguments
+  - `mat`: the matrix containing the image
+  - `idx`: the linear indices of the nodes to be discarded
+  - `eps`: Matern parameter eps
+  - `m`: The Matern exponent (integer)
+  - `h`: The aspect ratio in the first dimension
+  - `k`: The aspect ratio in the second dimension
+
+# Outputs
+  - matrix containing the interpolated image
+
+# Example:
+
+```<julia-repl>
+x = y = 1:30
+h = k = x[2] - x[1]
+y = sin.(2 * pi * x * 0.2) * cos.(2 * pi * y * 0.3)
+discard = randperm(900)[1:450]
+# Laplace interpolation
+y_lap = matern_2d_grid(y, discard, 1, 0.0, h, k)
+# Matern interpolation
+y_mat = matern_2d_grid(y, discard, 2, 0.1, h, k)
+...
+
+"""
+function matern_2d_grid(mat::Matrix, discard::Vector, m::Int64 = 1, eps = 0.0, 
+                        h::Float64 = 1.0, k::Float64 = 1.0)
+    rows, columns = size(mat)
+    A2D = nablasq_grid(rows, columns, h, k)
+    sizeA = size(A2D, 1)
+    C = sparse(I, sizeA, sizeA)
+    for i in discard
+        C[i, i] = 0.0
+    end
+    if ((m == 1)||(m == 1.0)) && (eps == 0.0)
+        # Laplace interpolation
+        u = ((C - (sparse(I, sizeA, sizeA) - C) * A2D)) \ (C * mat[:])
+        return reshape(u, rows, columns)
+    else
+        # Matern interpolation
+        for i = 1:sizeA
+            A2D[i,i] = A2D[i,i] + eps^2
+        end
+        A2D = A2D^m
+        u = ((C - (sparse(I, sizeA, sizeA) - C) * A2D)) \ (C * mat[:])
+        return reshape(u, rows, columns)   
+    end
+end
+