Refactor FPDE scheme

Author: lululxvi

deepxde/data/fpde.py

@@ -13,13 +13,23 @@
 from ..utils import run_if_all_none
 
 
-class Discretization(object):
-    """Space discretization scheme parameters."""
+class Scheme(object):
+    """Fractional Laplacian discretization.
 
-    def __init__(self, dim, meshtype, resolution):
-        self.dim = dim
-        self.meshtype, self.resolution = meshtype, resolution
+    Discretize fractional Laplacian uisng quadrature rule for the integral with respect to the directions
+    and Grunwald-Letnikov (GL) formula for the Riemann-Liouville directional fractional derivative.
 
+    Args:
+        meshtype (string): "static" or "dynamic".
+        resolution: A list of integer. The first number is the number of quadrature points in the first direction, ...,
+            and the last number is the GL parameter.
+    """
+
+    def __init__(self, meshtype, resolution):
+        self.meshtype = meshtype
+        self.resolution = resolution
+
+        self.dim = len(resolution)
         self._check()
 
     def _check(self):
@@ -29,11 +39,6 @@ def _check(self):
             raise ValueError(
                 "Do not support meshtype static for dimension %d" % self.dim
             )
-        if self.dim != len(self.resolution):
-            raise ValueError(
-                "Resolution %s does not math dimension %d."
-                % (self.resolution, self.dim)
-            )
 
 
 class FPDE(PDE):
