PhysicsNeMo Sym Geometry#

geometry.geometry#

Defines base class for all geometries

class physicsnemo.sym.geometry.geometry.Geometry( curves, sdf, dims, bounds, parameterization=<physicsnemo.sym.geometry.parameterization.Parameterization object>, interior_epsilon=1e-06, )[source]#

Bases: object

Base class for all geometries

property dims#: returns: dims – output can be [‘x’], [‘x’,’y’], or [‘x’,’y’,’z’] :rtype: List[srt]

repeat( spacing: float, repeat_lower: List[int], repeat_higher: List[int], center: None | List[float] = None, )[source]#

Finite Repetition of geometry.

Parameters:

spacing (float) – Spacing between each repetition.
repeat_lower (List[int]) – How many repetitions going in negative direction.
repeat_upper (List[int]) – How many repetitions going in positive direction.
center (Union[None, List[Union[float, sympy.Basic]]] = None) – If given then center the rotation around this point.

rotate( angle: float | ~sympy.core.basic.Basic, axis: str = 'z', center: None | ~typing.List[float] = None, parameterization=<physicsnemo.sym.geometry.parameterization.Parameterization object>, )[source]#

Rotates geometry.

Parameters:

angle (Union[float, sympy.Basic]) – Angle of rotate in radians. Can be a sympy expression if parameterizing.
axis (str) – Axis of rotation. Default is “z”.
center (Union[None, List[Union[float, sympy.Basic]]] = None) – If given then center the rotation around this point.
parameterization (Parameterization) – Parameterization if translation is parameterized.

sample_boundary( nr_points: int, criteria: Basic | None = None, parameterization: Parameterization | None = None, quasirandom: bool = False, )[source]#

Samples the surface or perimeter of the geometry.

Parameters:

nr_points (int) – number of points to sample on boundary.
criteria (Union[sympy.Basic, None]) – Only sample points that satisfy this criteria.
parameterization (Union[Parameterization, None], optional) – If the geometry is parameterized then you can provide ranges for the parameters with this. By default the sampling will be done with the internal parameterization.
quasirandom (bool) – If true then sample the points using the Halton sequences. Default is False.

Returns:

points – Dictionary contain a point cloud sampled uniformly. For example in 2D it would be

points = {'x': np.ndarray (N, 1),
          'y': np.ndarray (N, 1),
          'normal_x': np.ndarray (N, 1),
          'normal_y': np.ndarray (N, 1),
          'area': np.ndarray (N, 1)}

The area value can be used for Monte Carlo integration like the following, total_area = np.sum(points['area'])

Return type:

Dict[str, np.ndarray]

sample_interior( nr_points: int, bounds: Bounds | None = None, criteria: Basic | None = None, parameterization: Parameterization | None = None, compute_sdf_derivatives: bool = False, quasirandom: bool = False, flip_interior: bool = False, )[source]#

Samples the interior of the geometry.

Parameters:

nr_points (int) – number of points to sample.
bounds (Union[Bounds, None]) – Bounds to sample points from. For example, bounds = Bounds({Parameter(‘x’): (0, 1), Parameter(‘y’): (0, 1)}). By default the internal bounds will be used.
criteria (Union[sympy.Basic, None]) – Only sample points that satisfy this criteria.
parameterization (Union[Parameterization, None]) – If the geometry is parameterized then you can provide ranges for the parameters with this.
compute_sdf_derivatives (bool) – Compute sdf derivatives if true.
quasirandom (bool) – If true then sample the points using the Halton sequences. Default is False.
flip_interior (bool) – If true, then instead of sampling inside the geometry, the points are sampled in the region defined between bounds and geometry.

Returns:

points – Dictionary contain a point cloud sampled uniformly. For example in 2D it would be

points = {'x': np.ndarray (N, 1),
          'y': np.ndarray (N, 1),
          'sdf': np.ndarray (N, 1),
          'area': np.ndarray (N, 1)}

