Trying to fix formatting done by mistake in commit-978e115

SciML · Jul 4, 2023 · 7980448 · 7980448
1 parent e817b93
commit 7980448
Show file tree

Hide file tree

Showing 42 changed files with 797 additions and 832 deletions.
diff --git a/README.md b/README.md
@@ -93,9 +93,9 @@ xs, ys = [infimum(d.domain):(dx / 10):supremum(d.domain) for d in domains]
 analytic_sol_func(x, y) = (sin(pi * x) * sin(pi * y)) / (2pi^2)
 
 u_predict = reshape([first(phi([x, y], res.minimizer)) for x in xs for y in ys],
-    (length(xs), length(ys)))
+                    (length(xs), length(ys)))
 u_real = reshape([analytic_sol_func(x, y) for x in xs for y in ys],
-    (length(xs), length(ys)))
+                 (length(xs), length(ys)))
 diff_u = abs.(u_predict .- u_real)
 
 using Plots

diff --git a/docs/make.jl b/docs/make.jl
@@ -9,22 +9,22 @@ using Plots
 include("pages.jl")
 
 makedocs(sitename = "NeuralPDE.jl",
-    authors = "#",
-    clean = true,
-    doctest = false,
-    modules = [NeuralPDE],
-    strict = [
-        :doctest,
-        :linkcheck,
-        :parse_error,
-        :example_block,
-        # Other available options are
-        # :autodocs_block, :cross_references, :docs_block, :eval_block, :example_block, :footnote, :meta_block, :missing_docs, :setup_block
-    ],
-    format = Documenter.HTML(analytics = "UA-90474609-3",
-        assets = ["assets/favicon.ico"],
-        canonical = "https://docs.sciml.ai/NeuralPDE/stable/"),
-    pages = pages)
+         authors = "#",
+         clean = true,
+         doctest = false,
+         modules = [NeuralPDE],
+         strict = [
+             :doctest,
+             :linkcheck,
+             :parse_error,
+             :example_block,
+             # Other available options are
+             # :autodocs_block, :cross_references, :docs_block, :eval_block, :example_block, :footnote, :meta_block, :missing_docs, :setup_block
+         ],
+         format = Documenter.HTML(analytics = "UA-90474609-3",
+                                  assets = ["assets/favicon.ico"],
+                                  canonical = "https://docs.sciml.ai/NeuralPDE/stable/"),
+         pages = pages)
 
 deploydocs(repo = "github.com/SciML/NeuralPDE.jl.git";
-    push_preview = true)
+           push_preview = true)
diff --git a/docs/pages.jl b/docs/pages.jl
@@ -1,28 +1,28 @@
 pages = ["index.md",
     "ODE PINN Tutorials" => Any["Introduction to NeuralPDE for ODEs" => "tutorials/ode.md"
-    #"examples/nnrode_example.md", # currently incorrect
-    ],
+                                #"examples/nnrode_example.md", # currently incorrect
+                                ],
     "PDE PINN Tutorials" => Any["Introduction to NeuralPDE for PDEs" => "tutorials/pdesystem.md",
-        "Using GPUs" => "tutorials/gpu.md",
-        "Defining Systems of PDEs" => "tutorials/systems.md",
-        "Imposing Constraints" => "tutorials/constraints.md",
-        "The symbolic_discretize Interface" => "tutorials/low_level.md",
-        "Optimising Parameters (Solving Inverse Problems)" => "tutorials/param_estim.md",
-        "Solving Integro Differential Equations" => "tutorials/integro_diff.md",
-        "Transfer Learning with Neural Adapter" => "tutorials/neural_adapter.md",
-        "The Derivative Neural Network Approximation" => "tutorials/derivative_neural_network.md"],
+                                "Using GPUs" => "tutorials/gpu.md",
+                                "Defining Systems of PDEs" => "tutorials/systems.md",
+                                "Imposing Constraints" => "tutorials/constraints.md",
+                                "The symbolic_discretize Interface" => "tutorials/low_level.md",
+                                "Optimising Parameters (Solving Inverse Problems)" => "tutorials/param_estim.md",
+                                "Solving Integro Differential Equations" => "tutorials/integro_diff.md",
+                                "Transfer Learning with Neural Adapter" => "tutorials/neural_adapter.md",
+                                "The Derivative Neural Network Approximation" => "tutorials/derivative_neural_network.md"],
     "Extended Examples" => Any["examples/wave.md",
-        "examples/3rd.md",
-        "examples/ks.md",
-        "examples/heterogeneous.md",
-        "examples/linear_parabolic.md",
-        "examples/nonlinear_elliptic.md",
-        "examples/nonlinear_hyperbolic.md"],
+                               "examples/3rd.md",
+                               "examples/ks.md",
+                               "examples/heterogeneous.md",
+                               "examples/linear_parabolic.md",
+                               "examples/nonlinear_elliptic.md",
+                               "examples/nonlinear_hyperbolic.md"],
     "Manual" => Any["manual/ode.md",
-        "manual/pinns.md",
-        "manual/training_strategies.md",
-        "manual/adaptive_losses.md",
-        "manual/logging.md",
-        "manual/neural_adapters.md"],
+                    "manual/pinns.md",
+                    "manual/training_strategies.md",
+                    "manual/adaptive_losses.md",
+                    "manual/logging.md",
+                    "manual/neural_adapters.md"],
     "Developer Documentation" => Any["developer/debugging.md"],
 ]
