Skip to content

Commit 8cf5daa

Browse files
MatteB03MatteB03
committed
Renaming
* solvers -> solver * adaptive_functions -> adaptive_function * callbacks -> callback * operators -> operator * pinns -> physics_informed_solver * layers -> block
1 parent 2d65749 commit 8cf5daa

File tree

3 files changed

+184
-25
lines changed

3 files changed

+184
-25
lines changed

‎tutorials/tutorial15/mus.py‎

Lines changed: 134 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,134 @@
1+
import warnings
2+
import torch
3+
import scipy.io as io
4+
import numpy as np
5+
from scipy.io import loadmat
6+
7+
warnings.filterwarnings('ignore')
8+
9+
from pina.problem import SpatialProblem, TimeDependentProblem
10+
from pina.operator import grad, laplacian
11+
from pina import Condition, LabelTensor
12+
from pina.domain import CartesianDomain
13+
from pina.equation import Equation, FixedValue, FixedGradient
14+
import matplotlib.pyplot as plt
15+
16+
from lightning.pytorch.loggers import TensorBoardLogger
17+
from pina import Trainer
18+
from pina.solver import PINN, RBAPINN, SelfAdaptivePINN as SAPINN
19+
from pina.model import FeedForward
20+
from pina.callback import MetricTracker, PINAProgressBar, SwitchOptimizer
21+
from pina.loss import LpLoss
22+
23+
from pytorch_lightning import seed_everything
24+
from pina.optim import TorchOptimizer
25+
26+
import matplotlib.pyplot as plt
27+
28+
# List to store results for each mu
29+
results = []
30+
31+
mus=[0.1,0.2,0.3,0.5,0.8,1,1.2,1.5,2,4,5,10]
32+
33+
for value in mus:
34+
class TimeSpaceProblem(TimeDependentProblem, SpatialProblem):
35+
output_variables = ["u"]
36+
spatial_domain = CartesianDomain({"x": [0, 1]})
37+
temporal_domain = CartesianDomain({"t": [0, 1]})
38+
39+
# Defining the PDE equation
40+
def equation_4p5(input_, output_):
41+
u_t = grad(output_, input_, components=["u"], d=["t"])
42+
nabla_u = laplacian(output_, input_, components=["u"], d=["x"])
43+
u = output_.extract(["u"])
44+
mu = value
45+
46+
res = u_t - mu * nabla_u + u**3 - u
47+
return res
48+
49+
# Conditions
50+
conditions = {
51+
"step1": Condition(
52+
domain=CartesianDomain({"x": [0, 0.249], "t": 0}),
53+
equation=FixedValue(0)),
54+
"step2": Condition(
55+
domain=CartesianDomain({"x": [0.25, 0.75], "t": 0}),
56+
equation=FixedValue(1)),
57+
"step3": Condition(
58+
domain=CartesianDomain({"x": [0.751, 1], "t": 0}),
59+
equation=FixedValue(0)),
60+
"L_u": Condition(
61+
domain=CartesianDomain({"x": [0, 1], "t": [0, 1]}),
62+
equation=Equation(equation_4p5)),
63+
"u0": Condition(
64+
domain=CartesianDomain({"x": 0, "t": [0, 1]}),
65+
equation=FixedValue(0)),
66+
"u1": Condition(
67+
domain=CartesianDomain({"x": 1, "t": [0, 1]}),
68+
equation=FixedValue(0))
69+
}
70+
71+
problem = TimeSpaceProblem()
72+
problem.discretise_domain(4000, "random", domains=["L_u"])
73+
problem.discretise_domain(250, "grid", domains=["step1", "step3"])
74+
problem.discretise_domain(501, "grid", domains=["step2"])
75+
problem.discretise_domain(1001, "grid", domains=["u0", "u1"])
76+
77+
# Setting the seed for reproducibility
78+
seed_everything(42, workers=True)
79+
80+
# Build the model
81+
model = FeedForward(
82+
layers=[16, 16, 16, 16],
83+
func=torch.nn.Tanh,
84+
output_dimensions=len(problem.output_variables),
85+
input_dimensions=len(problem.input_variables),
86+
)
87+
88+
pinn = PINN(
89+
problem,
90+
model,
91+
optimizer=TorchOptimizer(torch.optim.Adam, lr=1e-4, weight_decay=0),
92+
loss=torch.nn.MSELoss()
93+
)
94+
95+
trainer = Trainer(
96+
solver=pinn,
97+
max_epochs=10000,
98+
accelerator="cpu",
99+
logger=TensorBoardLogger(save_dir="training_logs"),
100+
enable_model_summary=False,
101+
gradient_clip_val=0.7,
102+
callbacks=[MetricTracker()],
103+
train_size=0.9,
104+
val_size=0.0,
105+
test_size=0.1
106+
)
107+
108+
# Train
109+
trainer.train()
110+
trainer.test()
111+
112+
# Test the trained model
113+
input_test = CartesianDomain({"x": [0, 1], "t": [0, 1]}).sample(501, mode='grid')
114+
output_test = pinn(input_test)
115+
u = output_test.extract(["u"])
116+
117+
# Store the results
118+
results.append((value, input_test, u))
119+
120+
# Create subplots
121+
fig, axes = plt.subplots(3, 4, figsize=(24, 16))
122+
axes = axes.flatten()
123+
124+
# Plot results
125+
for i, (mu, input_test, u) in enumerate(results):
126+
ax = axes[i]
127+
scatter = ax.scatter(input_test.extract(["x"]), input_test.extract(["t"]), c=u.detach().numpy())
128+
ax.set_title(f"mu = {mu}")
129+
ax.set_xlabel("x")
130+
ax.set_ylabel("t")
131+
fig.colorbar(scatter, ax=ax)
132+
133+
plt.tight_layout()
134+
plt.show()

