Mode convergence

Functionality to investigate convergence is supplied in this packages where the convergence in time and frequency can be investigated.

ProperOrthogonalDecomposition.modeConvergence — Method

function modeConvergence(X::AbstractArray, PODfun, stops::AbstractArray{<: AbstractRange}, numModes::Int)

Modal convergence check based on l2-norm of modes. The array stops contains the ranges to investigate where stops[end] is used as the reference modes. The numModes largest modes are compared to reduce the computational time. The function used to POD the data is supplied through PODfun

source

ProperOrthogonalDecomposition.modeConvergence! — Method

function modeConvergence!(loadFun, PODfun, stops::AbstractArray{<: AbstractRange}, numModes::Int)

Same as modeConvergence(X::AbstractArray, PODfun, stops::AbstractArray{<: AbstractRange}, numModes::Int) but here the data is reloaded for each comparision so that an inplace POD method can be used to reduce maximum memory usage.

source

Example

Convergence in time

using ProperOrthogonalDecomposition

t, x = range(0, stop=100, length=100), range(-10, stop=30, length=120)

Xgrid = [i for i in x, j in t]
tgrid = [j for i in x, j in t]

f1 = sech.(Xgrid.-3.5) .* 10.0 .* cos.(0.5 .*tgrid)
f2 = cos.(Xgrid) .* 1.0 .* cos.(2.5 .*tgrid)
f3 = sech.(Xgrid.+5.0) .* 4.0 .* cos.(1.0 .*tgrid)

Y = f1+f2+f3

#Array of ranges we're interested in investigating
ranges = Array{UnitRange{Int64}}(undef,40)

#Ranges of interest starting from 3 timesteps
subset = range(3, stop=size(Y,2), length=length(ranges))
for i = 1:length(ranges)
    ranges[i] = 1:round(Int,subset[i])
end

convergence = modeConvergence(Y,PODeigen,ranges,3)

The history of convergence indicates the point at which additional data no longer provides additional information to the POD modes.

Convergence inplace

Datasets can quickly become large which is why an inplace method is available where the user supplies a function to load the data.

using DelimitedFiles

#Anonymous function with zero arguments
loadFun = ()->readdlm("path/to/data/dataset.csv", ',')

#POD the data inplace and reload it into memory each time.
convergence = modeConvergence!(loadFun,PODeigen!,ranges,3)

This can also be done for a weighted POD with

convergence = modeConvergence!(loadFun,X->PODeigen!(X,W),ranges,3)

Note

The use of a delimited files, such as a *.csv in the above example, is not advisable if memory is a concern. Use a binary file format such as HDF5 for example.

Convergence in frequency

Just as we can investigate the time history needed for the mode to be converged, we can also investigate the sampling frequency needed. This is done by supplying the ranges as subsampled sets of the full time history.

using ProperOrthogonalDecomposition

t, x = range(0, stop=50, length=1000), range(-10, stop=30, length=120)

Xgrid = [i for i in x, j in t]
tgrid = [j for i in x, j in t]

f1 = sech.(Xgrid.-3.5) .* 10.0 .* cos.(0.5 .*tgrid)
f2 = cos.(Xgrid) .* 1.0 .* cos.(2.5 .*tgrid)
f3 = sech.(Xgrid.+5.0) .* 4.0 .* cos.(1.0 .*tgrid)

Y = f1+f2+f3

#Array of ranges we're interested in investigating
subset = 100:-3:1 #Sub-sampling starts at every 100:th timestep
ranges = Array{StepRange{Int64,Int64}}(undef,length(subset))

for i = 1:length(ranges)
    ranges[i] = 1:round(Int,subset[i]):length(t)
end

convergence = modeConvergence(Y,PODeigen,ranges,3)

Note

The data point where 1/f = 1.25 indicates that Mode 2 and Mode 3 are far from converged, this sudden jump is likely due to the relative importance of the modes switching at this sampling frequency. This does not necessarily mean that the modes themselves are poorly represented.