diff --git a/docs/src/developer/debugging.md b/docs/src/developer/debugging.md
@@ -58,8 +58,8 @@ strategy = NeuralPDE.GridTraining(dx)
 integral = NeuralPDE.get_numeric_integral(strategy, indvars, multioutput, chain, derivative)
 
 _pde_loss_function = NeuralPDE.build_loss_function(eq, indvars, depvars, phi, derivative,
-    integral, multioutput, init_params,
-    strategy)
+                                                   integral, multioutput, init_params,
+                                                   strategy)
 ```
 
 ```
@@ -83,9 +83,9 @@ julia> bc_indvars = NeuralPDE.get_variables(bcs,indvars,depvars)
 
 ```julia
 _bc_loss_functions = [NeuralPDE.build_loss_function(bc, indvars, depvars,
-    phi, derivative, integral, multioutput,
-    init_params, strategy,
-    bc_indvars = bc_indvar)
+                                                    phi, derivative, integral, multioutput,
+                                                    init_params, strategy,
+                                                    bc_indvars = bc_indvar)
                       for (bc, bc_indvar) in zip(bcs, bc_indvars)]
 ```
 
@@ -126,7 +126,7 @@ julia> expr_bc_loss_functions = [NeuralPDE.build_symbolic_loss_function(bc,indva
 
 ```julia
 train_sets = NeuralPDE.generate_training_sets(domains, dx, [eq], bcs, eltypeθ, indvars,
-    depvars)
+                                              depvars)
 pde_train_set, bcs_train_set = train_sets
 ```
 
@@ -146,7 +146,7 @@ julia> bcs_train_set
 
 ```julia
 pde_bounds, bcs_bounds = NeuralPDE.get_bounds(domains, [eq], bcs, eltypeθ, indvars, depvars,
-    NeuralPDE.StochasticTraining(100))
+                                              NeuralPDE.StochasticTraining(100))
 ```
 
 ```

diff --git a/docs/src/examples/heterogeneous.md b/docs/src/examples/heterogeneous.md
@@ -32,9 +32,9 @@ domains = [x ∈ Interval(0.0, 1.0),
 
 numhid = 3
 chains = [[Lux.Chain(Dense(1, numhid, Lux.σ), Dense(numhid, numhid, Lux.σ),
-    Dense(numhid, 1)) for i in 1:2]
-    [Lux.Chain(Dense(2, numhid, Lux.σ), Dense(numhid, numhid, Lux.σ),
-    Dense(numhid, 1)) for i in 1:2]]
+                     Dense(numhid, 1)) for i in 1:2]
+          [Lux.Chain(Dense(2, numhid, Lux.σ), Dense(numhid, numhid, Lux.σ),
+                     Dense(numhid, 1)) for i in 1:2]]
 discretization = NeuralPDE.PhysicsInformedNN(chains, QuadratureTraining())
 
 @named pde_system = PDESystem(eq, bcs, domains, [x, y], [p(x), q(y), r(x, y), s(y, x)])

diff --git a/docs/src/examples/wave.md b/docs/src/examples/wave.md
@@ -70,9 +70,9 @@ function analytic_sol_func(t, x)
 end
 
 u_predict = reshape([first(phi([t, x], res.u)) for t in ts for x in xs],
-    (length(ts), length(xs)))
+                    (length(ts), length(xs)))
 u_real = reshape([analytic_sol_func(t, x) for t in ts for x in xs],
-    (length(ts), length(xs)))
+                 (length(ts), length(xs)))
 
 diff_u = abs.(u_predict .- u_real)
 p1 = plot(ts, xs, u_real, linetype = :contourf, title = "analytic");
@@ -141,16 +141,16 @@ domains = [t ∈ Interval(0.0, L),
 inn = 25
 innd = 4
 chain = [[Lux.Chain(Dense(2, inn, Lux.tanh),
-    Dense(inn, inn, Lux.tanh),
-    Dense(inn, inn, Lux.tanh),
-    Dense(inn, 1)) for _ in 1:3]
-    [Lux.Chain(Dense(2, innd, Lux.tanh), Dense(innd, 1)) for _ in 1:2]]
+                    Dense(inn, inn, Lux.tanh),
+                    Dense(inn, inn, Lux.tanh),
+                    Dense(inn, 1)) for _ in 1:3]
+         [Lux.Chain(Dense(2, innd, Lux.tanh), Dense(innd, 1)) for _ in 1:2]]
 
 strategy = GridTraining(0.02)
 discretization = PhysicsInformedNN(chain, strategy;)
 
 @named pde_system = PDESystem(eq, bcs, domains, [t, x],
-    [u(t, x), Dxu(t, x), Dtu(t, x), O1(t, x), O2(t, x)])
+                              [u(t, x), Dxu(t, x), Dtu(t, x), O1(t, x), O2(t, x)])
 prob = discretize(pde_system, discretization)
 sym_prob = NeuralPDE.symbolic_discretize(pde_system, discretization)
 
@@ -206,7 +206,7 @@ ts, xs = [infimum(d.domain):0.01:supremum(d.domain) for d in domains]
 u_predict = reshape([first(phi([t, x], res.u.depvar.u)) for
                      t in ts for x in xs], (length(ts), length(xs)))
 u_real = reshape([analytic_sol_func(t, x) for t in ts for x in xs],
-    (length(ts), length(xs)))
+                 (length(ts), length(xs)))
 
 diff_u = abs.(u_predict .- u_real)
 p1 = plot(ts, xs, u_real, linetype = :contourf, title = "analytic");

diff --git a/docs/src/index.md b/docs/src/index.md
@@ -1,7 +1,7 @@
 # NeuralPDE.jl: Automatic Physics-Informed Neural Networks (PINNs)
 
-[NeuralPDE.jl](https://github.com/SciML/NeuralPDE.jl) is a solver package which
-consists of neural network solvers for partial differential equations using
+[NeuralPDE.jl](https://github.com/SciML/NeuralPDE.jl) is a solver package which 
+consists of neural network solvers for partial differential equations using 
 physics-informed neural networks (PINNs) and the ability to generate neural
 networks which both approximate physical laws and real data simultaniously.
 

diff --git a/docs/src/tutorials/constraints.md b/docs/src/tutorials/constraints.md
@@ -49,9 +49,9 @@ domains = [x ∈ Interval(x_0, x_end)]
 # Neural network
 inn = 18
 chain = Lux.Chain(Dense(1, inn, Lux.σ),
-    Dense(inn, inn, Lux.σ),
-    Dense(inn, inn, Lux.σ),
-    Dense(inn, 1))
+                  Dense(inn, inn, Lux.σ),
+                  Dense(inn, inn, Lux.σ),
+                  Dense(inn, 1))
 
 lb = [x_0]
 ub = [x_end]
@@ -65,8 +65,8 @@ function norm_loss_function(phi, θ, p)
 end
 
 discretization = PhysicsInformedNN(chain,
-    GridTraining(dx),
-    additional_loss = norm_loss_function)
+                                   GridTraining(dx),
+                                   additional_loss = norm_loss_function)
 
 @named pdesystem = PDESystem(eq, bcs, domains, [x], [p(x)])
 prob = discretize(pdesystem, discretization)

diff --git a/docs/src/tutorials/derivative_neural_network.md b/docs/src/tutorials/derivative_neural_network.md
@@ -95,7 +95,7 @@ chain = [Lux.Chain(Dense(input_, n, Lux.σ), Dense(n, n, Lux.σ), Dense(n, 1)) f
 
 grid_strategy = NeuralPDE.GridTraining(0.07)
 discretization = NeuralPDE.PhysicsInformedNN(chain,
-    grid_strategy)
+                                             grid_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)

diff --git a/docs/src/tutorials/gpu.md b/docs/src/tutorials/gpu.md
@@ -32,10 +32,10 @@ using the `gpu` function on the initial parameters, like:
 ```julia
 using Lux, ComponentArrays
 chain = Chain(Dense(3, inner, Lux.σ),
-    Dense(inner, inner, Lux.σ),
-    Dense(inner, inner, Lux.σ),
-    Dense(inner, inner, Lux.σ),
-    Dense(inner, 1))
+              Dense(inner, inner, Lux.σ),
+              Dense(inner, inner, Lux.σ),
+              Dense(inner, inner, Lux.σ),
+              Dense(inner, 1))
 ps = Lux.setup(Random.default_rng(), chain)[1]
 ps = ps |> ComponentArray |> gpu .|> Float64
 ```
@@ -79,17 +79,17 @@ domains = [t ∈ Interval(t_min, t_max),
 # Neural network
 inner = 25
 chain = Chain(Dense(3, inner, Lux.σ),
-    Dense(inner, inner, Lux.σ),
-    Dense(inner, inner, Lux.σ),
-    Dense(inner, inner, Lux.σ),
-    Dense(inner, 1))
+              Dense(inner, inner, Lux.σ),
+              Dense(inner, inner, Lux.σ),
+              Dense(inner, inner, Lux.σ),
+              Dense(inner, 1))
 
 strategy = GridTraining(0.05)
 ps = Lux.setup(Random.default_rng(), chain)[1]
 ps = ps |> ComponentArray |> gpu .|> Float64
 discretization = PhysicsInformedNN(chain,
-    strategy,
-    init_params = ps)
+                                   strategy,
+                                   init_params = ps)
 
 @named pde_system = PDESystem(eq, bcs, domains, [t, x, y], [u(t, x, y)])
 prob = discretize(pde_system, discretization)
@@ -127,9 +127,9 @@ function plot_(res)
     anim = @animate for (i, t) in enumerate(0:0.05:t_max)
         @info "Animating frame $i..."
         u_real = reshape([analytic_sol_func(t, x, y) for x in xs for y in ys],
-            (length(xs), length(ys)))
+                         (length(xs), length(ys)))
         u_predict = reshape([Array(phi(gpu([t, x, y]), res.u))[1] for x in xs for y in ys],
-            length(xs), length(ys))
+                            length(xs), length(ys))
         u_error = abs.(u_predict .- u_real)
         title = @sprintf("predict, t = %.3f", t)
         p1 = plot(xs, ys, u_predict, st = :surface, label = "", title = title)

diff --git a/docs/src/tutorials/integro_diff.md b/docs/src/tutorials/integro_diff.md
@@ -59,7 +59,7 @@ chain = Chain(Dense(1, 15, Flux.σ), Dense(15, 1)) |> f64
 
 strategy_ = GridTraining(0.05)
 discretization = PhysicsInformedNN(chain,
-    strategy_)
+                                   strategy_)
 @named pde_system = PDESystem(eq, bcs, domains, [t], [i(t)])
 prob = NeuralPDE.discretize(pde_system, discretization)
 callback = function (p, l)

diff --git a/docs/src/tutorials/low_level.md b/docs/src/tutorials/low_level.md
@@ -71,7 +71,7 @@ f_ = OptimizationFunction(loss_function, Optimization.AutoZygote())
 prob = Optimization.OptimizationProblem(f_, sym_prob.flat_init_params)
 
 res = Optimization.solve(prob, OptimizationOptimJL.BFGS(); callback = callback,
-    maxiters = 2000)
+                         maxiters = 2000)
 ```
 
 And some analysis:
@@ -81,7 +81,7 @@ using Plots
 
 ts, xs = [infimum(d.domain):dx:supremum(d.domain) for d in domains]
 u_predict_contourf = reshape([first(phi([t, x], res.u)) for t in ts for x in xs],
-    length(xs), length(ts))
+                             length(xs), length(ts))
 plot(ts, xs, u_predict_contourf, linetype = :contourf, title = "predict")
 
 u_predict = [[first(phi([t, x], res.u)) for x in xs] for t in ts]