@@ -58,7 +63,8 @@ def __init__(
         fpde,
         alpha,
         bcs,
-        disc,
+        resolution,
+        meshtype="dynamic",
         num_domain=0,
         num_boundary=0,
         train_distribution="random",
@@ -67,7 +73,7 @@ def __init__(
         num_test=None,
     ):
         self.alpha = alpha
-        self.disc = disc
+        self.disc = Scheme(meshtype, resolution)
         self.frac_train, self.frac_test = None, None
 
         super(FPDE, self).__init__(
@@ -118,10 +124,6 @@ def train_next_batch(self, batch_size=None):
         if self.disc.meshtype == "static":
             if self.geom.idstr != "Interval":
                 raise ValueError("Only Interval supports static mesh.")
-            if self.num_domain + 2 != self.disc.resolution[0]:
-                raise ValueError(
-                    "Mesh resolution does not match the number of points inside the domain."
-                )
 
             self.frac_train = Fractional(self.alpha, self.geom, self.disc, None)
             X = self.frac_train.get_x()
@@ -198,7 +200,8 @@ def __init__(
         fpde,
         alpha,
         ic_bcs,
-        disc,
+        resolution,
+        meshtype="dynamic",
         num_domain=0,
         num_boundary=0,
         num_initial=0,
@@ -213,7 +216,8 @@ def __init__(
             fpde,
             alpha,
             ic_bcs,
-            disc,
+            resolution,
+            meshtype=meshtype,
             num_domain=num_domain,
             num_boundary=num_boundary,
             train_distribution=train_distribution,

examples/fractional_Poisson_1d.py

@@ -38,14 +38,10 @@ def func(x):
     bc = dde.DirichletBC(geom, func, lambda _, on_boundary: on_boundary)
 
     # Static auxiliary points
-    disc = dde.data.fpde.Discretization(1, "static", [101])
-    data = dde.data.FPDE(
-        geom, fpde, alpha, bc, disc, num_domain=99, num_boundary=2, solution=func
-    )
+    data = dde.data.FPDE(geom, fpde, alpha, bc, [101], meshtype="static", solution=func)
     # Dynamic auxiliary points
-    # disc = dde.data.fpde.Discretization(1, "dynamic", [100])
     # data = dde.data.FPDE(
-    #     geom, fpde, alpha, bc, disc, num_domain=20, num_boundary=2, solution=func, num_test=100
+    #     geom, fpde, alpha, bc, [100], meshtype="dynamic", num_domain=20, num_boundary=2, solution=func, num_test=100
     # )
 
     net = dde.maps.FNN([1] + [20] * 4 + [1], "tanh", "Glorot normal")

examples/fractional_Poisson_1d_inverse.py

@@ -37,30 +37,29 @@ def func(x):
     )
 
     # Static auxiliary points
-    disc = dde.data.fpde.Discretization(1, "static", [101])
-    data = dde.data.FPDE(
-        geom,
-        fpde,
-        alpha,
-        observe_y,
-        disc,
-        num_domain=99,
-        anchors=observe_x,
-        solution=func,
-    )
-    # Dynamic auxiliary points
-    # disc = dde.data.fpde.Discretization(1, "dynamic", [100])
     # data = dde.data.FPDE(
     #     geom,
     #     fpde,
     #     alpha,
     #     observe_y,
-    #     disc,
-    #     num_domain=20,
+    #     [101],
+    #     meshtype="static",
     #     anchors=observe_x,
     #     solution=func,
-    #     num_test=100,
     # )
+    # Dynamic auxiliary points
+    data = dde.data.FPDE(
+        geom,
+        fpde,
+        alpha,
+        observe_y,
+        [100],
+        meshtype="dynamic",
+        num_domain=20,
+        anchors=observe_x,
+        solution=func,
+        num_test=100,
+    )
 
     net = dde.maps.FNN([1] + [20] * 4 + [1], "tanh", "Glorot normal")
     net.apply_output_transform(lambda x, y: (1 - x ** 2) * y)

examples/fractional_Poisson_2d.py

@@ -37,9 +37,8 @@ def func(x):
     geom = dde.geometry.Disk([0, 0], 1)
     bc = dde.DirichletBC(geom, func, lambda _, on_boundary: on_boundary)
 
-    disc = dde.data.fpde.Discretization(2, "dynamic", [8, 100])
     data = dde.data.FPDE(
-        geom, fpde, alpha, bc, disc, num_domain=100, num_boundary=1, solution=func
+        geom, fpde, alpha, bc, [8, 100], num_domain=100, num_boundary=1, solution=func
     )
 
     net = dde.maps.FNN([2] + [20] * 4 + [1], "tanh", "Glorot normal")

examples/fractional_Poisson_2d_inverse.py

@@ -43,13 +43,12 @@ def func(x):
         geom, ptset.values_to_func(func(observe_x)), lambda x, _: ptset.inside(x)
     )
 
-    disc = dde.data.fpde.Discretization(2, "dynamic", [8, 100])
     data = dde.data.FPDE(
         geom,
         fpde,
         alpha,
         observe_y,
-        disc,
+        [8, 100],
         num_domain=64,
         anchors=observe_x,
         solution=func,

examples/fractional_Poisson_3d.py

@@ -37,9 +37,8 @@ def func(x):
     geom = dde.geometry.Sphere([0, 0, 0], 1)
     bc = dde.DirichletBC(geom, func, lambda _, on_boundary: on_boundary)
 
-    disc = dde.data.fpde.Discretization(3, "dynamic", [8, 8, 100])
     data = dde.data.FPDE(
-        geom, fpde, alpha, bc, disc, num_domain=256, num_boundary=1, solution=func
+        geom, fpde, alpha, bc, [8, 8, 100], num_domain=256, num_boundary=1, solution=func
     )
 
     net = dde.maps.FNN([3] + [20] * 4 + [1], "tanh", "Glorot normal")

examples/fractional_diffusion_1d.py

@@ -43,18 +43,16 @@ def func(x):
     ic = dde.IC(geomtime, func, lambda _, on_initial: on_initial)
 
     # Static auxiliary points
-    disc = dde.data.fpde.Discretization(1, "static", [52])
     data = dde.data.TimeFPDE(
-        geomtime, fpde, alpha, [bc, ic], disc, num_domain=400, solution=func
+        geomtime, fpde, alpha, [bc, ic], [52], meshtype="static", num_domain=400, solution=func
     )
     # Dynamic auxiliary points
-    # disc = dde.data.fpde.Discretization(1, "dynamic", [100])
     # data = dde.data.TimeFPDE(
     #     geomtime,
     #     fpde,
     #     alpha,
     #     [bc, ic],
-    #     disc,
+    #     [100],
     #     num_domain=20,
     #     num_boundary=1,
     #     num_initial=1,