torchphysics.problem.domains package

Domains handle the geometries of the underlying problems. Every input variable, that appears in the differentialequation has to get a domain, to which it belongs. Different 0D, 1D, 2D and 3D domains are pre implemented. For more complex domains four operations are implemented:

• Union \(A \cup B\), implemented with: +

• Intersection \(A \cap B\), implemented with: &

• Cut \(A \setminus B\), implemented with: -

• Cartesian product \(A \times B\), implemented with: *

It is possible to pass in functions as parameters of most domains. This leads to geometries that can change depending on other variables, e.g. a moving domain in time.

Boolean operations together with cartesian products and parameter-dependencies form an easy-to-use toolbox enable the user to define a large set of relevant domains. In addition, domains can be imported from shapely or .stl-files (through trimesh).

If you want to solve an inverse problem, the learnable parameters do not get a domain! They have to be defined with the torchphysics.model.Parameters class.

Subpackages

• torchphysics.problem.domains.domain0D package
  • Submodules
  • torchphysics.problem.domains.domain0D.point module
    • Point
      • Point.__call__()
      • Point.bounding_box()
      • Point.sample_grid()
      • Point.sample_random_uniform()
• torchphysics.problem.domains.domain1D package
  • Submodules
  • torchphysics.problem.domains.domain1D.interval module
    • Interval
      • Interval.__call__()
      • Interval.boundary
      • Interval.boundary_left
      • Interval.boundary_right
      • Interval.bounding_box()
      • Interval.sample_grid()
      • Interval.sample_random_uniform()
    • IntervalBoundary
      • IntervalBoundary.normal()
      • IntervalBoundary.sample_grid()
      • IntervalBoundary.sample_random_uniform()
    • IntervalSingleBoundaryPoint
      • IntervalSingleBoundaryPoint.__call__()
      • IntervalSingleBoundaryPoint.normal()
      • IntervalSingleBoundaryPoint.sample_grid()
      • IntervalSingleBoundaryPoint.sample_random_uniform()
• torchphysics.problem.domains.domain2D package
  • Submodules
  • torchphysics.problem.domains.domain2D.circle module
    • Circle
      • Circle.__call__()
      • Circle.boundary
      • Circle.bounding_box()
      • Circle.sample_grid()
      • Circle.sample_random_uniform()
    • CircleBoundary
      • CircleBoundary.normal()
      • CircleBoundary.sample_grid()
      • CircleBoundary.sample_random_uniform()
  • torchphysics.problem.domains.domain2D.parallelogram module
    • Parallelogram
      • Parallelogram.__call__()
      • Parallelogram.boundary
      • Parallelogram.bounding_box()
      • Parallelogram.sample_grid()
      • Parallelogram.sample_random_uniform()
    • ParallelogramBoundary
      • ParallelogramBoundary.normal()
      • ParallelogramBoundary.sample_grid()
      • ParallelogramBoundary.sample_random_uniform()
  • torchphysics.problem.domains.domain2D.shapely_polygon module
    • ShapelyBoundary
      • ShapelyBoundary.__call__()
      • ShapelyBoundary.normal()
      • ShapelyBoundary.sample_grid()
      • ShapelyBoundary.sample_random_uniform()
    • ShapelyPolygon
      • ShapelyPolygon.__call__()
      • ShapelyPolygon.boundary
      • ShapelyPolygon.bounding_box()
      • ShapelyPolygon.outline()
      • ShapelyPolygon.sample_grid()
      • ShapelyPolygon.sample_random_uniform()
  • torchphysics.problem.domains.domain2D.triangle module
    • Triangle
      • Triangle.__call__()
      • Triangle.boundary
      • Triangle.bounding_box()
      • Triangle.sample_grid()
      • Triangle.sample_random_uniform()
    • TriangleBoundary
      • TriangleBoundary.normal()
      • TriangleBoundary.sample_grid()
      • TriangleBoundary.sample_random_uniform()