The area value can be used for Monte Carlo integration like the following, total_area = np.sum(points['area'])

Return type:

Dict[str, np.ndarray]

scale( x: float | ~sympy.core.basic.Basic, parameterization: ~physicsnemo.sym.geometry.parameterization.Parameterization = <physicsnemo.sym.geometry.parameterization.Parameterization object>, )[source]#

Scales geometry.

Parameters:

x (Union[float, sympy.Basic]) – Scale factor. Can be a sympy expression if parameterizing.
parameterization (Parameterization) – Parameterization if scale factor is parameterized.

translate(xyz: ~typing.List[float | ~sympy.core.basic.Basic], parameterization: ~physicsnemo.sym.geometry.parameterization.Parameterization = <physicsnemo.sym.geometry.parameterization.Parameterization object>)[source]#

Translates geometry.

Parameters:

xyz (List[Union[float, sympy.Basic]]) – Translation. Can be a sympy expression if parameterizing.
parameterization (Parameterization) – Parameterization if translation is parameterized.

geometry.adf#

class physicsnemo.sym.geometry.adf.ADF[source]#

Bases: Module

Used for hard imposition of boundary conditions. Currently supports 2d geometries and Dirichlet boundary conditions. Contributors: M. A. Nabian, R. Gladstone, H. Meidani, N. Sukumar, A. Srivastava

Reference: “Sukumar, N. and Srivastava, A., 2021.: Exact imposition of boundary conditions with distance functions in physics-informed deep neural networks. Computer Methods in Applied Mechanics and Engineering, p.114333.”

static circle_adf( points: Tuple[Tensor], radius: float, center: Tuple[float], ) → Tensor[source]#

Computes the pointwise approximate distance for a circle

Parameters:

points (Tuple[torch.Tensor]) – ADF will be computed on these points
radius (float) – Radius of the circle
center (Tuple[float]) – Center of the circle

Returns:

omega – pointwise approximate distance

Return type:

torch.Tensor

forward(invar)[source]#

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

static infinite_line_adf( points: Tuple[Tensor], point_1: Tuple[float], point_2: Tuple[float], ) → Tensor[source]#

Computes the pointwise approximate distance for an infinite line

Parameters:

points (Tuple[torch.Tensor]) – ADF will be computed on these points
point_1 (Tuple[float]) – One of the two points that form the infinite line
point_2 (Tuple[float]) – One of the two points that form the infinite line

Returns:

omega – pointwise approximate distance

Return type:

torch.Tensor

static line_segment_adf( points: Tuple[Tensor], point_1: Tuple[float], point_2: Tuple[float], ) → Tensor[source]#

Computes the pointwise approximate distance for a line segment

Parameters:

points (Tuple[torch.Tensor]) – ADF will be computed on these points
point_1 (Tuple[float]) – Point on one end of the line segment
point_2 (Tuple[float]) – Point on the other ned of the line segment

Returns:

omega – pointwise approximate distance

Return type:

torch.Tensor

static r_equivalence( omegas: List[Tensor], m: float = 2.0, ) → Tensor[source]#

Computes the R-equivalence of a collection of approximate distance functions

Parameters:

omegas (List[torch.Tensor]) – List of ADFs used to compute the R-equivalence.
m (float) – Normalization order

Returns:

omega_E – R-equivalence distance

Return type:

torch.Tensor

static transfinite_interpolation( bases: List[Tensor], indx: int, eps: float = 1e-08, ) → Tensor[source]#

Performs transfinite interpolation of the boundary conditions

Parameters:

bases (List[torch.Tensor]) – List of ADFs used for the transfinite interpolation.
indx (int) – index of the interpolation basis
eps (float) – Small value to avoid division by zero

Returns:

w – Interpolation basis corresponding to the input index

Return type:

torch.Tensor

