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

Fix Codacy Warnings (#477)

Browse Source 
---------

Co-authored-by: Dario Coscia <dariocos99@gmail.com>
This commit is contained in:
Filippo Olivo
2025-03-10 15:38:45 +01:00
committed by Nicola Demo
parent e3790e049a
commit 4177bfbb50
157 changed files with 3473 additions and 3839 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pina/problem/__init__.py
View File

@@ -1,3 +1,5 @@
"""Module for Problems."""
__all__ = [
"AbstractProblem",
"SpatialProblem",

55
pina/problem/abstract_problem.py
View File

@@ -1,11 +1,11 @@
"""Module for AbstractProblem class"""
from abc import ABCMeta, abstractmethod
from copy import deepcopy
from ..utils import check_consistency
from ..domain import DomainInterface, CartesianDomain
from ..condition.domain_equation_condition import DomainEquationCondition
from copy import deepcopy
from .. import LabelTensor
from ..label_tensor import LabelTensor
from ..utils import merge_tensors
@@ -20,7 +20,12 @@ class AbstractProblem(metaclass=ABCMeta):
"""
def __init__(self):
"""
TODO
:return: _description_
:rtype: _type_
"""
self._discretised_domains = {}
# create collector to manage problem data
@@ -42,16 +47,33 @@ class AbstractProblem(metaclass=ABCMeta):
@property
def batching_dimension(self):
"""
TODO
:return: _description_
:rtype: _type_
"""
return self._batching_dimension
@batching_dimension.setter
def batching_dimension(self, value):
"""
TODO
:return: _description_
:rtype: _type_
"""
self._batching_dimension = value
# TODO this should be erase when dataloading will interface collector,
# kept only for back compatibility
# back compatibility 0.1
@property
def input_pts(self):
"""
TODO
:return: _description_
:rtype: _type_
"""
to_return = {}
for cond_name, cond in self.conditions.items():
if hasattr(cond, "input"):
@@ -62,6 +84,12 @@ class AbstractProblem(metaclass=ABCMeta):
@property
def discretised_domains(self):
"""
TODO
:return: _description_
:rtype: _type_
"""
return self._discretised_domains
def __deepcopy__(self, memo):
@@ -90,10 +118,7 @@ class AbstractProblem(metaclass=ABCMeta):
:rtype: bool
"""
return all(
[
domain in self.discretised_domains
for domain in self.domains.keys()
]
domain in self.discretised_domains for domain in self.domains
)
@property
@@ -127,7 +152,6 @@ class AbstractProblem(metaclass=ABCMeta):
"""
The output variables of the problem.
"""
pass
@property
@abstractmethod
@@ -153,7 +177,7 @@ class AbstractProblem(metaclass=ABCMeta):
chebyshev sampling, ``chebyshev``; grid sampling ``grid``.
:param variables: variable(s) to sample, defaults to 'all'.
:type variables: str | list[str]
:param domains: problem's domain from where to sample, defaults to 'all'.
:param domains: Domain from where to sample, defaults to 'all'.
:type domains: str | list[str]
:Example:
@@ -162,11 +186,12 @@ class AbstractProblem(metaclass=ABCMeta):
>>> pinn.discretise_domain(n=10, mode='grid', variables=['x'])
.. warning::
``random`` is currently the only implemented ``mode`` for all geometries, i.e.
``EllipsoidDomain``, ``CartesianDomain``, ``SimplexDomain`` and the geometries
compositions ``Union``, ``Difference``, ``Exclusion``, ``Intersection``. The
modes ``latin`` or ``lh``, ``chebyshev``, ``grid`` are only implemented for
``CartesianDomain``.
``random`` is currently the only implemented ``mode`` for all
geometries, i.e. ``EllipsoidDomain``, ``CartesianDomain``,
``SimplexDomain`` and the geometries compositions ``Union``,
``Difference``, ``Exclusion``, ``Intersection``. The
modes ``latin`` or ``lh``, ``chebyshev``, ``grid`` are only
implemented for ``CartesianDomain``.
"""
# check consistecy n, mode, variables, locations

33
pina/problem/inverse_problem.py
View File

@@ -1,7 +1,7 @@
"""Module for the ParametricProblem class"""
import torch
from abc import abstractmethod
import torch
from .abstract_problem import AbstractProblem
@@ -16,40 +16,14 @@ class InverseProblem(AbstractProblem):
derivative term.
:Example:
>>> from pina.problem import SpatialProblem, InverseProblem
>>> from pina.operator import grad
>>> from pina.equation import ParametricEquation, FixedValue
>>> from pina import Condition
>>> from pina.geometry import CartesianDomain
>>> import torch
>>>
>>> class InverseODE(SpatialProblem, InverseProblem):
>>>
>>> output_variables = ['u']
>>> spatial_domain = CartesianDomain({'x': [0, 1]})
>>> unknown_parameter_domain = CartesianDomain({'alpha': [1, 10]})
>>>
>>> def ode_equation(input_, output_, params_):
>>> u_x = grad(output_, input_, components=['u'], d=['x'])
>>> u = output_.extract(['u'])
>>> return params_.extract(['alpha']) * u_x - u
>>>
>>> def solution_data(input_, output_):
>>> x = input_.extract(['x'])
>>> solution = torch.exp(x)
>>> return output_ - solution
>>>
>>> conditions = {
>>> 'x0': Condition(CartesianDomain({'x': 0}), FixedValue(1.0)),
>>> 'D': Condition(CartesianDomain({'x': [0, 1]}), ParametricEquation(ode_equation)),
>>> 'data': Condition(CartesianDomain({'x': [0, 1]}), Equation(solution_data))
TODO
"""
def __init__(self):
super().__init__()
# storing unknown_parameters for optimization
self.unknown_parameters = {}
for i, var in enumerate(self.unknown_variables):
for var in self.unknown_variables:
range_var = self.unknown_parameter_domain.range_[var]
tensor_var = (
torch.rand(1, requires_grad=True) * range_var[1] + range_var[0]
@@ -61,7 +35,6 @@ class InverseProblem(AbstractProblem):
"""
The parameters' domain of the problem.
"""
pass
@property
def unknown_variables(self):

25
pina/problem/parametric_problem.py
View File

@@ -15,29 +15,7 @@ class ParametricProblem(AbstractProblem):
derivative term.
:Example:
>>> from pina.problem import SpatialProblem, ParametricProblem
>>> from pina.operator import grad
>>> from pina.equations import Equation, FixedValue
>>> from pina import Condition
>>> from pina.geometry import CartesianDomain
>>> import torch
>>>
>>>
>>> class ParametricODE(SpatialProblem, ParametricProblem):
>>>
>>> output_variables = ['u']
>>> spatial_domain = CartesianDomain({'x': [0, 1]})
>>> parameter_domain = CartesianDomain({'alpha': [1, 10]})
>>>
>>> def ode_equation(input_, output_):
>>> u_x = grad(output_, input_, components=['u'], d=['x'])
>>> u = output_.extract(['u'])
>>> alpha = input_.extract(['alpha'])
>>> return alpha * u_x - u
>>>
>>> conditions = {
>>> 'x0': Condition(CartesianDomain({'x': 0, 'alpha':[1, 10]}), FixedValue(1.)),
>>> 'D': Condition(CartesianDomain({'x': [0, 1], 'alpha':[1, 10]}), Equation(ode_equation))}
TODO
"""
@abstractmethod
@@ -45,7 +23,6 @@ class ParametricProblem(AbstractProblem):
"""
The parameters' domain of the problem.
"""
pass
@property
def parameters(self):

23
pina/problem/spatial_problem.py
View File

@@ -13,27 +13,7 @@ class SpatialProblem(AbstractProblem):
Here's an example of a spatial 1-dimensional ODE problem.
:Example:
>>> from pina.problem import SpatialProblem
>>> from pina.operator import grad
>>> from pina.equation import Equation, FixedValue
>>> from pina import Condition
>>> from pina.geometry import CartesianDomain
>>> import torch
>>>
>>>
>>> class SpatialODE(SpatialProblem:
>>>
>>> output_variables = ['u']
>>> spatial_domain = CartesianDomain({'x': [0, 1]})
>>>
>>> def ode_equation(input_, output_):
>>> u_x = grad(output_, input_, components=['u'], d=['x'])
>>> u = output_.extract(['u'])
>>> return u_x - u
>>>
>>> conditions = {
>>> 'x0': Condition(CartesianDomain({'x': 0, 'alpha':[1, 10]}), FixedValue(1.)),
>>> 'D': Condition(CartesianDomain({'x': [0, 1], 'alpha':[1, 10]}), Equation(ode_equation))}
TODO
"""
@abstractmethod
@@ -41,7 +21,6 @@ class SpatialProblem(AbstractProblem):
"""
The spatial domain of the problem.
"""
pass
@property
def spatial_variables(self):

33
pina/problem/time_dependent_problem.py
View File

@@ -13,37 +13,7 @@ class TimeDependentProblem(AbstractProblem):
Here's an example of a 1D wave problem.
:Example:
>>> from pina.problem import SpatialProblem, TimeDependentProblem
>>> from pina.operator import grad, laplacian
>>> from pina.equation import Equation, FixedValue
>>> from pina import Condition
>>> from pina.geometry import CartesianDomain
>>> import torch
>>>
>>>
>>> class Wave(TimeDependentSpatialProblem):
>>>
>>> output_variables = ['u']
>>> spatial_domain = CartesianDomain({'x': [0, 3]})
>>> temporal_domain = CartesianDomain({'t': [0, 1]})
>>>
>>> def wave_equation(input_, output_):
>>> u_t = grad(output_, input_, components=['u'], d=['t'])
>>> u_tt = grad(u_t, input_, components=['dudt'], d=['t'])
>>> delta_u = laplacian(output_, input_, components=['u'], d=['x'])
>>> return delta_u - u_tt
>>>
>>> def initial_condition(input_, output_):
>>> u_expected = (-3*torch.sin(2*torch.pi*input_.extract(['x']))
>>> + 5*torch.sin(8/3*torch.pi*input_.extract(['x'])))
>>> u = output_.extract(['u'])
>>> return u - u_expected
>>>
>>> conditions = {
>>> 't0': Condition(CartesianDomain({'x': [0, 3], 't':0}), Equation(initial_condition)),
>>> 'gamma1': Condition(CartesianDomain({'x':0, 't':[0, 1]}), FixedValue(0.)),
>>> 'gamma2': Condition(CartesianDomain({'x':3, 't':[0, 1]}), FixedValue(0.)),
>>> 'D': Condition(CartesianDomain({'x': [0, 3], 't':[0, 1]}), Equation(wave_equation))}
TODO
"""
@abstractmethod
@@ -51,7 +21,6 @@ class TimeDependentProblem(AbstractProblem):
"""
The temporal domain of the problem.
"""
pass
@property
def temporal_variable(self):

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

@@ -1,3 +1,5 @@
"""TODO"""
__all__ = [
"Poisson2DSquareProblem",
"SupervisedProblem",

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

@@ -1,12 +1,12 @@
"""Definition of the Poisson problem on a square domain."""
from pina.problem import SpatialProblem
from pina.operator import laplacian
from pina import Condition
from pina.domain import CartesianDomain
from pina.equation.equation import Equation
from pina.equation.equation_factory import FixedValue
import torch
from ..spatial_problem import SpatialProblem
from ...operator import laplacian
from ... import Condition
from ...domain import CartesianDomain
from ...equation.equation import Equation
from ...equation.equation_factory import FixedValue
def laplace_equation(input_, output_):
@@ -48,6 +48,8 @@ class Poisson2DSquareProblem(SpatialProblem):
}
def poisson_sol(self, pts):
"""TODO"""
return -(
torch.sin(pts.extract(["x"]) * torch.pi)
* torch.sin(pts.extract(["y"]) * torch.pi)

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

@@ -1,14 +1,17 @@
from pina.problem import AbstractProblem
from pina import Condition
from pina import Graph
"""TODO"""
from ..abstract_problem import AbstractProblem
from ... import Condition
from ... import Graph
class SupervisedProblem(AbstractProblem):
"""
A problem definition for supervised learning in PINA.
This class allows an easy and straightforward definition of a Supervised problem,
based on a single condition of type `InputTargetCondition`
This class allows an easy and straightforward definition of a
Supervised problem, based on a single condition of type
`InputTargetCondition`
:Example:
>>> import torch
@@ -17,7 +20,7 @@ class SupervisedProblem(AbstractProblem):
>>> problem = SupervisedProblem(input_data, output_data)
"""
conditions = dict()
conditions = {}
output_variables = None
def __init__(self, input_, output_):