Partial differential equations (PDE) solvers library

A library for numerical solution of partial differential equations (PDE) using finite difference method and Thomas algorithm

Features

Solution of parabolic equations of the form:

L(x,t,U)*∂U/∂t = ∂U( K(x,t,U)*∂U/∂x )/∂x + V(x,t,U)*∂U/∂x + F(x,t,U)

where U = U(x,t) is the unknown function (temperature, concentration, etc)

Solution of hyperbolic equations of the form:

M(x,t,U)*∂²U/∂t² = ∂U( K(x,t,U)*∂U/∂x )/∂x + V(x,t,U)*∂U/∂x + F(x,t,U)

where U = U(x,t) is the unknown function (displacement of string, etc)

Support for various boundary conditions:

• Dirichlet (function value at the boundary)
• Neumann (derivative value at the boundary)
• Robin (linear combination of function value and its derivative)

Efficient numerical methods:

• Finite difference method for derivative approximation
• Thomas algorithm for solving tridiagonal systems of linear equations

Prerequisites

• JDK 21
• Gradle (embedded in the project)

Building the project

./gradlew clean build

Generating documentation

./gradlew clean javadoc

Check ./build/doc/javadoc folder
Online documentation is available here

Supported equation types

Parabolic equations

ParabolicEquation class

• Describes diffusion, heat conduction, and other dissipative processes
• Characterized by the presence of only first-order time derivative
• Solution is defined on the space-time domain [x1,x2]×[0,t2]

Hyperbolic equations

HyperbolicEquation class

• Describes wave processes and oscillations
• Characterized by the presence of second-order time derivative
• Solution is defined on the space-time domain [x1,x2]×[0,t2]

Boundary conditions

Dirichlet (definite mode)

DirichletBorderCondition class

• Specifies function value at the boundary: U(x1,t) = g1(t) or U(x2,t) = g2(t)

Neumann (definite force)

NeumannBorderCondition class

• Specifies derivative value at the boundary: ∂U/∂x(x1,t) = g1(t) or ∂U/∂x(x2,t) = g2(t)

Robin (elastic fixing)

RobinBorderCondition class

• Specifies linear combination of function value and its derivative: ∂U/∂x(x1,t) = h*(U(x1,t) - Theta(t)) or ∂U/∂x(x2,t) = h*(U(x2,t) - Theta(t))

Solution methods

Finite difference method

• Approximates derivatives using finite differences
• Transforms PDE into a system of linear equations
• Uses the Thomas algorithm to solve the resulting system

Thomas algorithm

• Efficient algorithm for solving tridiagonal systems of linear equations
• Time complexity O(n), where n is the system size

Library usage examples

Parabolic equations

• Diffusion problem with Dirichlet boundary conditions
• Diffusion problem with Neumann boundary conditions
• Heat transfer problem with mixed Dirichlet+Robin boundary conditions

Hyperbolic equations

• Wave equation (plucked string) with Dirichlet boundary conditions

Solution utilities

• Solution data saving and loading

How to use library in your project

Maven

<dependency>
  <groupId>io.github.andrei-punko</groupId>
  <artifactId>pde-solvers</artifactId>
  <version>1.0.3</version>
</dependency>

Gradle

implementation 'io.github.andrei-punko:pde-solvers:1.0.3'

Code example

import io.github.andreipunko.math.pde.border.DirichletBorderCondition;
import io.github.andreipunko.math.pde.equation.ParabolicEquation;
import io.github.andreipunko.util.FileUtil;

class ParabolicEquationSolution {

    private final double C_MAX = 100.0;     // Max concentration
    private final double L = 0.001;         // Thickness of plate, m
    private final double TIME = 1;          // Investigated time, sec
    private final double D = 1e-9;          // Diffusion coefficient

    private final double h = L / 100.0;         // Space step
    private final double tau = TIME / 100.0;    // Time step

    public void solve() {
        var diffusionEquation = buildParabolicEquation();

        var solution = new ParabolicEquationSolver()
                .solve(diffusionEquation, h, tau);

        var numericU = solution.gUt(TIME);
        FileUtil.save(numericU, "./build/parabolic1-eqn-solution.txt", true);
    }

    /**
     * Parabolic equation definition
     */
    private ParabolicEquation buildParabolicEquation() {
        var leftBorderCondition = new DirichletBorderCondition();
        var rightBorderCondition = new DirichletBorderCondition();

        return new ParabolicEquation(0, L, TIME, leftBorderCondition, rightBorderCondition) {
            @Override
            public double gK(double x, double t, double U) {
                return D;
            }

            @Override
            public double gU0(double x) {
                return getC0(x);
            }
        };
    }

    /**
     * Initial concentration profile
     */
    private double getC0(double x) {
        x /= L;
        if (0.4 <= x && x <= 0.5) {
            return C_MAX * (10 * x - 4);
        }
        if (0.5 <= x && x <= 0.6) {
            return C_MAX * (-10 * x + 6);
        }
        return 0;
    }
}

Appendix

Video with project description

How to make new library release on GitHub

See instruction

How to publish artifact to Maven Central

See instruction