Skip to content

Loss Function Implementation for 2D Helmholtz Problem.

This module implements the loss function for solving the 2D Helmholtz equation using neural networks. It focuses on computing residuals in the weak form of the PDE with wave number parameter.

Key functions
  • pde_loss_helmholtz: Computes domain-based PDE loss
Note

The implementation is based on the FastVPINNs methodology [1] for efficient computation of Variational residuals of PDEs.

References

[1] FastVPINNs: Tensor-Driven Acceleration of VPINNs for Complex Geometries DOI: https://arxiv.org/abs/2404.12063

pde_loss_helmholtz(test_shape_val_mat, test_grad_x_mat, test_grad_y_mat, pred_nn, pred_grad_x_nn, pred_grad_y_nn, forcing_function, bilinear_params)

Calculates residual for 2D Helmholtz equation.

Implements the FastVPINNs methodology for computing variational residuals in 2D Helmholtz equation (-Δu - k²u = f) using efficient tensor operations.

Parameters:

Name Type Description Default
test_shape_val_mat Tensor

Test function values at quadrature points Shape: (n_elements, n_test_functions, n_quad_points)

 required
test_grad_x_mat Tensor

Test function x-derivatives at quadrature points Shape: (n_elements, n_test_functions, n_quad_points)

 required
test_grad_y_mat Tensor

Test function y-derivatives at quadrature points Shape: (n_elements, n_test_functions, n_quad_points)

 required
pred_nn Tensor

Neural network solution at quadrature points Shape: (n_elements, n_quad_points)

 required
pred_grad_x_nn Tensor

x-derivative of NN solution at quadrature points Shape: (n_elements, n_quad_points)

 required
pred_grad_y_nn Tensor

y-derivative of NN solution at quadrature points Shape: (n_elements, n_quad_points)

 required
forcing_function callable

Right-hand side forcing term

 required
bilinear_params dict

Dictionary containing: eps: Diffusion coefficient (typically 1.0) k: Wave number parameter

 required

Returns:

Type Description
Tensor

Cell-wise residuals averaged over test functions Shape: (n_cells,)
Note

The weak form includes: - Diffusion term: -∫∇u·∇v dΩ - Wave term: ∫k²uv dΩ Implementation handles high wave numbers through efficient tensor operations.

Source code in scirex/core/sciml/fastvpinns/physics/helmholtz2d.py 
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def pde_loss_helmholtz(
    test_shape_val_mat: tf.Tensor,
    test_grad_x_mat: tf.Tensor,
    test_grad_y_mat: tf.Tensor,
    pred_nn: tf.Tensor,
    pred_grad_x_nn: tf.Tensor,
    pred_grad_y_nn: tf.Tensor,
    forcing_function: callable,
    bilinear_params: dict,
) -> tf.Tensor:
    """Calculates residual for 2D Helmholtz equation.

    Implements the FastVPINNs methodology for computing variational residuals
    in 2D Helmholtz equation (-Δu - k²u = f) using efficient tensor operations.

    Args:
        test_shape_val_mat: Test function values at quadrature points
            Shape: (n_elements, n_test_functions, n_quad_points)
        test_grad_x_mat: Test function x-derivatives at quadrature points
            Shape: (n_elements, n_test_functions, n_quad_points)
        test_grad_y_mat: Test function y-derivatives at quadrature points
            Shape: (n_elements, n_test_functions, n_quad_points)
        pred_nn: Neural network solution at quadrature points
            Shape: (n_elements, n_quad_points)
        pred_grad_x_nn: x-derivative of NN solution at quadrature points
            Shape: (n_elements, n_quad_points)
        pred_grad_y_nn: y-derivative of NN solution at quadrature points
            Shape: (n_elements, n_quad_points)
        forcing_function: Right-hand side forcing term
        bilinear_params: Dictionary containing:
            eps: Diffusion coefficient (typically 1.0)
            k: Wave number parameter

    Returns:
        Cell-wise residuals averaged over test functions
            Shape: (n_cells,)

    Note:
        The weak form includes:
        - Diffusion term: -∫∇u·∇v dΩ
        - Wave term: ∫k²uv dΩ
        Implementation handles high wave numbers through efficient
        tensor operations.
    """
    #  ∫ (du/dx. dv/dx ) dΩ
    pde_diffusion_x = tf.transpose(tf.linalg.matvec(test_grad_x_mat, pred_grad_x_nn))

    #  ∫ (du/dy. dv/dy ) dΩ
    pde_diffusion_y = tf.transpose(tf.linalg.matvec(test_grad_y_mat, pred_grad_y_nn))

    # eps * ∫ (du/dx. dv/dx + du/dy. dv/dy) dΩ
    pde_diffusion = bilinear_params["eps"] * (pde_diffusion_x + pde_diffusion_y)

    # \int(k^2 (u).v) dw
    helmholtz_additional = (bilinear_params["k"] ** 2) * tf.transpose(
        tf.linalg.matvec(test_shape_val_mat, pred_nn)
    )

    residual_matrix = -1.0 * (pde_diffusion) + helmholtz_additional - forcing_function

    residual_cells = tf.reduce_mean(tf.square(residual_matrix), axis=0)

    return residual_cells

Helmholtz Equation Loss Calculation Module