static trimmed_circle_adf( points: Tuple[Tensor], point_1: Tuple[float], point_2: Tuple[float], sign: int, radius: float, center: float, ) → Tensor[source]#

Computes the pointwise approximate distance of a trimmed circle

Parameters:

points (Tuple[torch.Tensor]) – ADF will be computed on these points
point_1 (Tuple[float]) – One of the two points that form the trimming infinite line
point_2 (Tuple[float]) – One of the two points that form the trimming infinite line
sign (int) – Specifies the trimming side
radius (float) – Radius of the circle
center (Tuple[float]) – Center of the circle

Returns:

omega – pointwise approximate distance

Return type:

torch.Tensor

geometry.curve#

Defines different Curve objects

class physicsnemo.sym.geometry.curve.Curve( sample, dims, parameterization=<physicsnemo.sym.geometry.parameterization.Parameterization object>, )[source]#

Bases: object

A Curve object that keeps track of the surface/perimeter of a geometry. The curve object also contains normals and area/length of curve.

approx_area( parameterization=<physicsnemo.sym.geometry.parameterization.Parameterization object>, criteria=None, approx_nr=10000, quasirandom=False, )[source]#

Parameters:

parameterization (dict with of Parameters and their ranges) – If the curve is parameterized then you can provide ranges for the parameters with this.
criteria (None, SymPy boolean exprs) – Calculate area discarding regions that don’t satisfy this criteria.
approx_nr (int) – Area might be difficult to compute if parameterized. In this case the area is approximated by sampling area, approx_nr number of times. This amounts to monte carlo integration.

Returns:

area – area of curve

Return type:

float

property dims#: returns: dims – output can be [‘x’], [‘x’,’y’], or [‘x’,’y’,’z’] :rtype: list of strings

rotate( angle, axis, parameterization=<physicsnemo.sym.geometry.parameterization.Parameterization object>, )[source]#

rotate curve

Parameters:: x (float, SymPy Symbol/Exprs) – scale factor.

scale( x, parameterization=<physicsnemo.sym.geometry.parameterization.Parameterization object>, )[source]#

scale curve

Parameters:: x (float, SymPy Symbol/Exprs) – scale factor.

translate( xyz, parameterization=<physicsnemo.sym.geometry.parameterization.Parameterization object>, )[source]#

translate curve

Parameters:: xyz (tuple of floats, ints, SymPy Symbol/Exprs) – translate curve by these values.

class physicsnemo.sym.geometry.curve.SympyCurve(functions, parameterization, area, criteria=None)[source]#

Bases: Curve

Curve defined by sympy functions

Parameters:

functions (dictionary of SymPy Exprs) –
Parameterized curve in 1, 2 or 3 dimensions. For example, a circle might have:
```
functions = {'x': cos(theta),
    'y': sin(theta),
    'normal_x': cos(theta),
    'normal_y': sin(theta)}
```
TODO: refactor to remove normals.
ranges (dictionary of Sympy Symbols and ranges) – This gives the ranges for the parameters in the parameterized curve. For example, a circle might have ranges = {theta: (0, 2*pi)}.
area (float, int, SymPy Exprs) – The surface area/perimeter of the curve.
criteria (SymPy Boolean Function) – If this boolean expression is false then we do not sample their on curve. This can be used to enforce uniform sample probability.

geometry.discrete_geometry#

Defines a Discrete geometry

class physicsnemo.sym.geometry.discrete_geometry.DiscreteGeometry( geometries, parameterization=<physicsnemo.sym.geometry.parameterization.Parameterization object>, interior_epsilon=1e-06, )[source]#

PhysicsNeMo Sym Geometry#

geometry.geometry#

geometry.adf#

geometry.curve#

geometry.discrete_geometry#

geometry.parameterization#

geometry.primitives_1d#

geometry.primitives_2d#

geometry.primitives_3d#

geometry.tessellation#

geometry.geometry_dataloader#