SummationByPartsOperators.jl: A Julia library of provably stable discretization techniques with mimetic properties

The Julia library SummationByPartsOperators.jl provides a unified interface of different discretization approaches including finite difference, Fourier pseudospectral, continuous Galerkin, and discontinuous Galerkin methods. This unified interface is based on the notion of summation-by-parts (SBP) operators. Originally developed for finite difference methods, SBP operators are discrete derivative operators designed specifically to get provably stable (semi-) discretizations, mimicking energy/entropy estimates from the continuous level discretely and paying special attention to boundary conditions.

SummationByPartsOperators.jl is mainly written to be useful for both students learning the basic concepts and researchers developing new numerical algorithms based on SBP operators. Thus, this package uses Julia's multiple dispatch and strong type system to provide a unified framework of all of these seemingly different discretizations while being reasonably optimized at the same time, achieving good performance without sacrificing flexibility.

Installation

SummationByPartsOperators.jl is a registered Julia package. Thus, you can install it from the Julia REPL via

julia> using Pkg; Pkg.add("SummationByPartsOperators")

If you want to update SummationByPartsOperators.jl, you can use

julia> using Pkg; Pkg.update("SummationByPartsOperators")

As usual, if you want to update SummationByPartsOperators.jl and all other packages in your current project, you can execute

julia> using Pkg; Pkg.update()

A brief list of notable changes is available in NEWS.md.

Basic examples

Compute the derivative on a periodic domain using a central finite difference operator.

julia> using SummationByPartsOperators

julia> using Plots: plot, plot!

julia> D = periodic_derivative_operator(derivative_order=1, accuracy_order=2,
                                        xmin=0.0, xmax=2.0, N=20)
Periodic first-derivative operator of order 2 on a grid in [0.0, 2.0] using 20 nodes,
stencils with 1 nodes to the left, 1 nodes to the right, and coefficients of Fornberg (1998)
  Calculation of Weights in Finite Difference Formulas.
  SIAM Rev. 40.3, pp. 685-691.

julia> x = grid(D); u = sinpi.(x);

julia> plot(x, D * u, label="numerical")

julia> plot!(x, π .* cospi.(x), label="analytical")

You should see a plot like the following.

Compute the derivative on a bounded domain using an SBP finite difference operator.

julia> using SummationByPartsOperators

julia> using Plots: plot, plot!

julia> D = derivative_operator(MattssonNordström2004(), derivative_order=1, accuracy_order=2,
                               xmin=0.0, xmax=1.0, N=21)
SBP first-derivative operator of order 2 on a grid in [0.0, 1.0] using 21 nodes
and coefficients of Mattsson, Nordström (2004)
  Summation by parts operators for finite difference approximations of second
    derivatives.
  Journal of Computational Physics 199, pp. 503-540.

julia> x = grid(D); u = exp.(x);

julia> plot(x, D * u, label="numerical")

julia> plot!(x, exp.(x), label="analytical")

You should see a plot like the following.

Brief overview

The following derivative operators are implemented as "lazy"/matrix-free operators, i.e. no large (size of the computational grid) matrix is formed explicitly. They are linear operators and implement the same interface as matrices in Julia (at least partially). In particular, * and mul! are supported.

Periodic domains

periodic_derivative_operator(; derivative_order, accuracy_order, xmin, xmax, N)

These are classical central finite difference operators using N nodes on the interval [xmin, xmax].
periodic_derivative_operator(Holoborodko2008(); derivative_order, accuracy_order, xmin, xmax, N)

These are central finite difference operators using N nodes on the interval [xmin, xmax] and the coefficients of Pavel Holoborodko.
fourier_derivative_operator(; xmin, xmax, N)

Fourier derivative operators are implemented using the fast Fourier transform of FFTW.jl.

All of these periodic derivative operators support multiplication and addition such that polynomials and rational functions of them can be represented efficiently, e.g. to solve elliptic problems of the form u = (D^2 + I) \ f.

Finite (nonperiodic) domains

derivative_operator(source_of_coefficients; derivative_order, accuracy_order, xmin, xmax, N)

Finite difference SBP operators for first and second derivatives can be obtained by using MattssonNordström2004() as source_of_coefficients. Other sources of coefficients are implemented as well. To obtain a full list of all operators, use subtypes(SourceOfCoefficients).
legendre_derivative_operator(; xmin, xmax, N)

Use Lobatto Legendre polynomial collocation schemes on N, i.e. polynomials of degree N-1, implemented via PolynomialBases.jl.

Dissipation operators

Additionally, some artificial dissipation/viscosity operators are implemented. The most basic usage is Di = dissipation_operator(D), where D can be a (periodic, Fourier, Legendre, SBP FD) derivative operator. Use ?dissipation_operator for more details.

Continuous and discontinuous Galerkin methods

SBP operators on bounded domains can be coupled continuously or discontinuously to obtain CG//DG-type methods. You need to create an appropriate mesh and a basic operator D that should be used on each element. Then, global CG/DG operators are constructed lazily/matrix-free by calling couple_continuously(D, mesh) or couple_discontinuously(D, mesh, coupling::Union{Val{:plus}, Val{:central}, Val{:minus}}=Val(:central)). Choosing coupling=Val(:central) yields a classical SBP operator; the other two coupling types result in upwind SBP operators. Currently, only uniform meshes

