--- a/DiffOps/src/laplace.jl	Thu Dec 05 09:28:04 2019 +0100
+++ b/DiffOps/src/laplace.jl	Thu Dec 05 09:44:34 2019 +0100
@@ -10,17 +10,17 @@
 
 # u = L*v
 function apply(L::Laplace{1}, v::AbstractVector, i::Int)
-    uᵢ = L.a * SbpOperators.apply(L.op, L.grid.spacing[1], v, i)
+    uᵢ = L.a * SbpOperators.apply(L.op, inverse_spacing(L.grid)[1], v, i)
     return uᵢ
 end
 
 @inline function apply(L::Laplace{2}, v::AbstractArray{T,2} where T, I::Tuple{Index{R1}, Index{R2}}) where {R1, R2}
     # 2nd x-derivative
     @inbounds vx = view(v, :, Int(I[2]))
-    @inbounds uᵢ = L.a*SbpOperators.apply(L.op, L.grid.inverse_spacing[1], vx , I[1])
+    @inbounds uᵢ = L.a*SbpOperators.apply(L.op, inverse_spacing(L.grid)[1], vx , I[1])
     # 2nd y-derivative
     @inbounds vy = view(v, Int(I[1]), :)
-    @inbounds uᵢ += L.a*SbpOperators.apply(L.op, L.grid.inverse_spacing[2], vy, I[2])
+    @inbounds uᵢ += L.a*SbpOperators.apply(L.op, inverse_spacing(L.grid)[2], vy, I[2])
     # NOTE: the package qualifier 'SbpOperators' can problably be removed once all "applying" objects use LazyTensors
     return uᵢ
 end
@@ -56,9 +56,9 @@
     I = CartesianIndex(I);
     N = size(H.grid)
     # Quadrature in x direction
-    @inbounds q = apply_quadrature(H.op, H.grid.spacing[1], v[I] , I[1], N[1])
+    @inbounds q = apply_quadrature(H.op, spacing(H.grid)[1], v[I] , I[1], N[1])
     # Quadrature in y-direction
-    @inbounds q = apply_quadrature(H.op, H.grid.spacing[2], q, I[2], N[2])
+    @inbounds q = apply_quadrature(H.op, spacing(H.grid)[2], q, I[2], N[2])
     return q
 end
 
@@ -83,9 +83,9 @@
     I = CartesianIndex(I);
     N = size(H_inv.grid)
     # Inverse quadrature in x direction
-    @inbounds q_inv = apply_inverse_quadrature(H_inv.op, H_inv.grid.inverse_spacing[1], v[I] , I[1], N[1])
+    @inbounds q_inv = apply_inverse_quadrature(H_inv.op, inverse_spacing(H_inv.grid)[1], v[I] , I[1], N[1])
     # Inverse quadrature in y-direction
-    @inbounds q_inv = apply_inverse_quadrature(H_inv.op, H_inv.grid.inverse_spacing[2], q_inv, I[2], N[2])
+    @inbounds q_inv = apply_inverse_quadrature(H_inv.op, inverse_spacing(H_inv.grid)[2], q_inv, I[2], N[2])
     return q_inv
 end
 
@@ -144,13 +144,13 @@
     i = I[dim(d.bId)]
     j = I[3-dim(d.bId)]
     N_i = size(d.grid)[dim(d.bId)]
-    h_inv = d.grid.inverse_spacing[dim(d.bId)]
+    h_inv = inverse_spacing(d.grid)[dim(d.bId)]
     return apply_d(d.op, h_inv, v[j], N_i, i, region(d.bId))
 end
 
 function LazyTensors.apply_transpose(d::NormalDerivative, v::AbstractArray, I::NTuple{1,Int})
     u = selectdim(v,3-dim(d.bId),I[1])
-    return apply_d_T(d.op, d.grid.inverse_spacing[dim(d.bId)], u, region(d.bId))
+    return apply_d_T(d.op, inverse_spacing(d.grid)[dim(d.bId)], u, region(d.bId))
 end
 
 """
@@ -168,7 +168,7 @@
 # TODO: Make this independent of dimension
 # TODO: Dispatch directly on Index{R}?
 function LazyTensors.apply(q::BoundaryQuadrature{T}, v::AbstractArray{T,1}, I::NTuple{1,Int}) where T
-    h = q.grid.spacing[3-dim(q.bId)]
+    h = spacing(q.grid)[3-dim(q.bId)]
     N = size(v)
     return apply_quadrature(q.op, h, v[I[1]], I[1], N[1])
 end

--- a/Grids/src/EquidistantGrid.jl	Thu Dec 05 09:28:04 2019 +0100
+++ b/Grids/src/EquidistantGrid.jl	Thu Dec 05 09:44:34 2019 +0100
@@ -10,16 +10,14 @@
     size::NTuple{Dim, Int} # First coordinate direction stored first
     limit_lower::NTuple{Dim, T}
     limit_upper::NTuple{Dim, T}
-    spacing::NTuple{Dim, T} # Grid spacing
     inverse_spacing::NTuple{Dim, T} # Reciprocal of grid spacing
 
     # General constructor
     function EquidistantGrid(size::NTuple{Dim, Int}, limit_lower::NTuple{Dim, T}, limit_upper::NTuple{Dim, T}) where Dim where T
         @assert all(size.>0)
         @assert all(limit_upper.-limit_lower .!= 0)
-        spacing = abs.(limit_upper.-limit_lower)./(size.-1)
-        inverse_spacing = 1.0./spacing
-        return new{Dim,T}(size, limit_lower, limit_upper, spacing, inverse_spacing)
+        inverse_spacing = (size.-1)./ abs.(limit_upper.-limit_lower)
+        return new{Dim,T}(size, limit_lower, limit_upper, inverse_spacing)
     end
 end
 
@@ -37,7 +35,6 @@
     return length(grid.size)
 end
 
-# TODO: Keep the below functions or just use properties?
 # Returns the reciprocal of the spacing of the grid
 #
 function inverse_spacing(grid::EquidistantGrid)
@@ -48,7 +45,7 @@
 # Returns the reciprocal of the spacing of the grid
 #
 function spacing(grid::EquidistantGrid)
-    return grid.spacing
+    return 1.0./grid.inverse_spacing
 end
 export spacing