|
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 |
| 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 | 15 |
|
16 | | -logger = getLogger(__name__) |
| 16 | +# logger = getLogger(__name__) |
17 | 17 |
|
18 | 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") |
| 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 | 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 | | - ) |
| 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 | 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") |
| 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 | 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 |
| 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 | 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 |
| 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 | 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") |
| 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 commit comments