UniformMesh1D(xmin::Real, xmax::Real, Nx::Integer)
UniformPeriodicMesh1D(xmin::Real, xmax::Real, Nx::Integer)

are implemented.

Conversion to other forms

Sometimes, it can be convenient to obtain an explicit (sparse, banded) matrix form of the operators. Therefore, some conversion functions are supplied, e.g.

julia> using SummationByPartsOperators

julia> D = derivative_operator(MattssonNordström2004(),
                               derivative_order=1, accuracy_order=2,
                               xmin=0.0, xmax=1.0, N=5)
SBP first-derivative operator of order 2 on a grid in [0.0, 1.0] using 5 nodes
and coefficients of Mattsson, Nordström (2004)
  Summation by parts operators for finite difference approximations of second
    derivatives.
  Journal of Computational Physics 199, pp. 503-540.

julia> Matrix(D)
5×5 Array{Float64,2}:
 -4.0   4.0   0.0   0.0  0.0
 -2.0   0.0   2.0   0.0  0.0
  0.0  -2.0   0.0   2.0  0.0
  0.0   0.0  -2.0   0.0  2.0
  0.0   0.0   0.0  -4.0  4.0

julia> using SparseArrays

julia> sparse(D)
5×5 SparseMatrixCSC{Float64, Int64} with 10 stored entries:
 -4.0   4.0    ⋅     ⋅    ⋅
 -2.0    ⋅    2.0    ⋅    ⋅
   ⋅   -2.0    ⋅    2.0   ⋅
   ⋅     ⋅   -2.0    ⋅   2.0
   ⋅     ⋅     ⋅   -4.0  4.0

julia> using BandedMatrices

julia> BandedMatrix(D)
5×5 BandedMatrix{Float64,Array{Float64,2},Base.OneTo{Int64}}:
 -4.0   4.0    ⋅     ⋅    ⋅
 -2.0   0.0   2.0    ⋅    ⋅
   ⋅   -2.0   0.0   2.0   ⋅
   ⋅     ⋅   -2.0   0.0  2.0
   ⋅     ⋅     ⋅   -4.0  4.0

Documentation

The latest documentation is available online and under docs/src. Some additional examples can be found in the directory notebooks. In particular, examples of complete discretizations of the linear advection equation, the heat equation, and the wave equation are available. Further examples are supplied as tests.

Referencing

If you use SummationByPartsOperators.jl for your research, please cite it using the bibtex entry

@article{ranocha2021sbp,
  title={{SummationByPartsOperators.jl}: {A} {J}ulia library of provably stable
         semidiscretization techniques with mimetic properties},
  author={Ranocha, Hendrik},
  journal={Journal of Open Source Software},
  year={2021},
  month={08},
  doi={10.21105/joss.03454},
  volume={6},
  number={64},
  pages={3454},
  publisher={The Open Journal},
  url={https://github.com/ranocha/SummationByPartsOperators.jl}
}

License and contributing

This project is licensed under the MIT license (see LICENSE.md). Since it is an open-source project, we are very happy to accept contributions from the community. Please refer to CONTRIBUTING.md for more details.

Remove Travis CI testing - at least on on Mac, maybe completely???

https://blog.travis-ci.com/2020-11-02-travis-ci-new-billing:

macOS builds need special care and attention. We want to make sure that builders on Mac have the highest quality experience at the fastest possible speeds. Therefore, we are separating out macOS usage from other build usage and offering a distinct add-on plan that will correlate directly to your macOS usage. Purchase only the credits you need and use them until you run out.

We love our OSS teams who choose to build using TravisCI and we fully want to support that community. However, recently we have encountered significant abuse of the intention of this offering. Abusers have been tying up our build queues and causing performance reductions for everyone. In order to bring the rules back to fair playing grounds, we are implementing some changes for our public build repositories.

For those of you who have been building on public repositories (on travis-ci.com, with no paid subscription), we will upgrade you to our trial (free) plan with a 10K credit allotment (which allows around 1000 minutes in a Linux environment).

You will not need to change your build definitions when you are pointed to the new plan

When your credit allotment runs out - we’d love for you to consider which of our plans will meet your needs.

We will be offering an allotment of OSS minutes that will be reviewed and allocated on a case by case basis. Should you want to apply for these credits please open a request with Travis CI support stating that you’d like to be considered for the OSS allotment. Please include:

Your account name and VCS provider (like travis-ci.com/github/[your account name] )

How many credits (build minutes) you’d like to request (should your run out of credits again you can repeat the process to request more)

Usage will be tracked under your account information so that you can better understand how many credits/minutes are being used

Any ideas, suggestions?

ranocha / summationbypartsoperators.jl Goto Github PK

summationbypartsoperators.jl's Introduction

SummationByPartsOperators.jl: A Julia library of provably stable discretization techniques with mimetic properties

Installation

Basic examples

Brief overview

Periodic domains

Finite (nonperiodic) domains

Dissipation operators

Continuous and discontinuous Galerkin methods

Conversion to other forms

Documentation

Referencing

License and contributing

summationbypartsoperators.jl's People

Contributors

Stargazers

Watchers

Forkers

summationbypartsoperators.jl's Issues

Recommend Projects

Recommend Topics

Recommend Org