• torchphysics.problem.domains.domain3D package
  • Submodules
  • torchphysics.problem.domains.domain3D.sphere module
    • Sphere
      • Sphere.__call__()
      • Sphere.boundary
      • Sphere.bounding_box()
      • Sphere.sample_grid()
      • Sphere.sample_random_uniform()
    • SphereBoundary
      • SphereBoundary.normal()
      • SphereBoundary.sample_grid()
      • SphereBoundary.sample_random_uniform()
  • torchphysics.problem.domains.domain3D.trimesh_polyhedron module
    • TrimeshBoundary
      • TrimeshBoundary.normal()
      • TrimeshBoundary.sample_grid()
      • TrimeshBoundary.sample_random_uniform()
    • TrimeshPolyhedron
      • TrimeshPolyhedron.__call__()
      • TrimeshPolyhedron.boundary
      • TrimeshPolyhedron.bounding_box()
      • TrimeshPolyhedron.export_file()
      • TrimeshPolyhedron.project_on_plane()
      • TrimeshPolyhedron.sample_grid()
      • TrimeshPolyhedron.sample_random_uniform()
      • TrimeshPolyhedron.slice_with_plane()
• torchphysics.problem.domains.domainoperations namespace
  • Submodules
  • torchphysics.problem.domains.domainoperations.cut module
    • CutBoundaryDomain
      • CutBoundaryDomain.normal()
      • CutBoundaryDomain.sample_grid()
      • CutBoundaryDomain.sample_random_uniform()
    • CutDomain
      • CutDomain.__call__()
      • CutDomain.boundary
      • CutDomain.bounding_box()
      • CutDomain.sample_grid()
      • CutDomain.sample_random_uniform()
  • torchphysics.problem.domains.domainoperations.intersection module
    • IntersectionBoundaryDomain
      • IntersectionBoundaryDomain.normal()
      • IntersectionBoundaryDomain.sample_grid()
      • IntersectionBoundaryDomain.sample_random_uniform()
    • IntersectionDomain
      • IntersectionDomain.__call__()
      • IntersectionDomain.boundary
      • IntersectionDomain.bounding_box()
      • IntersectionDomain.sample_grid()
      • IntersectionDomain.sample_random_uniform()
  • torchphysics.problem.domains.domainoperations.product module
    • ProductDomain
      • ProductDomain.__call__()
      • ProductDomain.boundary
      • ProductDomain.bounding_box()
      • ProductDomain.sample_grid()
      • ProductDomain.sample_random_uniform()
      • ProductDomain.set_bounding_box()
  • torchphysics.problem.domains.domainoperations.rotate module
    • Rotate
      • Rotate.__call__()
      • Rotate.boundary
      • Rotate.bounding_box()
      • Rotate.from_angles()
      • Rotate.sample_grid()
      • Rotate.sample_random_uniform()
      • Rotate.set_volume()
      • Rotate.volume()
    • RotationMatrix2D
      • RotationMatrix2D.__call__()
      • RotationMatrix2D.partially_evaluate()
    • RotationMatrix3D
      • RotationMatrix3D.necessary_args
  • torchphysics.problem.domains.domainoperations.sampler_helper module
  • torchphysics.problem.domains.domainoperations.translate module
    • Translate
      • Translate.__call__()
      • Translate.boundary
      • Translate.bounding_box()
      • Translate.sample_grid()
      • Translate.sample_random_uniform()
      • Translate.set_volume()
      • Translate.volume()
  • torchphysics.problem.domains.domainoperations.union module
    • UnionBoundaryDomain
      • UnionBoundaryDomain.normal()
      • UnionBoundaryDomain.sample_grid()
      • UnionBoundaryDomain.sample_random_uniform()
    • UnionDomain
      • UnionDomain.__call__()
      • UnionDomain.boundary
      • UnionDomain.bounding_box()
      • UnionDomain.sample_grid()
      • UnionDomain.sample_random_uniform()