‎tutorials/tutorial15/tsproblem.py‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,14 +25,13 @@
2525
class TimeSpaceProblem(TimeDependentProblem, SpatialProblem):
2626
output_variables = ["u"]
2727
spatial_domain = CartesianDomain({"x": [0, 1]})
28-
temporal_domain = CartesianDomain({"t": [0,1]})
28+
temporal_domain = CartesianDomain({"t": [0, 1]})
2929

3030
# defining the ode equation
3131
def equation_4p5(input_, output_):
3232
# computing the derivative
3333
u_t = grad(output_, input_, components=["u"], d=["t"])
3434
nabla_u = laplacian(output_, input_, components=["u"], d=["x"])
35-
3635
u = output_.extract(["u"])
3736
gamma = 1
3837

‎tutorials/tutorial15/tutorial.py‎

Lines changed: 49 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1,43 +1,70 @@
11
import warnings
22
import torch
3-
import scipy.io as io
4-
import numpy as np
5-
from scipy.io import loadmat
63

74
warnings.filterwarnings('ignore')
85

96
from pina.problem import SpatialProblem, TimeDependentProblem
107
from pina.operator import grad, laplacian
11-
from pina import Condition, LabelTensor
8+
from pina import Condition
129
from pina.domain import CartesianDomain
13-
from pina.equation import Equation, FixedValue, FixedGradient
10+
from pina.equation import Equation, FixedValue
1411
import matplotlib.pyplot as plt
1512

1613
from pina import Trainer
17-
from pina.solver import PINN, RBAPINN, SelfAdaptivePINN as SAPINN
14+
from pina.solver import PINN
1815
from pina.model import FeedForward
19-
from pina.callback import MetricTracker, PINAProgressBar, SwitchOptimizer
20-
from pina.loss import LpLoss
16+
from pina.callback import MetricTracker
2117

22-
from tsproblem import TimeSpaceProblem
2318
from pytorch_lightning import seed_everything
2419
from pina.optim import TorchOptimizer
2520

