Docs modifications to use QuadratureTraining instead of GridTraining

docs/src/tutorials/constraints.md

@@ -65,7 +65,7 @@ function norm_loss_function(phi, θ, p)
 end
 
 discretization = PhysicsInformedNN(chain,
-                                   GridTraining(dx),
+                                   QuadratureTraining(),
                                    additional_loss = norm_loss_function)
 
 @named pdesystem = PDESystem(eq, bcs, domains, [x], [p(x)])

docs/src/tutorials/derivative_neural_network.md

@@ -93,9 +93,9 @@ input_ = length(domains)
 n = 15
 chain = [Lux.Chain(Dense(input_, n, Lux.σ), Dense(n, n, Lux.σ), Dense(n, 1)) for _ in 1:7]
 
-grid_strategy = NeuralPDE.GridTraining(0.07)
+training_strategy = NeuralPDE.QuadratureTraining()
 discretization = NeuralPDE.PhysicsInformedNN(chain,
-                                             grid_strategy)
+                                             training_strategy)
 
 vars = [u1(t, x), u2(t, x), u3(t, x), Dxu1(t, x), Dtu1(t, x), Dxu2(t, x), Dtu2(t, x)]
 @named pdesystem = PDESystem(eqs_, bcs__, domains, [t, x], vars)

docs/src/tutorials/gpu.md

@@ -84,7 +84,7 @@ chain = Chain(Dense(3, inner, Lux.σ),
               Dense(inner, inner, Lux.σ),
               Dense(inner, 1))
 
-strategy = GridTraining(0.05)
+strategy = QuadratureTraining()
 ps = Lux.setup(Random.default_rng(), chain)[1]
 ps = ps |> ComponentArray |> gpu .|> Float64
 discretization = PhysicsInformedNN(chain,

docs/src/tutorials/integro_diff.md

@@ -57,7 +57,7 @@ bcs = [i(0.0) ~ 0.0]
 domains = [t ∈ Interval(0.0, 2.0)]
 chain = Chain(Dense(1, 15, Flux.σ), Dense(15, 1)) |> f64
 
-strategy_ = GridTraining(0.05)
+strategy_ = QuadratureTraining()
 discretization = PhysicsInformedNN(chain,
                                    strategy_)
 @named pde_system = PDESystem(eq, bcs, domains, [t], [i(t)])

docs/src/tutorials/low_level.md

@@ -35,12 +35,9 @@ bcs = [u(0, x) ~ -sin(pi * x),
 domains = [t ∈ Interval(0.0, 1.0),
     x ∈ Interval(-1.0, 1.0)]
 
-# Discretization
-dx = 0.05
-
 # Neural network
 chain = Lux.Chain(Dense(2, 16, Lux.σ), Dense(16, 16, Lux.σ), Dense(16, 1))
-strategy = NeuralPDE.GridTraining(dx)
+strategy = NeuralPDE.QuadratureTraining
 
 indvars = [t, x]
 depvars = [u(t, x)]

docs/src/tutorials/param_estim.md

@@ -113,7 +113,7 @@ Then finally defining and optimizing using the `PhysicsInformedNN` interface.
 
 ```@example param_estim
 discretization = NeuralPDE.PhysicsInformedNN([chain1, chain2, chain3],
-                                             NeuralPDE.GridTraining(dt), param_estim = true,
+                                             NeuralPDE.QuadratureTraining(), param_estim = true,
                                              additional_loss = additional_loss)
 @named pde_system = PDESystem(eqs, bcs, domains, [t], [x(t), y(t), z(t)], [σ_, ρ, β],
                               defaults = Dict([p .=> 1.0 for p in [σ_, ρ, β]]))