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.
Files changed (39) hide show
  1. loop_interpolation/__init__.py +152 -0
  2. loop_interpolation/_builders.py +149 -0
  3. loop_interpolation/_constant_norm.py +232 -0
  4. loop_interpolation/_diagnostics.py +102 -0
  5. loop_interpolation/_discrete_fold_interpolator.py +242 -0
  6. loop_interpolation/_discrete_interpolator.py +1405 -0
  7. loop_interpolation/_fd_fold_interpolator.py +237 -0
  8. loop_interpolation/_finite_difference_interpolator.py +1348 -0
  9. loop_interpolation/_fold_event.py +185 -0
  10. loop_interpolation/_fold_norm_alignment.py +118 -0
  11. loop_interpolation/_fold_setup.py +39 -0
  12. loop_interpolation/_geological_interpolator.py +920 -0
  13. loop_interpolation/_interpolator_builder.py +251 -0
  14. loop_interpolation/_interpolator_factory.py +167 -0
  15. loop_interpolation/_interpolatortype.py +20 -0
  16. loop_interpolation/_operator.py +44 -0
  17. loop_interpolation/_p1interpolator.py +299 -0
  18. loop_interpolation/_p2interpolator.py +317 -0
  19. loop_interpolation/_regularisation.py +110 -0
  20. loop_interpolation/_solver_pipeline.py +138 -0
  21. loop_interpolation/_solver_strategy.py +218 -0
  22. loop_interpolation/_surfe_wrapper.py +211 -0
  23. loop_interpolation/_svariogram.py +133 -0
  24. loop_interpolation/_validation.py +604 -0
  25. loop_interpolation/constraints.py +473 -0
  26. loop_interpolation/fold_function/__init__.py +39 -0
  27. loop_interpolation/fold_function/_base_fold_rotation_angle.py +219 -0
  28. loop_interpolation/fold_function/_fourier_series_fold_rotation_angle.py +131 -0
  29. loop_interpolation/fold_function/_lambda_fold_rotation_angle.py +53 -0
  30. loop_interpolation/loopsolver/__init__.py +2 -0
  31. loop_interpolation/loopsolver/admm_constant_norm.py +118 -0
  32. loop_interpolation/loopsolver/admm_method.py +25 -0
  33. loop_interpolation/loopsolver/admm_solver.py +463 -0
  34. loop_interpolation/loopsolver/version.py +1 -0
  35. loop_interpolation-0.0.1.dist-info/METADATA +34 -0
  36. loop_interpolation-0.0.1.dist-info/RECORD +39 -0
  37. loop_interpolation-0.0.1.dist-info/WHEEL +5 -0
  38. loop_interpolation-0.0.1.dist-info/licenses/LICENSE +21 -0
  39. 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)