21+
class TimeSpaceProblem(TimeDependentProblem, SpatialProblem):
22+
output_variables = ["u"]
23+
spatial_domain = CartesianDomain({"x": [0, 1]})
24+
temporal_domain = CartesianDomain({"t": [0, 1]})
25+
26+
# defining the ode equation
27+
def equation_4p5(input_, output_):
28+
# computing the derivative
29+
u_t = grad(output_, input_, components=["u"], d=["t"])
30+
nabla_u = laplacian(output_, input_, components=["u"], d=["x"])
31+
u = output_.extract(["u"])
32+
gamma = 2
33+
34+
res = u_t - gamma * nabla_u + u**3 - u
35+
return res
36+
37+
# conditions to hold
38+
# specify the fixed gradient direction (ex x,y...)
39+
conditions = {
40+
"step1": Condition(
41+
domain=CartesianDomain({"x": [0,0.249], "t": 0}),
42+
equation=FixedValue(0)),
43+
"step2": Condition(
44+
domain=CartesianDomain({"x": [0.25,0.75], "t": 0}),
45+
equation=FixedValue(1)),
46+
"step3": Condition(
47+
domain=CartesianDomain({"x": [0.751,1], "t": 0}),
48+
equation=FixedValue(0)),
49+
"L_u": Condition(
50+
domain=CartesianDomain({"x":[0,1],"t":[0,1]}),
51+
equation=Equation(equation_4p5)),
52+
"u0":Condition(
53+
domain=CartesianDomain({"x":0,"t":[0,1]}),
54+
equation= FixedValue(0)),
55+
"u1":Condition(
56+
domain=CartesianDomain({"x":1,"t":[0,1]}),
57+
equation= FixedValue(0))
58+
}
59+
60+
2661
problem = TimeSpaceProblem()
2762

2863
problem.discretise_domain(4000, "random", domains=["L_u"])
2964
problem.discretise_domain(250, "grid", domains=["step1", "step3"])
30-
problem.discretise_domain(251, "grid", domains=["step2"])
65+
problem.discretise_domain(501, "grid", domains=["step2"])
3166
problem.discretise_domain(1001, "grid", domains=["u0","u1"])
3267

33-
#print("Input points:", problem.input_pts)
34-
35-
# from pina import Plotter
36-
37-
# pl = Plotter()
38-
# pl.plot_samples(problem=problem)#,variables='spatial')
39-
40-
4168
# setting the seed for reproducibility
4269
seed_everything(42, workers=True)
4370

@@ -51,14 +78,14 @@
5178
pinn = PINN(
5279
problem,
5380
model,
54-
optimizer=TorchOptimizer(torch.optim.Adam, lr=1e-4, weight_decay=0),
81+
#optimizer=TorchOptimizer(torch.optim.Adam, lr=1e-4, weight_decay=0),
5582
loss=torch.nn.MSELoss()
5683
)
5784

5885
from lightning.pytorch.loggers import TensorBoardLogger
5986
trainer = Trainer(
6087
solver=pinn,
61-
max_epochs=10000,#logger=TensorBoardLogger('tutorial_logs'),
88+
max_epochs=10000,
6289
accelerator="cpu",
6390
logger=TensorBoardLogger(save_dir="training_logs"),
6491
enable_model_summary=False,
@@ -73,13 +100,12 @@
73100
trainer.train()
74101
trainer.test()
75102

76-
input_test = CartesianDomain({"x": [0, 1], "t": [0,1]}).sample(1001, mode='grid')
77-
#input_test = CartesianDomain({"x": [0.1, 20], "t": [1, 70]}).sample(100, mode='grid')
103+
input_test = CartesianDomain({"x": [0, 1], "t": [0, 1]}).sample(501, mode='grid')
78104
output_test = pinn(input_test)
79105
u = output_test.extract(["u"])
80106

81107
plt.figure(figsize=(6, 5))
82-
plt.scatter(input_test.extract(["x"]), input_test.extract(["t"]), c=u.detach().numpy(), cmap='coolwarm')
108+
plt.scatter(input_test.extract(["x"]), input_test.extract(["t"]), c=u.detach().numpy())
83109
plt.colorbar()
84110
plt.title('u')
85111
plt.grid()

0 commit comments

Comments
 (0)