• torchphysics.problem.domains.functionsets package
  • Submodules
  • torchphysics.problem.domains.functionsets.FE_functionset module
    • FEFunctionSet
      • FEFunctionSet.__call__()
      • FEFunctionSet.get_quad_weights()
      • FEFunctionSet.get_quadrature_points()
      • FEFunctionSet.switch_quadrature_mode_on()
      • FEFunctionSet.to()
    • LinearFE1D
      • LinearFE1D.__call__()
      • LinearFE1D.compute_center_and_volume()
      • LinearFE1D.compute_grad_per_dof()
      • LinearFE1D.switch_quadrature_mode_on()
      • LinearFE1D.to()
    • LinearFE2D
      • LinearFE2D.__call__()
      • LinearFE2D.compute_center_and_volume()
      • LinearFE2D.compute_grad_per_dof()
      • LinearFE2D.find_boundary_dofs()
      • LinearFE2D.switch_quadrature_mode_on()
      • LinearFE2D.to()
  • torchphysics.problem.domains.functionsets.functionset module
    • CustomFunctionSet
    • FunctionSet
      • FunctionSet.__add__()
      • FunctionSet.__len__()
      • FunctionSet.create_function_batch()
      • FunctionSet.sample_params()
    • FunctionSetCollection
      • FunctionSetCollection.__add__()
      • FunctionSetCollection.__len__()
      • FunctionSetCollection.create_function_batch()
      • FunctionSetCollection.sample_params()
    • TestFunctionHelper
      • TestFunctionHelper.backward()
      • TestFunctionHelper.forward()
    • TestFunctionSet
      • TestFunctionSet.__call__()
      • TestFunctionSet.get_quad_weights()
      • TestFunctionSet.get_quadrature_points()
      • TestFunctionSet.switch_quadrature_mode_on()
      • TestFunctionSet.to()
  • torchphysics.problem.domains.functionsets.harmonic_functionset module
    • HarmonicFunctionSet1D
      • HarmonicFunctionSet1D.__call__()
      • HarmonicFunctionSet1D.compute_basis_at_quadrature_points()
      • HarmonicFunctionSet1D.get_quad_weights()
      • HarmonicFunctionSet1D.get_quadrature_points()
      • HarmonicFunctionSet1D.grad()
      • HarmonicFunctionSet1D.switch_quadrature_mode_on()
      • HarmonicFunctionSet1D.to()

Submodules

torchphysics.problem.domains.domain module

class torchphysics.problem.domains.domain.BoundaryDomain(domain)

Bases: Domain

The parent class for all built-in boundaries. Can be used just like the main Domain class.

Parameters:

domain (Domain) – The domain of which this object is the boundary.

__call__(**data)

Evaluates the domain at the given data.

bounding_box(params=Points: {}, device='cpu')

Computes the bounds of the domain.

Returns:

A torch.Tensor with the length of 2*self.dim. It has the form [axis_1_min, axis_1_max, axis_2_min, axis_2_max, …], where min and max are the minimum and maximum value that the domain reaches in each dimension-axis.

Return type:

tensor

abstract normal(points, params=Points: {}, device='cpu')

Computes the normal vector at each point in points.

Parameters:

• points (torch.tensor or torchphysics.problem.Points) – Different points for which the normal vector should be computed. The points should lay on the boundary of the domain, to get correct results. E.g in 2D: points = Points(torch.tensor([[2, 4], [9, 6], ….]), R2(…))

• params (dict or torchphysics.problem.Points, optional) – Additional parameters that are maybe needed to evaluate the domain.

• device (str, optional) – The device on which the points should be created. Default is ‘cpu’.

Returns:

The tensor is of the shape (len(points), self.dim) and contains the normal vector at each entry from points.

Return type:

torch.tensor

class torchphysics.problem.domains.domain.Domain(space, dim=None)

Bases: object

The parent class for all built-in domains.

Parameters:

• space (torchphysiscs.spaces.Space) – The space in which this object lays.

