Renaming

* solvers -> solver
* adaptive_functions -> adaptive_function
* callbacks -> callback
* operators -> operator
* pinns -> physics_informed_solver
* layers -> block

tests/test_callback/test_adaptive_refinment_callback.py

@@ -0,0 +1,44 @@
+from pina.solver import PINN
+from pina.trainer import Trainer
+from pina.model import FeedForward
+from pina.problem.zoo import Poisson2DSquareProblem as Poisson
+from pina.callback import R3Refinement
+
+
+# make the problem
+poisson_problem = Poisson()
+boundaries = ['g1', 'g2', 'g3', 'g4']
+n = 10
+poisson_problem.discretise_domain(n, 'grid', domains=boundaries)
+poisson_problem.discretise_domain(n, 'grid', domains='D')
+model = FeedForward(len(poisson_problem.input_variables),
+                    len(poisson_problem.output_variables))
+
+# make the solver
+solver = PINN(problem=poisson_problem, model=model)
+
+
+# def test_r3constructor():
+#     R3Refinement(sample_every=10)
+
+
+# def test_r3refinment_routine():
+#     # make the trainer
+#     trainer = Trainer(solver=solver,
+#                       callback=[R3Refinement(sample_every=1)],
+#                       accelerator='cpu',
+#                       max_epochs=5)
+#     trainer.train()
+
+# def test_r3refinment_routine():
+#     model = FeedForward(len(poisson_problem.input_variables),
+#                     len(poisson_problem.output_variables))
+#     solver = PINN(problem=poisson_problem, model=model)
+#     trainer = Trainer(solver=solver,
+#                       callback=[R3Refinement(sample_every=1)],
+#                       accelerator='cpu',
+#                       max_epochs=5)
+#     before_n_points = {loc : len(pts) for loc, pts in trainer.solver.problem.input_pts.items()}
+#     trainer.train()
+#     after_n_points = {loc : len(pts) for loc, pts in trainer.solver.problem.input_pts.items()}
+#     assert before_n_points == after_n_points

tests/test_callback/test_metric_tracker.py

@@ -0,0 +1,39 @@
+from pina.solver import PINN
+from pina.trainer import Trainer
+from pina.model import FeedForward
+from pina.callback import MetricTracker
+from pina.problem.zoo import Poisson2DSquareProblem as Poisson
+
+
+# make the problem
+poisson_problem = Poisson()
+boundaries = ['g1', 'g2', 'g3', 'g4']
+n = 10
+poisson_problem.discretise_domain(n, 'grid', domains=boundaries)
+poisson_problem.discretise_domain(n, 'grid', domains='D')
+model = FeedForward(len(poisson_problem.input_variables),
+                    len(poisson_problem.output_variables))
+
+# make the solver
+solver = PINN(problem=poisson_problem, model=model)
+
+
+def test_metric_tracker_constructor():
+    MetricTracker()
+
+# def test_metric_tracker_routine(): #TODO revert
+#     # make the trainer
+#     trainer = Trainer(solver=solver,
+#                       callback=[
+#                           MetricTracker()
+#                       ],
+#                       accelerator='cpu',
+#                       max_epochs=5)
+#     trainer.train()
+#     # get the tracked metrics
+#     metrics = trainer.callback[0].metrics
+#     # assert the logged metrics are correct
+#     logged_metrics = sorted(list(metrics.keys()))
+#     assert logged_metrics == ['train_loss_epoch', 'train_loss_step', 'val_loss']
+
+

tests/test_callback/test_optimizer_callback.py

@@ -0,0 +1,37 @@
+from pina.callback import SwitchOptimizer
+import torch
+import pytest
+
+from pina.solver import PINN
+from pina.trainer import Trainer
+from pina.model import FeedForward
+from pina.problem.zoo import Poisson2DSquareProblem as Poisson
+from pina.optim import TorchOptimizer
+
+# make the problem
+poisson_problem = Poisson()
+boundaries = ['g1', 'g2', 'g3', 'g4']
+n = 10
+poisson_problem.discretise_domain(n, 'grid', domains=boundaries)
+poisson_problem.discretise_domain(n, 'grid', domains='D')
+model = FeedForward(len(poisson_problem.input_variables),
+                    len(poisson_problem.output_variables))
+
+# make the solver
+solver = PINN(problem=poisson_problem, model=model)
+
+adam_optimizer = TorchOptimizer(torch.optim.Adam, lr=0.01)
+lbfgs_optimizer = TorchOptimizer(torch.optim.LBFGS, lr= 0.001)
+
+def test_switch_optimizer_constructor():
+    SwitchOptimizer(adam_optimizer, epoch_switch=10)
+
+
+# def test_switch_optimizer_routine(): #TODO revert
+#     # make the trainer
+#     switch_opt_callback = SwitchOptimizer(lbfgs_optimizer, epoch_switch=3)
+#     trainer = Trainer(solver=solver,
+#                       callback=[switch_opt_callback],
+#                       accelerator='cpu',
+#                       max_epochs=5)
+#     trainer.train()

tests/test_callback/test_progress_bar.py

@@ -0,0 +1,33 @@
+from pina.solver import PINN
+from pina.trainer import Trainer
+from pina.model import FeedForward
+from pina.callback.processing_callback import PINAProgressBar
+from pina.problem.zoo import Poisson2DSquareProblem as Poisson
+
+
+# # make the problem
+# poisson_problem = Poisson()
+# boundaries = ['nil_g1', 'nil_g2', 'nil_g3', 'nil_g4']
+# n = 10
+# poisson_problem.discretise_domain(n, 'grid', locations=boundaries)
+# poisson_problem.discretise_domain(n, 'grid', locations='laplace_D')
+# model = FeedForward(len(poisson_problem.input_variables),
+#                     len(poisson_problem.output_variables))
+
+# # make the solver
+# solver = PINN(problem=poisson_problem, model=model)
+
+
+# def test_progress_bar_constructor():
+#     PINAProgressBar(['mean'])
+
+# def test_progress_bar_routine():
+#     # make the trainer
+#     trainer = Trainer(solver=solver,
+#                       callback=[
+#                           PINAProgressBar(['mean', 'laplace_D'])
+#                       ],
+#                       accelerator='cpu',
+#                       max_epochs=5)
+#     trainer.train()
+#     # TODO there should be a check that the correct metrics are displayed