folivo/PINA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Formatting

Browse Source 
* Adding black as dev dependency
* Formatting pina code
* Formatting tests
This commit is contained in:
Dario Coscia
2025-02-24 11:26:49 +01:00
committed by Nicola Demo
parent 4c4482b155
commit 42ab1a666b
77 changed files with 1170 additions and 924 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
pina/problem/zoo/__init__.py
View File

@@ -1,9 +1,9 @@
__all__ = [
'Poisson2DSquareProblem',
'SupervisedProblem',
'InversePoisson2DSquareProblem',
'DiffusionReactionProblem',
'InverseDiffusionReactionProblem'
"Poisson2DSquareProblem",
"SupervisedProblem",
"InversePoisson2DSquareProblem",
"DiffusionReactionProblem",
"InverseDiffusionReactionProblem",
]
from .poisson_2d_square import Poisson2DSquareProblem

46
pina/problem/zoo/diffusion_reaction.py
View File

@@ -1,4 +1,4 @@
""" Definition of the diffusion-reaction problem."""
"""Definition of the diffusion-reaction problem."""
import torch
from pina import Condition
@@ -7,17 +7,22 @@ from pina.equation.equation import Equation
from pina.domain import CartesianDomain
from pina.operator import grad
def diffusion_reaction(input_, output_):
"""
Implementation of the diffusion-reaction equation.
"""
x = input_.extract('x')
t = input_.extract('t')
u_t = grad(output_, input_, d='t')
u_x = grad(output_, input_, d='x')
u_xx = grad(u_x, input_, d='x')
r = torch.exp(-t) * (1.5 * torch.sin(2*x) + (8/3) * torch.sin(3*x) +
(15/4) * torch.sin(4*x) + (63/8) * torch.sin(8*x))
x = input_.extract("x")
t = input_.extract("t")
u_t = grad(output_, input_, d="t")
u_x = grad(output_, input_, d="x")
u_xx = grad(u_x, input_, d="x")
r = torch.exp(-t) * (
1.5 * torch.sin(2 * x)
+ (8 / 3) * torch.sin(3 * x)
+ (15 / 4) * torch.sin(4 * x)
+ (63 / 8) * torch.sin(8 * x)
)
return u_t - u_xx - r
@@ -26,20 +31,25 @@ class DiffusionReactionProblem(TimeDependentProblem, SpatialProblem):
Implementation of the diffusion-reaction problem on the spatial interval
[-pi, pi] and temporal interval [0,1].
"""
output_variables = ['u']
spatial_domain = CartesianDomain({'x': [-torch.pi, torch.pi]})
temporal_domain = CartesianDomain({'t': [0, 1]})
output_variables = ["u"]
spatial_domain = CartesianDomain({"x": [-torch.pi, torch.pi]})
temporal_domain = CartesianDomain({"t": [0, 1]})
conditions = {
'D': Condition(
domain=CartesianDomain({'x': [-torch.pi, torch.pi], 't': [0, 1]}),
equation=Equation(diffusion_reaction))
"D": Condition(
domain=CartesianDomain({"x": [-torch.pi, torch.pi], "t": [0, 1]}),
equation=Equation(diffusion_reaction),
)
}
def _solution(self, pts):
t = pts.extract('t')
x = pts.extract('x')
t = pts.extract("t")
x = pts.extract("x")
return torch.exp(-t) * (
torch.sin(x) + (1/2)*torch.sin(2*x) + (1/3)*torch.sin(3*x) +
(1/4)*torch.sin(4*x) + (1/8)*torch.sin(8*x)
torch.sin(x)
+ (1 / 2) * torch.sin(2 * x)
+ (1 / 3) * torch.sin(3 * x)
+ (1 / 4) * torch.sin(4 * x)
+ (1 / 8) * torch.sin(8 * x)
)

66
pina/problem/zoo/inverse_diffusion_reaction.py
View File

@@ -1,4 +1,4 @@
""" Definition of the diffusion-reaction problem."""
"""Definition of the diffusion-reaction problem."""
import torch
from pina import Condition, LabelTensor
@@ -7,45 +7,57 @@ from pina.equation.equation import Equation
from pina.domain import CartesianDomain
from pina.operator import grad
def diffusion_reaction(input_, output_):
"""
Implementation of the diffusion-reaction equation.
"""
x = input_.extract('x')
t = input_.extract('t')
u_t = grad(output_, input_, d='t')
u_x = grad(output_, input_, d='x')
u_xx = grad(u_x, input_, d='x')
r = torch.exp(-t) * (1.5 * torch.sin(2*x) + (8/3) * torch.sin(3*x) +
(15/4) * torch.sin(4*x) + (63/8) * torch.sin(8*x))
x = input_.extract("x")
t = input_.extract("t")
u_t = grad(output_, input_, d="t")
u_x = grad(output_, input_, d="x")
u_xx = grad(u_x, input_, d="x")
r = torch.exp(-t) * (
1.5 * torch.sin(2 * x)
+ (8 / 3) * torch.sin(3 * x)
+ (15 / 4) * torch.sin(4 * x)
+ (63 / 8) * torch.sin(8 * x)
)
return u_t - u_xx - r
class InverseDiffusionReactionProblem(TimeDependentProblem,
SpatialProblem,
InverseProblem):
class InverseDiffusionReactionProblem(
TimeDependentProblem, SpatialProblem, InverseProblem
):
"""
Implementation of the diffusion-reaction inverse problem on the spatial
interval [-pi, pi] and temporal interval [0,1], with unknown parameters
Implementation of the diffusion-reaction inverse problem on the spatial
interval [-pi, pi] and temporal interval [0,1], with unknown parameters
in the interval [-1,1].
"""
output_variables = ['u']
spatial_domain = CartesianDomain({'x': [-torch.pi, torch.pi]})
temporal_domain = CartesianDomain({'t': [0, 1]})
unknown_parameter_domain = CartesianDomain({'mu': [-1, 1]})
output_variables = ["u"]
spatial_domain = CartesianDomain({"x": [-torch.pi, torch.pi]})
temporal_domain = CartesianDomain({"t": [0, 1]})
unknown_parameter_domain = CartesianDomain({"mu": [-1, 1]})
conditions = {
'D': Condition(
domain=CartesianDomain({'x': [-torch.pi, torch.pi], 't': [0, 1]}),
equation=Equation(diffusion_reaction)),
'data' : Condition(
input_points=LabelTensor(torch.randn(10, 2), ['x', 't']),
output_points=LabelTensor(torch.randn(10, 1), ['u'])),
"D": Condition(
domain=CartesianDomain({"x": [-torch.pi, torch.pi], "t": [0, 1]}),
equation=Equation(diffusion_reaction),
),
"data": Condition(
input_points=LabelTensor(torch.randn(10, 2), ["x", "t"]),
output_points=LabelTensor(torch.randn(10, 1), ["u"]),
),
}
def _solution(self, pts):
t = pts.extract('t')
x = pts.extract('x')
t = pts.extract("t")
x = pts.extract("x")
return torch.exp(-t) * (
torch.sin(x) + (1/2)*torch.sin(2*x) + (1/3)*torch.sin(3*x) +
(1/4)*torch.sin(4*x) + (1/8)*torch.sin(8*x)
torch.sin(x)
+ (1 / 2) * torch.sin(2 * x)
+ (1 / 3) * torch.sin(3 * x)
+ (1 / 4) * torch.sin(4 * x)
+ (1 / 8) * torch.sin(8 * x)
)

52
pina/problem/zoo/inverse_poisson_2d_square.py
View File

@@ -1,4 +1,4 @@
""" Definition of the inverse Poisson problem on a square domain."""
"""Definition of the inverse Poisson problem on a square domain."""
import torch
from pina import Condition, LabelTensor
@@ -8,43 +8,49 @@ from pina.domain import CartesianDomain
from pina.equation.equation import Equation
from pina.equation.equation_factory import FixedValue
def laplace_equation(input_, output_, params_):
"""
Implementation of the laplace equation.
"""
force_term = torch.exp(- 2*(input_.extract(['x']) - params_['mu1'])**2
- 2*(input_.extract(['y']) - params_['mu2'])**2)
delta_u = laplacian(output_, input_, components=['u'], d=['x', 'y'])
force_term = torch.exp(
-2 * (input_.extract(["x"]) - params_["mu1"]) ** 2
- 2 * (input_.extract(["y"]) - params_["mu2"]) ** 2
)
delta_u = laplacian(output_, input_, components=["u"], d=["x", "y"])
return delta_u - force_term
class InversePoisson2DSquareProblem(SpatialProblem, InverseProblem):
"""
Implementation of the inverse 2-dimensional Poisson problem
Implementation of the inverse 2-dimensional Poisson problem
on a square domain, with parameter domain [-1, 1] x [-1, 1].
"""
output_variables = ['u']
output_variables = ["u"]
x_min, x_max = -2, 2
y_min, y_max = -2, 2
data_input = LabelTensor(torch.rand(10, 2), ['x', 'y'])
data_output = LabelTensor(torch.rand(10, 1), ['u'])
spatial_domain = CartesianDomain({'x': [x_min, x_max], 'y': [y_min, y_max]})
unknown_parameter_domain = CartesianDomain({'mu1': [-1, 1], 'mu2': [-1, 1]})
data_input = LabelTensor(torch.rand(10, 2), ["x", "y"])
data_output = LabelTensor(torch.rand(10, 1), ["u"])
spatial_domain = CartesianDomain({"x": [x_min, x_max], "y": [y_min, y_max]})
unknown_parameter_domain = CartesianDomain({"mu1": [-1, 1], "mu2": [-1, 1]})
domains = {
'g1': CartesianDomain({'x': [x_min, x_max], 'y': y_max}),
'g2': CartesianDomain({'x': [x_min, x_max], 'y': y_min}),
'g3': CartesianDomain({'x': x_max, 'y': [y_min, y_max]}),
'g4': CartesianDomain({'x': x_min, 'y': [y_min, y_max]}),
'D': CartesianDomain({'x': [x_min, x_max], 'y': [y_min, y_max]}),
"g1": CartesianDomain({"x": [x_min, x_max], "y": y_max}),
"g2": CartesianDomain({"x": [x_min, x_max], "y": y_min}),
"g3": CartesianDomain({"x": x_max, "y": [y_min, y_max]}),
"g4": CartesianDomain({"x": x_min, "y": [y_min, y_max]}),
"D": CartesianDomain({"x": [x_min, x_max], "y": [y_min, y_max]}),
}
conditions = {
'nil_g1': Condition(domain='g1', equation=FixedValue(0.0)),
'nil_g2': Condition(domain='g2', equation=FixedValue(0.0)),
'nil_g3': Condition(domain='g3', equation=FixedValue(0.0)),
'nil_g4': Condition(domain='g4', equation=FixedValue(0.0)),
'laplace_D': Condition(domain='D', equation=Equation(laplace_equation)),
'data': Condition(
input_points=data_input.extract(['x', 'y']),
output_points=data_output)
"nil_g1": Condition(domain="g1", equation=FixedValue(0.0)),
"nil_g2": Condition(domain="g2", equation=FixedValue(0.0)),
"nil_g3": Condition(domain="g3", equation=FixedValue(0.0)),
"nil_g4": Condition(domain="g4", equation=FixedValue(0.0)),
"laplace_D": Condition(domain="D", equation=Equation(laplace_equation)),
"data": Condition(
input_points=data_input.extract(["x", "y"]),
output_points=data_output,
),
}

44
pina/problem/zoo/poisson_2d_square.py
View File

@@ -1,4 +1,4 @@
""" Definition of the Poisson problem on a square domain."""
"""Definition of the Poisson problem on a square domain."""
from pina.problem import SpatialProblem
from pina.operator import laplacian
@@ -8,41 +8,47 @@ from pina.equation.equation import Equation
from pina.equation.equation_factory import FixedValue
import torch
def laplace_equation(input_, output_):
"""
Implementation of the laplace equation.
"""
force_term = (torch.sin(input_.extract(['x']) * torch.pi) *
torch.sin(input_.extract(['y']) * torch.pi))
delta_u = laplacian(output_.extract(['u']), input_)
force_term = torch.sin(input_.extract(["x"]) * torch.pi) * torch.sin(
input_.extract(["y"]) * torch.pi
)
delta_u = laplacian(output_.extract(["u"]), input_)
return delta_u - force_term
my_laplace = Equation(laplace_equation)
class Poisson2DSquareProblem(SpatialProblem):
"""
Implementation of the 2-dimensional Poisson problem on a square domain.
"""
output_variables = ['u']
spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]})
output_variables = ["u"]
spatial_domain = CartesianDomain({"x": [0, 1], "y": [0, 1]})
domains = {
'D': CartesianDomain({'x': [0, 1], 'y': [0, 1]}),
'g1': CartesianDomain({'x': [0, 1], 'y': 1}),
'g2': CartesianDomain({'x': [0, 1], 'y': 0}),
'g3': CartesianDomain({'x': 1, 'y': [0, 1]}),
'g4': CartesianDomain({'x': 0, 'y': [0, 1]}),
"D": CartesianDomain({"x": [0, 1], "y": [0, 1]}),
"g1": CartesianDomain({"x": [0, 1], "y": 1}),
"g2": CartesianDomain({"x": [0, 1], "y": 0}),
"g3": CartesianDomain({"x": 1, "y": [0, 1]}),
"g4": CartesianDomain({"x": 0, "y": [0, 1]}),
}
conditions = {
'nil_g1': Condition(domain='g1', equation=FixedValue(0.0)),
'nil_g2': Condition(domain='g2', equation=FixedValue(0.0)),
'nil_g3': Condition(domain='g3', equation=FixedValue(0.0)),
'nil_g4': Condition(domain='g4', equation=FixedValue(0.0)),
'laplace_D': Condition(domain='D', equation=my_laplace),
"nil_g1": Condition(domain="g1", equation=FixedValue(0.0)),
"nil_g2": Condition(domain="g2", equation=FixedValue(0.0)),
"nil_g3": Condition(domain="g3", equation=FixedValue(0.0)),
"nil_g4": Condition(domain="g4", equation=FixedValue(0.0)),
"laplace_D": Condition(domain="D", equation=my_laplace),
}
def poisson_sol(self, pts):
return -(torch.sin(pts.extract(['x']) * torch.pi) *
torch.sin(pts.extract(['y']) * torch.pi))
return -(
torch.sin(pts.extract(["x"]) * torch.pi)
* torch.sin(pts.extract(["y"]) * torch.pi)
)

8
pina/problem/zoo/supervised_problem.py
View File

@@ -2,6 +2,7 @@ from pina.problem import AbstractProblem
from pina import Condition
from pina import Graph
class SupervisedProblem(AbstractProblem):
"""
A problem definition for supervised learning in PINA.
@@ -15,6 +16,7 @@ class SupervisedProblem(AbstractProblem):
>>> output_data = torch.rand((100, 10))
>>> problem = SupervisedProblem(input_data, output_data)
"""
conditions = dict()
output_variables = None
@@ -29,9 +31,7 @@ class SupervisedProblem(AbstractProblem):
"""
if isinstance(input_, Graph):
input_ = input_.data
self.conditions['data'] = Condition(
input_points=input_,
output_points = output_
self.conditions["data"] = Condition(
input_points=input_, output_points=output_
)
super().__init__()