--- a/SbpOperators/src/Quadrature.jl	Tue Jun 23 17:32:54 2020 +0200
+++ b/SbpOperators/src/Quadrature.jl	Tue Jun 23 18:53:20 2020 +0200
@@ -3,11 +3,11 @@
     Quadrature{Dim,T<:Real,N,M,K} <: TensorMapping{T,Dim,Dim}
 
 Implements the quadrature operator `Q` of Dim dimension as a TensorMapping
-The multi-dimensional tensor operator consists of a tuple of 1D DiagonalQuadrature
+The multi-dimensional tensor operator consists of a tuple of 1D DiagonalNorm H
 tensor operators.
 """
 struct Quadrature{Dim,T<:Real,N,M} <: TensorOperator{T,Dim}
-    H::NTuple{Dim,DiagonalQuadrature{T,N,M}}
+    H::NTuple{Dim,DiagonalNorm{T,N,M}}
 end
 export Quadrature
 
@@ -35,35 +35,35 @@
 end
 
 """
-    Quadrature{Dim,T<:Real,N,M,K} <: TensorMapping{T,Dim,Dim}
+    DiagonalNorm{Dim,T<:Real,N,M,K} <: TensorMapping{T,Dim,Dim}
 
-Implements the quadrature operator `H` of Dim dimension as a TensorMapping
+Implements the diagnoal norm operator `H` of Dim dimension as a TensorMapping
 """
-struct DiagonalQuadrature{T<:Real,N,M} <: TensorOperator{T,1}
+struct DiagonalNorm{T<:Real,N,M} <: TensorOperator{T,1}
     h::T # The grid spacing could be included in the stencil already. Preferable?
     closure::NTuple{M,T}
     #TODO: Write a nice constructor
 end
 
-@inline function LazyTensors.apply(H::DiagonalQuadrature{T}, v::AbstractVector{T}, I::NTuple{1,Index}) where T
+@inline function LazyTensors.apply(H::DiagonalNorm{T}, v::AbstractVector{T}, I::NTuple{1,Index}) where T
     return @inbounds apply(H, v, I[1])
 end
 
 LazyTensors.apply_transpose(H::Quadrature{Dim,T}, v::AbstractArray{T,2}, I::NTuple{2,Index}) where T = LazyTensors.apply(H,v,I)
 
-@inline LazyTensors.apply(H::DiagonalQuadrature, v::AbstractVector{T}, i::Index{Lower}) where T
+@inline LazyTensors.apply(H::DiagonalNorm, v::AbstractVector{T}, i::Index{Lower}) where T
     return @inbounds H.h*H.closure[Int(i)]*v[Int(i)]
 end
-@inline LazyTensors.apply(H::DiagonalQuadrature,v::AbstractVector{T}, i::Index{Upper}) where T
+@inline LazyTensors.apply(H::DiagonalNorm,v::AbstractVector{T}, i::Index{Upper}) where T
     N = length(v);
     return @inbounds H.h*H.closure[N-Int(i)+1]v[Int(i)]
 end
 
-@inline LazyTensors.apply(H::DiagonalQuadrature, v::AbstractVector{T}, i::Index{Interior}) where T
+@inline LazyTensors.apply(H::DiagonalNorm, v::AbstractVector{T}, i::Index{Interior}) where T
     return @inbounds H.h*v[Int(i)]
 end
 
-function LazyTensors.apply(H::DiagonalQuadrature,  v::AbstractVector{T}, index::Index{Unknown}) where T
+function LazyTensors.apply(H::DiagonalNorm,  v::AbstractVector{T}, index::Index{Unknown}) where T
     N = length(v);
     r = getregion(Int(index), closuresize(H), N)
     i = Index(Int(index), r)
@@ -71,6 +71,6 @@
 end
 export LazyTensors.apply
 
-function closuresize(H::DiagonalQuadrature{T<:Real,N,M}) where {T,N,M}
+function closuresize(H::DiagonalNorm{T<:Real,N,M}) where {T,N,M}
     return M
 end