• dim (int, optional) – The dimension of this domain. (if not specified, implicit given through the space)

__add__(other)

Creates the union of the two input domains.

Parameters:

other (Domain) – The other domain that should be united with the domain. Has to be of the same dimension.

__and__(other)

Creates the intersection of the two input domains.

Parameters:

other (Domain) – The other domain that should be intersected with the domain. Has to lie in the same space.

__call__(**data)

Evaluates the domain at the given data.

__contains__(points)

Checks for every point in points if it lays inside the domain.

Parameters:

points (torchphysics.problem.Points) – A Points object that should be checked.

Returns:

A boolean Tensor of the shape (len(points), 1) where every entry contains true if the point was inside or false if not.

Return type:

torch.Tensor

__mul__(other)

Creates the cartesian product of this domain and another domain.

Parameters:

other (Domain) – The other domain to create the cartesian product with. Should lie in a disjoint space.

__sub__(other)

Creates the cut of domain other from self.

Parameters:

other (Domain) – The other domain that should be cut off the domain. Has to be of the same dimension.

property boundary

Returns the boundary of this domain. Does not work on boundaries itself, e.g. Circle.boundary.boundary throws an error.

Returns:

boundary – The boundary-object of the domain.

Return type:

torchphysics.domains.Boundarydomain

abstract bounding_box(params=Points: {}, device='cpu')

Computes the bounds of the domain.

Returns:

A torch.Tensor with the length of 2*self.dim. It has the form [axis_1_min, axis_1_max, axis_2_min, axis_2_max, …], where min and max are the minimum and maximum value that the domain reaches in each dimension-axis.

Return type:

tensor

compute_n_from_density(d, params)

Transforms a given point density to a number of points, since all methods from PyTorch only work with a given number.

len_of_params(params)

Finds the number of params, for which points should be sampled.

abstract sample_grid(n=None, d=None, params=Points: {}, device='cpu')

Creates an equdistant grid in the domain.

Parameters:

• n (int, optional) – The number of points that should be created.

• d (float, optional) – The density of points that should be created, if n is not defined.

• params (torchphysics.problem.Points, optional) – Additional paramters that are maybe needed to evaluate the domain.

• device (str) – The device on which the points should be created. Default is ‘cpu’.

Returns:

A Points object containing the sampled points.

Return type:

Points

abstract sample_random_uniform(n=None, d=None, params=Points: {}, device='cpu')

Creates random uniformly distributed points in the domain.

Parameters:

• n (int, optional) – The number of points that should be created.

• d (float, optional) – The density of points that should be created, if n is not defined.

• params (torchphysics.problem.Points, optional) – Additional paramters that are maybe needed to evaluate the domain.

• device (str) – The device on which the points should be created. Default is ‘cpu’.

Returns:

A Points object containing the sampled points.

Return type:

Points

set_necessary_variables(*domain_params)

Registers the variables/spaces that this domain needs to be properly defined

set_volume(volume)

Set the volume of the given domain.

Parameters:

volume (number or callable) – The volume of the domain. Can be a function if the volume changes depending on other variables.

Notes

For all basic domains the volume (and surface) are implemented. But if the given domain has a complex shape or is dependent on other variables, the volume can only be approixmated. Therefore one can set here a exact expression for the volume, if known.

transform_to_user_functions(*domain_params)

Transforms all parameters that define a given domain to a UserFunction. This enables that the domain can dependt on other variables.

Parameters:

*domain_params (callables, lists, arrays, tensors or numbers) – The parameters that define a domain.

volume(params=Points: {}, device='cpu')

Computes the volume of the current domain.

Parameters:

params (torchphysics.problem.Points, optional) – Additional paramters that are needed to evaluate the domain.

Returns:

volume – Returns the volume of the domain. If dependent on other parameters, the value will be returned as tensor with the shape (len(params), 1). Where each row corresponds to the volume of the given values in the params row.

Return type:

torch.tensor