loop-interpolation 0.0.1__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- loop_interpolation/__init__.py +152 -0
- loop_interpolation/_builders.py +149 -0
- loop_interpolation/_constant_norm.py +232 -0
- loop_interpolation/_diagnostics.py +102 -0
- loop_interpolation/_discrete_fold_interpolator.py +242 -0
- loop_interpolation/_discrete_interpolator.py +1405 -0
- loop_interpolation/_fd_fold_interpolator.py +237 -0
- loop_interpolation/_finite_difference_interpolator.py +1348 -0
- loop_interpolation/_fold_event.py +185 -0
- loop_interpolation/_fold_norm_alignment.py +118 -0
- loop_interpolation/_fold_setup.py +39 -0
- loop_interpolation/_geological_interpolator.py +920 -0
- loop_interpolation/_interpolator_builder.py +251 -0
- loop_interpolation/_interpolator_factory.py +167 -0
- loop_interpolation/_interpolatortype.py +20 -0
- loop_interpolation/_operator.py +44 -0
- loop_interpolation/_p1interpolator.py +299 -0
- loop_interpolation/_p2interpolator.py +317 -0
- loop_interpolation/_regularisation.py +110 -0
- loop_interpolation/_solver_pipeline.py +138 -0
- loop_interpolation/_solver_strategy.py +218 -0
- loop_interpolation/_surfe_wrapper.py +211 -0
- loop_interpolation/_svariogram.py +133 -0
- loop_interpolation/_validation.py +604 -0
- loop_interpolation/constraints.py +473 -0
- loop_interpolation/fold_function/__init__.py +39 -0
- loop_interpolation/fold_function/_base_fold_rotation_angle.py +219 -0
- loop_interpolation/fold_function/_fourier_series_fold_rotation_angle.py +131 -0
- loop_interpolation/fold_function/_lambda_fold_rotation_angle.py +53 -0
- loop_interpolation/loopsolver/__init__.py +2 -0
- loop_interpolation/loopsolver/admm_constant_norm.py +118 -0
- loop_interpolation/loopsolver/admm_method.py +25 -0
- loop_interpolation/loopsolver/admm_solver.py +463 -0
- loop_interpolation/loopsolver/version.py +1 -0
- loop_interpolation-0.0.1.dist-info/METADATA +34 -0
- loop_interpolation-0.0.1.dist-info/RECORD +39 -0
- loop_interpolation-0.0.1.dist-info/WHEEL +5 -0
- loop_interpolation-0.0.1.dist-info/licenses/LICENSE +21 -0
- loop_interpolation-0.0.1.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,152 @@
|
|
|
1
|
+
"""Interpolators and interpolation supports for LoopStructural.
|
|
2
|
+
|
|
3
|
+
This module provides various interpolation methods and support structures
|
|
4
|
+
for geological modelling, including finite difference, piecewise linear,
|
|
5
|
+
and radial basis function interpolators.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
__all__ = [
|
|
9
|
+
"ConstantNormFDIInterpolator",
|
|
10
|
+
"ConstantNormP1Interpolator",
|
|
11
|
+
"ConstraintDiagnosticsReport",
|
|
12
|
+
"ConstraintFamilyDiagnostics",
|
|
13
|
+
"DirectionalRegularisation",
|
|
14
|
+
"DiscreteFoldInterpolator",
|
|
15
|
+
"DiscreteInterpolator",
|
|
16
|
+
"FDFoldInterpolator",
|
|
17
|
+
"FiniteDifferenceInterpolator",
|
|
18
|
+
"FoldEvent",
|
|
19
|
+
"FoldRotationType",
|
|
20
|
+
"FourierSeriesFoldRotationAngleProfile",
|
|
21
|
+
"GeologicalInterpolator",
|
|
22
|
+
"InterpolatorType",
|
|
23
|
+
"LambdaFoldRotationAngleProfile",
|
|
24
|
+
"P1Interpolator",
|
|
25
|
+
"P1Unstructured2d",
|
|
26
|
+
"P2Interpolator",
|
|
27
|
+
"P2Unstructured2d",
|
|
28
|
+
"P2UnstructuredTetMesh",
|
|
29
|
+
"PiecewiseLinearInterpolator",
|
|
30
|
+
"RegionCoverageDiagnostics",
|
|
31
|
+
"RegularisationConfig",
|
|
32
|
+
"StructuredGrid",
|
|
33
|
+
"StructuredGrid2D",
|
|
34
|
+
"SurfeRBFInterpolator",
|
|
35
|
+
"TetMesh",
|
|
36
|
+
"UnStructuredTetMesh",
|
|
37
|
+
"get_fold_rotation_profile",
|
|
38
|
+
]
|
|
39
|
+
from loop_common.logging import get_logger as getLogger
|
|
40
|
+
|
|
41
|
+
from ._interpolatortype import InterpolatorType
|
|
42
|
+
|
|
43
|
+
logger = getLogger(__name__)
|
|
44
|
+
|
|
45
|
+
from loop_common.supports import (
|
|
46
|
+
P1Unstructured2d,
|
|
47
|
+
P2Unstructured2d,
|
|
48
|
+
P2UnstructuredTetMesh,
|
|
49
|
+
StructuredGrid,
|
|
50
|
+
StructuredGrid2D,
|
|
51
|
+
SupportType,
|
|
52
|
+
TetMesh,
|
|
53
|
+
UnStructuredTetMesh,
|
|
54
|
+
)
|
|
55
|
+
|
|
56
|
+
from ._constant_norm import ConstantNormFDIInterpolator, ConstantNormP1Interpolator
|
|
57
|
+
from ._diagnostics import (
|
|
58
|
+
ConstraintDiagnosticsReport,
|
|
59
|
+
ConstraintFamilyDiagnostics,
|
|
60
|
+
RegionCoverageDiagnostics,
|
|
61
|
+
)
|
|
62
|
+
from ._discrete_fold_interpolator import (
|
|
63
|
+
DiscreteFoldInterpolator,
|
|
64
|
+
)
|
|
65
|
+
from ._discrete_interpolator import DiscreteInterpolator
|
|
66
|
+
from ._fd_fold_interpolator import FDFoldInterpolator
|
|
67
|
+
from ._finite_difference_interpolator import (
|
|
68
|
+
FiniteDifferenceInterpolator,
|
|
69
|
+
)
|
|
70
|
+
from ._geological_interpolator import GeologicalInterpolator
|
|
71
|
+
from ._p1interpolator import P1Interpolator
|
|
72
|
+
from ._p1interpolator import (
|
|
73
|
+
P1Interpolator as PiecewiseLinearInterpolator,
|
|
74
|
+
)
|
|
75
|
+
from ._p2interpolator import P2Interpolator
|
|
76
|
+
from ._regularisation import DirectionalRegularisation, RegularisationConfig
|
|
77
|
+
|
|
78
|
+
try:
|
|
79
|
+
from ._surfe_wrapper import SurfeRBFInterpolator
|
|
80
|
+
except ImportError:
|
|
81
|
+
|
|
82
|
+
class SurfeRBFInterpolator(GeologicalInterpolator):
|
|
83
|
+
"""
|
|
84
|
+
Dummy class to handle the case where Surfe is not installed.
|
|
85
|
+
This will raise a warning when used.
|
|
86
|
+
"""
|
|
87
|
+
|
|
88
|
+
def __new__(cls, *args, **kwargs):
|
|
89
|
+
raise ImportError(
|
|
90
|
+
"Surfe cannot be imported. Please install Surfe. pip install surfe/ conda install -c loop3d surfe"
|
|
91
|
+
)
|
|
92
|
+
|
|
93
|
+
|
|
94
|
+
interpolator_string_map = {
|
|
95
|
+
"FDI": InterpolatorType.FINITE_DIFFERENCE,
|
|
96
|
+
"PLI": InterpolatorType.PIECEWISE_LINEAR,
|
|
97
|
+
"P2": InterpolatorType.PIECEWISE_QUADRATIC,
|
|
98
|
+
"P1": InterpolatorType.PIECEWISE_LINEAR,
|
|
99
|
+
"DFI": InterpolatorType.DISCRETE_FOLD,
|
|
100
|
+
"surfe": InterpolatorType.SURFE,
|
|
101
|
+
"FDI_CN": InterpolatorType.FINITE_DIFFERENCE_CONSTANT_NORM,
|
|
102
|
+
"P1_CN": InterpolatorType.PIECEWISE_LINEAR_CONSTANT_NORM,
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
# Define the mapping after all imports
|
|
106
|
+
interpolator_map = {
|
|
107
|
+
InterpolatorType.BASE: GeologicalInterpolator,
|
|
108
|
+
InterpolatorType.BASE_DISCRETE: DiscreteInterpolator,
|
|
109
|
+
InterpolatorType.FINITE_DIFFERENCE: FiniteDifferenceInterpolator,
|
|
110
|
+
InterpolatorType.DISCRETE_FOLD: DiscreteFoldInterpolator,
|
|
111
|
+
InterpolatorType.PIECEWISE_LINEAR: P1Interpolator,
|
|
112
|
+
InterpolatorType.PIECEWISE_QUADRATIC: P2Interpolator,
|
|
113
|
+
InterpolatorType.BASE_DATA_SUPPORTED: GeologicalInterpolator,
|
|
114
|
+
InterpolatorType.SURFE: SurfeRBFInterpolator,
|
|
115
|
+
InterpolatorType.PIECEWISE_LINEAR_CONSTANT_NORM: ConstantNormP1Interpolator,
|
|
116
|
+
InterpolatorType.FINITE_DIFFERENCE_CONSTANT_NORM: ConstantNormFDIInterpolator,
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
support_interpolator_map = {
|
|
120
|
+
InterpolatorType.FINITE_DIFFERENCE: {
|
|
121
|
+
2: SupportType.StructuredGrid2D,
|
|
122
|
+
3: SupportType.StructuredGrid,
|
|
123
|
+
},
|
|
124
|
+
InterpolatorType.DISCRETE_FOLD: {3: SupportType.TetMesh, 2: SupportType.P1Unstructured2d},
|
|
125
|
+
InterpolatorType.PIECEWISE_LINEAR: {3: SupportType.TetMesh, 2: SupportType.P1Unstructured2d},
|
|
126
|
+
InterpolatorType.PIECEWISE_QUADRATIC: {
|
|
127
|
+
3: SupportType.P2UnstructuredTetMesh,
|
|
128
|
+
2: SupportType.P2Unstructured2d,
|
|
129
|
+
},
|
|
130
|
+
InterpolatorType.SURFE: {
|
|
131
|
+
3: SupportType.DataSupported,
|
|
132
|
+
2: SupportType.DataSupported,
|
|
133
|
+
},
|
|
134
|
+
InterpolatorType.PIECEWISE_LINEAR_CONSTANT_NORM: {
|
|
135
|
+
3: SupportType.TetMesh,
|
|
136
|
+
2: SupportType.P1Unstructured2d,
|
|
137
|
+
},
|
|
138
|
+
InterpolatorType.FINITE_DIFFERENCE_CONSTANT_NORM: {
|
|
139
|
+
3: SupportType.StructuredGrid,
|
|
140
|
+
2: SupportType.StructuredGrid2D,
|
|
141
|
+
},
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
from ._fold_event import FoldEvent
|
|
145
|
+
from ._interpolator_builder import InterpolatorBuilder
|
|
146
|
+
from ._interpolator_factory import InterpolatorFactory
|
|
147
|
+
from .fold_function import (
|
|
148
|
+
FoldRotationType,
|
|
149
|
+
FourierSeriesFoldRotationAngleProfile,
|
|
150
|
+
LambdaFoldRotationAngleProfile,
|
|
151
|
+
get_fold_rotation_profile,
|
|
152
|
+
)
|
|
@@ -0,0 +1,149 @@
|
|
|
1
|
+
# from LoopStructural.utils.exceptions import LoopException
|
|
2
|
+
# import numpy as np
|
|
3
|
+
# from typing import Optional
|
|
4
|
+
# from LoopStructural.interpolators import (
|
|
5
|
+
# P1Interpolator,
|
|
6
|
+
# P2Interpolator,
|
|
7
|
+
# FiniteDifferenceInterpolator,
|
|
8
|
+
# GeologicalInterpolator,
|
|
9
|
+
# DiscreteFoldInterpolator,
|
|
10
|
+
# StructuredGrid,
|
|
11
|
+
# TetMesh,
|
|
12
|
+
# )
|
|
13
|
+
# from LoopStructural.datatypes import BoundingBox
|
|
14
|
+
# from LoopStructural.utils.logging import getLogger
|
|
15
|
+
|
|
16
|
+
# logger = getLogger(__name__)
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
# def get_interpolator(
|
|
20
|
+
# bounding_box: BoundingBox,
|
|
21
|
+
# interpolatortype: str,
|
|
22
|
+
# nelements: int,
|
|
23
|
+
# element_volume: Optional[float] = None,
|
|
24
|
+
# buffer: float = 0.2,
|
|
25
|
+
# dimensions: int = 3,
|
|
26
|
+
# support=None,
|
|
27
|
+
# ) -> GeologicalInterpolator:
|
|
28
|
+
# # add a buffer to the interpolation domain, this is necessary for
|
|
29
|
+
# # faults but also generally a good
|
|
30
|
+
# # idea to avoid boundary problems
|
|
31
|
+
# # buffer = bb[1, :]
|
|
32
|
+
# origin = bounding_box.with_buffer(buffer).origin
|
|
33
|
+
# maximum = bounding_box.with_buffer(buffer).maximum
|
|
34
|
+
# box_vol = np.prod(maximum - origin)
|
|
35
|
+
# if interpolatortype == "PLI":
|
|
36
|
+
# if support is None:
|
|
37
|
+
# if element_volume is None:
|
|
38
|
+
# # nelements /= 5
|
|
39
|
+
# element_volume = box_vol / nelements
|
|
40
|
+
# # calculate the step vector of a regular cube
|
|
41
|
+
# step_vector = np.zeros(3)
|
|
42
|
+
# step_vector[:] = element_volume ** (1.0 / 3.0)
|
|
43
|
+
# # step_vector /= np.array([1,1,2])
|
|
44
|
+
# # number of steps is the length of the box / step vector
|
|
45
|
+
# nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
|
|
46
|
+
# if np.any(np.less(nsteps, 3)):
|
|
47
|
+
# axis_labels = ["x", "y", "z"]
|
|
48
|
+
# for i in range(3):
|
|
49
|
+
# if nsteps[i] < 3:
|
|
50
|
+
# nsteps[i] = 3
|
|
51
|
+
# logger.error(
|
|
52
|
+
# f"Number of steps in direction {axis_labels[i]} is too small, try increasing nelements"
|
|
53
|
+
# )
|
|
54
|
+
# logger.error("Cannot create interpolator: number of steps is too small")
|
|
55
|
+
# raise ValueError("Number of steps too small cannot create interpolator")
|
|
56
|
+
|
|
57
|
+
# support = TetMesh(origin=origin, nsteps=nsteps, step_vector=step_vector)
|
|
58
|
+
# logger.info(
|
|
59
|
+
# "Creating regular tetrahedron mesh with %i elements \n"
|
|
60
|
+
# "for modelling using PLI" % (support.ntetra)
|
|
61
|
+
# )
|
|
62
|
+
|
|
63
|
+
# return P1Interpolator(support)
|
|
64
|
+
# if interpolatortype == "P2":
|
|
65
|
+
# if support is not None:
|
|
66
|
+
# logger.info(
|
|
67
|
+
# "Creating regular tetrahedron mesh with %i elements \n"
|
|
68
|
+
# "for modelling using P2" % (support.ntetra)
|
|
69
|
+
# )
|
|
70
|
+
# return P2Interpolator(support)
|
|
71
|
+
# else:
|
|
72
|
+
# raise ValueError("Cannot create P2 interpolator without support, try using PLI")
|
|
73
|
+
|
|
74
|
+
# if interpolatortype == "FDI":
|
|
75
|
+
# # find the volume of one element
|
|
76
|
+
# if element_volume is None:
|
|
77
|
+
# element_volume = box_vol / nelements
|
|
78
|
+
# # calculate the step vector of a regular cube
|
|
79
|
+
# step_vector = np.zeros(3)
|
|
80
|
+
# step_vector[:] = element_volume ** (1.0 / 3.0)
|
|
81
|
+
# # number of steps is the length of the box / step vector
|
|
82
|
+
# nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
|
|
83
|
+
# if np.any(np.less(nsteps, 3)):
|
|
84
|
+
# logger.error("Cannot create interpolator: number of steps is too small")
|
|
85
|
+
# axis_labels = ["x", "y", "z"]
|
|
86
|
+
# for i in range(3):
|
|
87
|
+
# if nsteps[i] < 3:
|
|
88
|
+
# nsteps[i] = 3
|
|
89
|
+
# # logger.error(
|
|
90
|
+
# # f"Number of steps in direction {axis_labels[i]} is too small, try increasing nelements"
|
|
91
|
+
# # )
|
|
92
|
+
# # raise ValueError("Number of steps too small cannot create interpolator")
|
|
93
|
+
# # create a structured grid using the origin and number of steps
|
|
94
|
+
|
|
95
|
+
# grid = StructuredGrid(origin=origin, nsteps=nsteps, step_vector=step_vector)
|
|
96
|
+
# logger.info(
|
|
97
|
+
# f"Creating regular grid with {grid.n_elements} elements \n" "for modelling using FDI"
|
|
98
|
+
# )
|
|
99
|
+
# return FiniteDifferenceInterpolator(grid)
|
|
100
|
+
# if interpolatortype == "DFI":
|
|
101
|
+
# if element_volume is None:
|
|
102
|
+
# nelements /= 5
|
|
103
|
+
# element_volume = box_vol / nelements
|
|
104
|
+
# # calculate the step vector of a regular cube
|
|
105
|
+
# step_vector = np.zeros(3)
|
|
106
|
+
# step_vector[:] = element_volume ** (1.0 / 3.0)
|
|
107
|
+
# # number of steps is the length of the box / step vector
|
|
108
|
+
# nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
|
|
109
|
+
# # create a structured grid using the origin and number of steps
|
|
110
|
+
|
|
111
|
+
# mesh = TetMesh(origin=origin, nsteps=nsteps, step_vector=step_vector)
|
|
112
|
+
# logger.info(
|
|
113
|
+
# f"Creating regular tetrahedron mesh with {mesh.ntetra} elements \n"
|
|
114
|
+
# "for modelling using DFI"
|
|
115
|
+
# )
|
|
116
|
+
# return DiscreteFoldInterpolator(mesh, None)
|
|
117
|
+
# raise LoopException("No interpolator")
|
|
118
|
+
# # fi interpolatortype == "DFI" and dfi is True:
|
|
119
|
+
# # if element_volume is None:
|
|
120
|
+
# # nelements /= 5
|
|
121
|
+
# # element_volume = box_vol / nelements
|
|
122
|
+
# # # calculate the step vector of a regular cube
|
|
123
|
+
# # step_vector = np.zeros(3)
|
|
124
|
+
# # step_vector[:] = element_volume ** (1.0 / 3.0)
|
|
125
|
+
# # # number of steps is the length of the box / step vector
|
|
126
|
+
# # nsteps = np.ceil((bb[1, :] - bb[0, :]) / step_vector).astype(int)
|
|
127
|
+
# # # create a structured grid using the origin and number of steps
|
|
128
|
+
# # if "meshbuilder" in kwargs:
|
|
129
|
+
# # mesh = kwargs["meshbuilder"].build(bb, nelements)
|
|
130
|
+
# # else:
|
|
131
|
+
# # mesh = kwargs.get(
|
|
132
|
+
# # "mesh",
|
|
133
|
+
# # TetMesh(origin=bb[0, :], nsteps=nsteps, step_vector=step_vector),
|
|
134
|
+
# # )
|
|
135
|
+
# # logger.info(
|
|
136
|
+
# # f"Creating regular tetrahedron mesh with {mesh.ntetra} elements \n"
|
|
137
|
+
# # "for modelling using DFI"
|
|
138
|
+
# # )
|
|
139
|
+
# # return DFI(mesh, kwargs["fold"])
|
|
140
|
+
# # if interpolatortype == "Surfe" or interpolatortype == "surfe":
|
|
141
|
+
# # # move import of surfe to where we actually try and use it
|
|
142
|
+
# # if not surfe:
|
|
143
|
+
# # logger.warning("Cannot import Surfe, try another interpolator")
|
|
144
|
+
# # raise ImportError("Cannot import surfepy, try pip install surfe")
|
|
145
|
+
# # method = kwargs.get("method", "single_surface")
|
|
146
|
+
# # logger.info("Using surfe interpolator")
|
|
147
|
+
# # return SurfeRBFInterpolator(method)
|
|
148
|
+
# # logger.warning("No interpolator")
|
|
149
|
+
# # raise InterpolatorError("Could not create interpolator")
|
|
@@ -0,0 +1,232 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Callable
|
|
4
|
+
|
|
5
|
+
import numpy as np
|
|
6
|
+
from loop_common.math import rng
|
|
7
|
+
from scipy import sparse
|
|
8
|
+
|
|
9
|
+
from ._discrete_interpolator import DiscreteInterpolator
|
|
10
|
+
from ._finite_difference_interpolator import (
|
|
11
|
+
FiniteDifferenceInterpolator,
|
|
12
|
+
)
|
|
13
|
+
from ._p1interpolator import P1Interpolator
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
class ConstantNormInterpolator:
|
|
17
|
+
"""Adds a non linear constraint to an interpolator to constrain
|
|
18
|
+
the norm of the gradient to be a set value.
|
|
19
|
+
|
|
20
|
+
Returns
|
|
21
|
+
-------
|
|
22
|
+
_type_
|
|
23
|
+
_description_
|
|
24
|
+
"""
|
|
25
|
+
|
|
26
|
+
def __init__(self, interpolator: DiscreteInterpolator, basetype):
|
|
27
|
+
"""Initialise the constant norm inteprolator
|
|
28
|
+
with a discrete interpolator.
|
|
29
|
+
|
|
30
|
+
Parameters
|
|
31
|
+
----------
|
|
32
|
+
interpolator : DiscreteInterpolator
|
|
33
|
+
The discrete interpolator to add constant norm to.
|
|
34
|
+
"""
|
|
35
|
+
self.basetype = basetype
|
|
36
|
+
self.interpolator = interpolator
|
|
37
|
+
self.support = interpolator.support
|
|
38
|
+
self.random_subset = False
|
|
39
|
+
self.norm_length = 1.0
|
|
40
|
+
self.n_iterations = 20
|
|
41
|
+
self.store_solution_history = False
|
|
42
|
+
self.solution_history = [] # np.zeros((self.n_iterations, self.support.n_nodes))
|
|
43
|
+
self.gradient_constraint_store = []
|
|
44
|
+
|
|
45
|
+
def add_constant_norm(self, w: float):
|
|
46
|
+
"""Add a constraint to the interpolator to constrain the norm of the gradient
|
|
47
|
+
to be a set value
|
|
48
|
+
|
|
49
|
+
Parameters
|
|
50
|
+
----------
|
|
51
|
+
w : float
|
|
52
|
+
weighting of the constraint
|
|
53
|
+
"""
|
|
54
|
+
if "constant norm" in self.interpolator.constraints:
|
|
55
|
+
_ = self.interpolator.constraints.pop("constant norm")
|
|
56
|
+
|
|
57
|
+
element_indices = np.arange(self.support.elements.shape[0])
|
|
58
|
+
if self.random_subset:
|
|
59
|
+
rng.shuffle(element_indices)
|
|
60
|
+
element_indices = element_indices[: int(0.1 * self.support.elements.shape[0])]
|
|
61
|
+
_vertices, gradient, elements, _inside = self.support.get_element_gradient_for_location(
|
|
62
|
+
self.support.barycentre[element_indices]
|
|
63
|
+
)
|
|
64
|
+
|
|
65
|
+
t_g = gradient[:, :, :]
|
|
66
|
+
# t_n = gradient[self.support.shared_element_relationships[:, 1], :, :]
|
|
67
|
+
v_t = np.einsum(
|
|
68
|
+
"ijk,ik->ij",
|
|
69
|
+
t_g,
|
|
70
|
+
self.interpolator.c[self.support.elements[elements]],
|
|
71
|
+
)
|
|
72
|
+
v_t_norm = np.linalg.norm(v_t, axis=1)
|
|
73
|
+
valid = v_t_norm > 0
|
|
74
|
+
if not np.any(valid):
|
|
75
|
+
return
|
|
76
|
+
v_t = v_t[valid] / v_t_norm[valid][:, np.newaxis]
|
|
77
|
+
element_indices = element_indices[valid]
|
|
78
|
+
t_g = t_g[valid]
|
|
79
|
+
elements = elements[valid]
|
|
80
|
+
self.gradient_constraint_store.append(
|
|
81
|
+
np.hstack([self.support.barycentre[element_indices], v_t])
|
|
82
|
+
)
|
|
83
|
+
A1 = np.einsum("ij,ijk->ik", v_t, t_g)
|
|
84
|
+
volume = self.support.element_size[element_indices]
|
|
85
|
+
A1 = A1 / volume[:, np.newaxis] # normalise by element size
|
|
86
|
+
|
|
87
|
+
b = np.zeros(A1.shape[0]) + self.norm_length
|
|
88
|
+
b = b / volume # normalise by element size
|
|
89
|
+
idc = np.hstack(
|
|
90
|
+
[
|
|
91
|
+
self.support.elements[elements],
|
|
92
|
+
]
|
|
93
|
+
)
|
|
94
|
+
self.interpolator.add_constraints_to_least_squares(A1, b, idc, w=w, name="constant norm")
|
|
95
|
+
|
|
96
|
+
def solve_system(
|
|
97
|
+
self,
|
|
98
|
+
solver: Callable[[sparse.csr_matrix, np.ndarray], np.ndarray] | str | None = None,
|
|
99
|
+
tol: float | None = None,
|
|
100
|
+
solver_kwargs: dict | None = None,
|
|
101
|
+
) -> bool:
|
|
102
|
+
"""Solve the system of equations iteratively for the constant norm interpolator.
|
|
103
|
+
|
|
104
|
+
Parameters
|
|
105
|
+
----------
|
|
106
|
+
solver : Optional[Union[Callable[[sparse.csr_matrix, np.ndarray], np.ndarray], str]], optional
|
|
107
|
+
Solver function or name, by default None
|
|
108
|
+
tol : Optional[float], optional
|
|
109
|
+
Tolerance for the solver, by default None
|
|
110
|
+
solver_kwargs : dict, optional
|
|
111
|
+
Additional arguments for the solver, by default {}
|
|
112
|
+
|
|
113
|
+
Returns
|
|
114
|
+
-------
|
|
115
|
+
bool
|
|
116
|
+
Success status of the solver
|
|
117
|
+
"""
|
|
118
|
+
solver_kwargs = dict(solver_kwargs or {})
|
|
119
|
+
success = True
|
|
120
|
+
for i in range(self.n_iterations):
|
|
121
|
+
if i > 0:
|
|
122
|
+
self.add_constant_norm(w=(0.1 * i) ** 2 + 0.01)
|
|
123
|
+
# Ensure the interpolator is cast to P1Interpolator before calling solve_system
|
|
124
|
+
if isinstance(self.interpolator, self.basetype):
|
|
125
|
+
success = self.basetype.solve_system(
|
|
126
|
+
self.interpolator, solver=solver, tol=tol, solver_kwargs=solver_kwargs
|
|
127
|
+
)
|
|
128
|
+
if self.store_solution_history:
|
|
129
|
+
self.solution_history.append(self.interpolator.c)
|
|
130
|
+
else:
|
|
131
|
+
raise TypeError("self.interpolator is not an instance of P1Interpolator")
|
|
132
|
+
if not success:
|
|
133
|
+
break
|
|
134
|
+
return success
|
|
135
|
+
|
|
136
|
+
|
|
137
|
+
class ConstantNormP1Interpolator(P1Interpolator, ConstantNormInterpolator):
|
|
138
|
+
"""Constant norm interpolator using P1 base interpolator
|
|
139
|
+
|
|
140
|
+
Parameters
|
|
141
|
+
----------
|
|
142
|
+
P1Interpolator : class
|
|
143
|
+
The P1Interpolator class.
|
|
144
|
+
ConstantNormInterpolator : class
|
|
145
|
+
The ConstantNormInterpolator class.
|
|
146
|
+
"""
|
|
147
|
+
|
|
148
|
+
def __init__(self, support):
|
|
149
|
+
"""Initialise the constant norm P1 interpolator.
|
|
150
|
+
|
|
151
|
+
Parameters
|
|
152
|
+
----------
|
|
153
|
+
support : _type_
|
|
154
|
+
_description_
|
|
155
|
+
"""
|
|
156
|
+
P1Interpolator.__init__(self, support)
|
|
157
|
+
ConstantNormInterpolator.__init__(self, self, P1Interpolator)
|
|
158
|
+
|
|
159
|
+
def solve_system(
|
|
160
|
+
self,
|
|
161
|
+
solver: Callable[[sparse.csr_matrix, np.ndarray], np.ndarray] | str | None = None,
|
|
162
|
+
tol: float | None = None,
|
|
163
|
+
solver_kwargs: dict | None = None,
|
|
164
|
+
) -> bool:
|
|
165
|
+
"""Solve the system of equations for the constant norm P1 interpolator.
|
|
166
|
+
|
|
167
|
+
Parameters
|
|
168
|
+
----------
|
|
169
|
+
solver : Optional[Union[Callable[[sparse.csr_matrix, np.ndarray], np.ndarray], str]], optional
|
|
170
|
+
Solver function or name, by default None
|
|
171
|
+
tol : Optional[float], optional
|
|
172
|
+
Tolerance for the solver, by default None
|
|
173
|
+
solver_kwargs : dict, optional
|
|
174
|
+
Additional arguments for the solver, by default {}
|
|
175
|
+
|
|
176
|
+
Returns
|
|
177
|
+
-------
|
|
178
|
+
bool
|
|
179
|
+
Success status of the solver
|
|
180
|
+
"""
|
|
181
|
+
return ConstantNormInterpolator.solve_system(
|
|
182
|
+
self, solver=solver, tol=tol, solver_kwargs=solver_kwargs
|
|
183
|
+
)
|
|
184
|
+
|
|
185
|
+
|
|
186
|
+
class ConstantNormFDIInterpolator(FiniteDifferenceInterpolator, ConstantNormInterpolator):
|
|
187
|
+
"""Constant norm interpolator using finite difference base interpolator
|
|
188
|
+
|
|
189
|
+
Parameters
|
|
190
|
+
----------
|
|
191
|
+
FiniteDifferenceInterpolator : class
|
|
192
|
+
The FiniteDifferenceInterpolator class.
|
|
193
|
+
ConstantNormInterpolator : class
|
|
194
|
+
The ConstantNormInterpolator class.
|
|
195
|
+
"""
|
|
196
|
+
|
|
197
|
+
def __init__(self, support):
|
|
198
|
+
"""Initialise the constant norm finite difference interpolator.
|
|
199
|
+
|
|
200
|
+
Parameters
|
|
201
|
+
----------
|
|
202
|
+
support : _type_
|
|
203
|
+
_description_
|
|
204
|
+
"""
|
|
205
|
+
FiniteDifferenceInterpolator.__init__(self, support)
|
|
206
|
+
ConstantNormInterpolator.__init__(self, self, FiniteDifferenceInterpolator)
|
|
207
|
+
|
|
208
|
+
def solve_system(
|
|
209
|
+
self,
|
|
210
|
+
solver: Callable[[sparse.csr_matrix, np.ndarray], np.ndarray] | str | None = None,
|
|
211
|
+
tol: float | None = None,
|
|
212
|
+
solver_kwargs: dict | None = None,
|
|
213
|
+
) -> bool:
|
|
214
|
+
"""Solve the system of equations for the constant norm finite difference interpolator.
|
|
215
|
+
|
|
216
|
+
Parameters
|
|
217
|
+
----------
|
|
218
|
+
solver : Optional[Union[Callable[[sparse.csr_matrix, np.ndarray], np.ndarray], str]], optional
|
|
219
|
+
Solver function or name, by default None
|
|
220
|
+
tol : Optional[float], optional
|
|
221
|
+
Tolerance for the solver, by default None
|
|
222
|
+
solver_kwargs : dict, optional
|
|
223
|
+
Additional arguments for the solver, by default {}
|
|
224
|
+
|
|
225
|
+
Returns
|
|
226
|
+
-------
|
|
227
|
+
bool
|
|
228
|
+
Success status of the solver
|
|
229
|
+
"""
|
|
230
|
+
return ConstantNormInterpolator.solve_system(
|
|
231
|
+
self, solver=solver, tol=tol, solver_kwargs=solver_kwargs
|
|
232
|
+
)
|
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from dataclasses import dataclass, field
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
@dataclass(frozen=True)
|
|
7
|
+
class ConstraintFamilyDiagnostics:
|
|
8
|
+
name: str
|
|
9
|
+
active: bool
|
|
10
|
+
row_count: int
|
|
11
|
+
dropped_rows: int | None
|
|
12
|
+
effective_weight_mean: float | None
|
|
13
|
+
effective_weight_min: float | None
|
|
14
|
+
effective_weight_max: float | None
|
|
15
|
+
source_point_count: int = 0
|
|
16
|
+
outside_model_point_count: int = 0
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
@dataclass(frozen=True)
|
|
20
|
+
class RegionCoverageDiagnostics:
|
|
21
|
+
total_support_nodes: int
|
|
22
|
+
active_region_nodes: int
|
|
23
|
+
inactive_region_nodes: int
|
|
24
|
+
active_fraction: float
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
@dataclass(frozen=True)
|
|
28
|
+
class ConstraintDiagnosticsReport:
|
|
29
|
+
interpolator_type: str
|
|
30
|
+
families: dict[str, ConstraintFamilyDiagnostics] = field(default_factory=dict)
|
|
31
|
+
region_coverage: RegionCoverageDiagnostics | None = None
|
|
32
|
+
outside_model_points: dict[str, int] = field(default_factory=dict)
|
|
33
|
+
|
|
34
|
+
@property
|
|
35
|
+
def total_rows(self) -> int:
|
|
36
|
+
return int(sum(f.row_count for f in self.families.values()))
|
|
37
|
+
|
|
38
|
+
@property
|
|
39
|
+
def active_families(self) -> dict[str, ConstraintFamilyDiagnostics]:
|
|
40
|
+
return {k: v for k, v in self.families.items() if v.active}
|
|
41
|
+
|
|
42
|
+
def to_dict(self) -> dict:
|
|
43
|
+
return {
|
|
44
|
+
"interpolator_type": self.interpolator_type,
|
|
45
|
+
"total_rows": self.total_rows,
|
|
46
|
+
"families": {
|
|
47
|
+
name: {
|
|
48
|
+
"active": family.active,
|
|
49
|
+
"row_count": family.row_count,
|
|
50
|
+
"dropped_rows": family.dropped_rows,
|
|
51
|
+
"effective_weight_mean": family.effective_weight_mean,
|
|
52
|
+
"effective_weight_min": family.effective_weight_min,
|
|
53
|
+
"effective_weight_max": family.effective_weight_max,
|
|
54
|
+
"source_point_count": family.source_point_count,
|
|
55
|
+
"outside_model_point_count": family.outside_model_point_count,
|
|
56
|
+
}
|
|
57
|
+
for name, family in self.families.items()
|
|
58
|
+
},
|
|
59
|
+
"region_coverage": None
|
|
60
|
+
if self.region_coverage is None
|
|
61
|
+
else {
|
|
62
|
+
"total_support_nodes": self.region_coverage.total_support_nodes,
|
|
63
|
+
"active_region_nodes": self.region_coverage.active_region_nodes,
|
|
64
|
+
"inactive_region_nodes": self.region_coverage.inactive_region_nodes,
|
|
65
|
+
"active_fraction": self.region_coverage.active_fraction,
|
|
66
|
+
},
|
|
67
|
+
"outside_model_points": dict(self.outside_model_points),
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
def summary(self) -> str:
|
|
71
|
+
lines = [
|
|
72
|
+
f"Constraint diagnostics for {self.interpolator_type}",
|
|
73
|
+
f"Total rows: {self.total_rows}",
|
|
74
|
+
"Active families:",
|
|
75
|
+
]
|
|
76
|
+
active = self.active_families
|
|
77
|
+
if len(active) == 0:
|
|
78
|
+
lines.append(" - none")
|
|
79
|
+
for name, family in sorted(active.items()):
|
|
80
|
+
dropped = "unknown" if family.dropped_rows is None else str(family.dropped_rows)
|
|
81
|
+
mean_weight = (
|
|
82
|
+
"n/a"
|
|
83
|
+
if family.effective_weight_mean is None
|
|
84
|
+
else f"{family.effective_weight_mean:.4g}"
|
|
85
|
+
)
|
|
86
|
+
lines.append(
|
|
87
|
+
f" - {name}: rows={family.row_count}, dropped={dropped}, mean_weight={mean_weight}"
|
|
88
|
+
)
|
|
89
|
+
|
|
90
|
+
if self.region_coverage is not None:
|
|
91
|
+
lines.append(
|
|
92
|
+
"Region coverage: "
|
|
93
|
+
f"{self.region_coverage.active_region_nodes}/{self.region_coverage.total_support_nodes} "
|
|
94
|
+
f"({self.region_coverage.active_fraction:.1%})"
|
|
95
|
+
)
|
|
96
|
+
|
|
97
|
+
if len(self.outside_model_points) > 0:
|
|
98
|
+
lines.append("Outside-model points:")
|
|
99
|
+
for key, value in sorted(self.outside_model_points.items()):
|
|
100
|
+
lines.append(f" - {key}: {value}")
|
|
101
|
+
|
|
102
|
+
return "\n".join(lines)
|