fiesta-pkg 1.0.2__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.
- docs/source/conf.py +56 -0
- fiesta/__init__.py +12 -0
- fiesta/boundary/__init__.py +18 -0
- fiesta/boundary/mpi_periodic.py +216 -0
- fiesta/boundary/mpi_randoms.py +215 -0
- fiesta/boundary/periodic.py +322 -0
- fiesta/boundary/randoms.py +167 -0
- fiesta/coords/__init__.py +16 -0
- fiesta/coords/mpi_points.py +639 -0
- fiesta/coords/points.py +153 -0
- fiesta/dtfe/__init__.py +19 -0
- fiesta/dtfe/dtfe2d.py +562 -0
- fiesta/dtfe/dtfe3d.py +759 -0
- fiesta/dtfe/dtfe4grid.py +1709 -0
- fiesta/dtfe/mpi_dtfe4grid.py +1146 -0
- fiesta/gridsph/__init__.py +9 -0
- fiesta/gridsph/gridsph.py +221 -0
- fiesta/gridsph/integral_image.py +46 -0
- fiesta/gridsph/mpi_gridsph.py +412 -0
- fiesta/interp/__init__.py +6 -0
- fiesta/interp/bilinear.py +273 -0
- fiesta/interp/trilinear.py +339 -0
- fiesta/kdtree/__init__.py +3 -0
- fiesta/kdtree/kdtree1d.py +87 -0
- fiesta/kdtree/kdtree2d.py +97 -0
- fiesta/kdtree/kdtree3d.py +112 -0
- fiesta/maths/__init__.py +10 -0
- fiesta/maths/diff.py +213 -0
- fiesta/maths/matrix.py +122 -0
- fiesta/maths/mpi_diff.py +116 -0
- fiesta/p2g/__init__.py +11 -0
- fiesta/p2g/deconvol.py +255 -0
- fiesta/p2g/mpi_part2grid.py +271 -0
- fiesta/p2g/part2grid.py +214 -0
- fiesta/randoms/__init__.py +3 -0
- fiesta/randoms/cartesian.py +102 -0
- fiesta/sph/__init__.py +12 -0
- fiesta/sph/kernels.py +87 -0
- fiesta/sph/mpi_sph4grid.py +312 -0
- fiesta/sph/sph1d.py +167 -0
- fiesta/sph/sph2d.py +167 -0
- fiesta/sph/sph3d.py +174 -0
- fiesta/sph/sph4grid.py +269 -0
- fiesta/src/__init__.py +69 -0
- fiesta/src/bilinear.py +307 -0
- fiesta/src/delaunay2d.py +190 -0
- fiesta/src/delaunay3d.py +244 -0
- fiesta/src/differentiate.py +248 -0
- fiesta/src/grid.py +52 -0
- fiesta/src/gridsph.py +831 -0
- fiesta/src/matrix.py +147 -0
- fiesta/src/part2grid_2d.py +291 -0
- fiesta/src/part2grid_3d.py +346 -0
- fiesta/src/part2grid_pix.py +306 -0
- fiesta/src/part2grid_wei.py +105 -0
- fiesta/src/polygon.py +72 -0
- fiesta/src/polyhedron.py +46 -0
- fiesta/src/trilinear.py +429 -0
- fiesta/src/voronoi2d.py +96 -0
- fiesta/src/voronoi3d.py +111 -0
- fiesta/utils/__init__.py +7 -0
- fiesta/utils/complex.py +37 -0
- fiesta/utils/lists.py +15 -0
- fiesta/utils/vectors.py +41 -0
- fiesta_pkg-1.0.2.dist-info/METADATA +146 -0
- fiesta_pkg-1.0.2.dist-info/RECORD +91 -0
- fiesta_pkg-1.0.2.dist-info/WHEEL +5 -0
- fiesta_pkg-1.0.2.dist-info/top_level.txt +3 -0
- tests/mpi_tests/test_mpi_boundary.py +194 -0
- tests/mpi_tests/test_mpi_coords.py +373 -0
- tests/mpi_tests/test_mpi_diff.py +113 -0
- tests/mpi_tests/test_mpi_dtfe4grid.py +245 -0
- tests/mpi_tests/test_mpi_gridsph.py +377 -0
- tests/mpi_tests/test_mpi_interp.py +340 -0
- tests/mpi_tests/test_mpi_part2grid.py +227 -0
- tests/mpi_tests/test_mpi_randoms.py +108 -0
- tests/mpi_tests/test_mpi_routines.py +215 -0
- tests/mpi_tests/test_mpi_sph4grid.py +353 -0
- tests/normal_tests/test_boundary.py +126 -0
- tests/normal_tests/test_coords.py +91 -0
- tests/normal_tests/test_dtfe.py +747 -0
- tests/normal_tests/test_gridsph.py +456 -0
- tests/normal_tests/test_interp.py +106 -0
- tests/normal_tests/test_kdtree.py +79 -0
- tests/normal_tests/test_maths.py +52 -0
- tests/normal_tests/test_mpi_dtfe4grid.py +339 -0
- tests/normal_tests/test_p2g.py +178 -0
- tests/normal_tests/test_randoms.py +26 -0
- tests/normal_tests/test_sph.py +128 -0
- tests/normal_tests/test_sph4grid.py +331 -0
- tests/normal_tests/test_utils.py +45 -0
|
@@ -0,0 +1,322 @@
|
|
|
1
|
+
import numpy as np
|
|
2
|
+
|
|
3
|
+
from typing import List, Union
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
def buffer_periodic(
|
|
7
|
+
data: np.ndarray,
|
|
8
|
+
axis: int,
|
|
9
|
+
boxsize: float,
|
|
10
|
+
buffer_length: float,
|
|
11
|
+
origin: float = 0.0,
|
|
12
|
+
) -> np.ndarray:
|
|
13
|
+
"""
|
|
14
|
+
Returns periodic boundary conditions.
|
|
15
|
+
|
|
16
|
+
Parameters
|
|
17
|
+
----------
|
|
18
|
+
data : array
|
|
19
|
+
Data for which we want periodic boundaries.
|
|
20
|
+
axis : int
|
|
21
|
+
The axis which we want periodic boundaries.
|
|
22
|
+
boxsize : float
|
|
23
|
+
Box size.
|
|
24
|
+
buffer_length : float
|
|
25
|
+
Length of the buffer region.
|
|
26
|
+
origin : float, optional
|
|
27
|
+
Origin point.
|
|
28
|
+
|
|
29
|
+
Returns
|
|
30
|
+
-------
|
|
31
|
+
datap : array
|
|
32
|
+
Data with periodic buffer particles.
|
|
33
|
+
"""
|
|
34
|
+
cond1 = np.where(data[:, axis] >= origin + boxsize - buffer_length)[0]
|
|
35
|
+
_d1 = data[cond1]
|
|
36
|
+
_d1[:, axis] -= boxsize
|
|
37
|
+
cond2 = np.where(data[:, axis] <= origin + buffer_length)[0]
|
|
38
|
+
_d2 = data[cond2]
|
|
39
|
+
_d2[:, axis] += boxsize
|
|
40
|
+
datap = np.vstack([data, _d1, _d2])
|
|
41
|
+
return datap
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
def subbox_buffer_periodic(
|
|
45
|
+
data: np.ndarray,
|
|
46
|
+
axis: int,
|
|
47
|
+
boxsize: float,
|
|
48
|
+
buffer_length: float,
|
|
49
|
+
subboxsize: float,
|
|
50
|
+
origin: float = 0.0,
|
|
51
|
+
subbox_origin: float = 0.0,
|
|
52
|
+
) -> np.ndarray:
|
|
53
|
+
"""
|
|
54
|
+
Returns periodic boundary conditions in a subbox.
|
|
55
|
+
|
|
56
|
+
Parameters
|
|
57
|
+
----------
|
|
58
|
+
data : array
|
|
59
|
+
Data for which we want periodic boundaries.
|
|
60
|
+
axis : int
|
|
61
|
+
The axis which we want periodic boundaries.
|
|
62
|
+
boxsize : float
|
|
63
|
+
Box size.
|
|
64
|
+
buffer_length : float
|
|
65
|
+
Length of the buffer region.
|
|
66
|
+
subboxsize : float
|
|
67
|
+
Size of subbox.
|
|
68
|
+
origin : float, optional
|
|
69
|
+
Origin point.
|
|
70
|
+
subbox_origin : float, optional
|
|
71
|
+
Origin point for the subbox.
|
|
72
|
+
|
|
73
|
+
Returns
|
|
74
|
+
-------
|
|
75
|
+
datap : array
|
|
76
|
+
Data with periodic buffer particles.
|
|
77
|
+
"""
|
|
78
|
+
datap = buffer_periodic(data, axis, boxsize, buffer_length, origin=origin)
|
|
79
|
+
cond = np.where(
|
|
80
|
+
(datap[:, axis] >= subbox_origin - buffer_length)
|
|
81
|
+
& (datap[:, axis] <= subbox_origin + subboxsize + buffer_length)
|
|
82
|
+
)[0]
|
|
83
|
+
datap = datap[cond]
|
|
84
|
+
return datap
|
|
85
|
+
|
|
86
|
+
|
|
87
|
+
def buffer_periodic_2D(
|
|
88
|
+
data: np.ndarray,
|
|
89
|
+
boxsize: Union[float, List[float]],
|
|
90
|
+
buffer_length: float,
|
|
91
|
+
origin: Union[float, List[float]] = 0.0,
|
|
92
|
+
) -> np.ndarray:
|
|
93
|
+
"""
|
|
94
|
+
Generates random buffer particles around a 2D box.
|
|
95
|
+
|
|
96
|
+
Parameters
|
|
97
|
+
----------
|
|
98
|
+
data : array
|
|
99
|
+
Where columns 0 and 1 are x and y.
|
|
100
|
+
boxsize : float or list
|
|
101
|
+
Box size.
|
|
102
|
+
buffer_length : float
|
|
103
|
+
Length of the buffer region.
|
|
104
|
+
origin : float or list, optional
|
|
105
|
+
Origin point.
|
|
106
|
+
|
|
107
|
+
Returns
|
|
108
|
+
-------
|
|
109
|
+
datap : array
|
|
110
|
+
Periodic data values.
|
|
111
|
+
"""
|
|
112
|
+
if np.isscalar(origin):
|
|
113
|
+
xorigin, yorigin = origin, origin
|
|
114
|
+
else:
|
|
115
|
+
xorigin, yorigin = origin[0], origin[1]
|
|
116
|
+
if np.isscalar(boxsize):
|
|
117
|
+
xboxsize, yboxsize = boxsize, boxsize
|
|
118
|
+
else:
|
|
119
|
+
xboxsize, yboxsize = boxsize[0], boxsize[1]
|
|
120
|
+
datap = buffer_periodic(data, 0, xboxsize, buffer_length, origin=xorigin)
|
|
121
|
+
datap = buffer_periodic(datap, 1, yboxsize, buffer_length, origin=yorigin)
|
|
122
|
+
return datap
|
|
123
|
+
|
|
124
|
+
|
|
125
|
+
def subbox_buffer_periodic_2D(
|
|
126
|
+
data: np.ndarray,
|
|
127
|
+
boxsize: Union[float, List[float]],
|
|
128
|
+
buffer_length: float,
|
|
129
|
+
subboxsize: Union[float, List[float]],
|
|
130
|
+
origin: Union[float, List[float]] = 0.0,
|
|
131
|
+
subbox_origin: Union[float, List[float]] = 0.0,
|
|
132
|
+
) -> np.ndarray:
|
|
133
|
+
"""
|
|
134
|
+
Generates random buffer particles around a 2D box.
|
|
135
|
+
|
|
136
|
+
Parameters
|
|
137
|
+
----------
|
|
138
|
+
data : array
|
|
139
|
+
Data for which we want periodic boundaries.
|
|
140
|
+
axis : int
|
|
141
|
+
The axis which we want periodic boundaries.
|
|
142
|
+
boxsize : float or list
|
|
143
|
+
Box size.
|
|
144
|
+
buffer_length : float
|
|
145
|
+
Length of the buffer region.
|
|
146
|
+
subboxsize : float or list
|
|
147
|
+
Size of subbox.
|
|
148
|
+
origin : float or list, optional
|
|
149
|
+
Origin point.
|
|
150
|
+
subbox_origin : float or list, optional
|
|
151
|
+
Origin point for the subbox.
|
|
152
|
+
|
|
153
|
+
Returns
|
|
154
|
+
-------
|
|
155
|
+
datap : array
|
|
156
|
+
Periodic data values.
|
|
157
|
+
"""
|
|
158
|
+
if np.isscalar(origin):
|
|
159
|
+
xorigin, yorigin = origin, origin
|
|
160
|
+
else:
|
|
161
|
+
xorigin, yorigin = origin[0], origin[1]
|
|
162
|
+
if np.isscalar(boxsize):
|
|
163
|
+
xboxsize, yboxsize = boxsize, boxsize
|
|
164
|
+
else:
|
|
165
|
+
xboxsize, yboxsize = boxsize[0], boxsize[1]
|
|
166
|
+
if np.isscalar(subbox_origin):
|
|
167
|
+
subbox_xorigin, subbox_yorigin = subbox_origin, subbox_origin
|
|
168
|
+
else:
|
|
169
|
+
subbox_xorigin, subbox_yorigin = subbox_origin[0], subbox_origin[1]
|
|
170
|
+
if np.isscalar(subboxsize):
|
|
171
|
+
xsubboxsize, ysubboxsize = subboxsize, subboxsize
|
|
172
|
+
else:
|
|
173
|
+
xsubboxsize, ysubboxsize = subboxsize[0], subboxsize[1]
|
|
174
|
+
datap = subbox_buffer_periodic(
|
|
175
|
+
data,
|
|
176
|
+
0,
|
|
177
|
+
xboxsize,
|
|
178
|
+
buffer_length,
|
|
179
|
+
xsubboxsize,
|
|
180
|
+
origin=xorigin,
|
|
181
|
+
subbox_origin=subbox_xorigin,
|
|
182
|
+
)
|
|
183
|
+
datap = subbox_buffer_periodic(
|
|
184
|
+
datap,
|
|
185
|
+
1,
|
|
186
|
+
yboxsize,
|
|
187
|
+
buffer_length,
|
|
188
|
+
ysubboxsize,
|
|
189
|
+
origin=yorigin,
|
|
190
|
+
subbox_origin=subbox_yorigin,
|
|
191
|
+
)
|
|
192
|
+
return datap
|
|
193
|
+
|
|
194
|
+
|
|
195
|
+
def buffer_periodic_3D(
|
|
196
|
+
data: np.ndarray,
|
|
197
|
+
boxsize: Union[float, List[float]],
|
|
198
|
+
buffer_length: float,
|
|
199
|
+
origin: Union[float, List[float]] = 0.0,
|
|
200
|
+
) -> np.ndarray:
|
|
201
|
+
"""
|
|
202
|
+
Generates random buffer particles around a 3D box.
|
|
203
|
+
|
|
204
|
+
Parameters
|
|
205
|
+
----------
|
|
206
|
+
data : array
|
|
207
|
+
Where columns 0, 1 and 2 correspond to the x, y and z coordinates.
|
|
208
|
+
boxsize : float or list
|
|
209
|
+
Box size.
|
|
210
|
+
buffer_length : float
|
|
211
|
+
Length of the buffer region.
|
|
212
|
+
origin : float or list, optional
|
|
213
|
+
Origin point.
|
|
214
|
+
|
|
215
|
+
Returns
|
|
216
|
+
-------
|
|
217
|
+
datap : array
|
|
218
|
+
Periodic data values.
|
|
219
|
+
"""
|
|
220
|
+
if np.isscalar(origin):
|
|
221
|
+
xorigin, yorigin, zorigin = origin, origin, origin
|
|
222
|
+
else:
|
|
223
|
+
xorigin, yorigin, zorigin = origin[0], origin[1], origin[2]
|
|
224
|
+
if np.isscalar(boxsize):
|
|
225
|
+
xboxsize, yboxsize, zboxsize = boxsize, boxsize, boxsize
|
|
226
|
+
else:
|
|
227
|
+
xboxsize, yboxsize, zboxsize = boxsize[0], boxsize[1], boxsize[2]
|
|
228
|
+
datap = buffer_periodic(data, 0, xboxsize, buffer_length, origin=xorigin)
|
|
229
|
+
datap = buffer_periodic(datap, 1, yboxsize, buffer_length, origin=yorigin)
|
|
230
|
+
datap = buffer_periodic(datap, 2, zboxsize, buffer_length, origin=zorigin)
|
|
231
|
+
return datap
|
|
232
|
+
|
|
233
|
+
|
|
234
|
+
def subbox_buffer_periodic_3D(
|
|
235
|
+
data: np.ndarray,
|
|
236
|
+
boxsize: Union[float, List[float]],
|
|
237
|
+
buffer_length: float,
|
|
238
|
+
subboxsize: Union[float, List[float]],
|
|
239
|
+
origin: Union[float, List[float]] = 0.0,
|
|
240
|
+
subbox_origin: Union[float, List[float]] = 0.0,
|
|
241
|
+
) -> np.ndarray:
|
|
242
|
+
"""
|
|
243
|
+
Generates random buffer particles around a 3D box.
|
|
244
|
+
|
|
245
|
+
Parameters
|
|
246
|
+
----------
|
|
247
|
+
data : array
|
|
248
|
+
Data for which we want periodic boundaries.
|
|
249
|
+
axis : int
|
|
250
|
+
The axis which we want periodic boundaries.
|
|
251
|
+
boxsize : float or list
|
|
252
|
+
Box size.
|
|
253
|
+
buffer_length : float
|
|
254
|
+
Length of the buffer region.
|
|
255
|
+
subboxsize : float or list
|
|
256
|
+
Size of subbox.
|
|
257
|
+
origin : float or list, optional
|
|
258
|
+
Origin point.
|
|
259
|
+
subbox_origin : float or list, optional
|
|
260
|
+
Origin point for the subbox.
|
|
261
|
+
|
|
262
|
+
Returns
|
|
263
|
+
-------
|
|
264
|
+
datap : array
|
|
265
|
+
Periodic data values.
|
|
266
|
+
"""
|
|
267
|
+
if np.isscalar(origin):
|
|
268
|
+
xorigin, yorigin, zorigin = origin, origin, origin
|
|
269
|
+
else:
|
|
270
|
+
xorigin, yorigin, zorigin = origin[0], origin[1], origin[2]
|
|
271
|
+
if np.isscalar(boxsize):
|
|
272
|
+
xboxsize, yboxsize, zboxsize = boxsize, boxsize, boxsize
|
|
273
|
+
else:
|
|
274
|
+
xboxsize, yboxsize, zboxsize = boxsize[0], boxsize[1], boxsize[2]
|
|
275
|
+
if np.isscalar(subbox_origin):
|
|
276
|
+
subbox_xorigin, subbox_yorigin, subbox_zorigin = (
|
|
277
|
+
subbox_origin,
|
|
278
|
+
subbox_origin,
|
|
279
|
+
subbox_origin,
|
|
280
|
+
)
|
|
281
|
+
else:
|
|
282
|
+
subbox_xorigin, subbox_yorigin, subbox_zorigin = (
|
|
283
|
+
subbox_origin[0],
|
|
284
|
+
subbox_origin[1],
|
|
285
|
+
subbox_origin[2],
|
|
286
|
+
)
|
|
287
|
+
if np.isscalar(subboxsize):
|
|
288
|
+
xsubboxsize, ysubboxsize, zsubboxsize = subboxsize, subboxsize, subboxsize
|
|
289
|
+
else:
|
|
290
|
+
xsubboxsize, ysubboxsize, zsubboxsize = (
|
|
291
|
+
subboxsize[0],
|
|
292
|
+
subboxsize[1],
|
|
293
|
+
subboxsize[2],
|
|
294
|
+
)
|
|
295
|
+
datap = subbox_buffer_periodic(
|
|
296
|
+
data,
|
|
297
|
+
0,
|
|
298
|
+
xboxsize,
|
|
299
|
+
buffer_length,
|
|
300
|
+
xsubboxsize,
|
|
301
|
+
origin=xorigin,
|
|
302
|
+
subbox_origin=subbox_xorigin,
|
|
303
|
+
)
|
|
304
|
+
datap = subbox_buffer_periodic(
|
|
305
|
+
datap,
|
|
306
|
+
1,
|
|
307
|
+
yboxsize,
|
|
308
|
+
buffer_length,
|
|
309
|
+
ysubboxsize,
|
|
310
|
+
origin=yorigin,
|
|
311
|
+
subbox_origin=subbox_yorigin,
|
|
312
|
+
)
|
|
313
|
+
datap = subbox_buffer_periodic(
|
|
314
|
+
datap,
|
|
315
|
+
2,
|
|
316
|
+
zboxsize,
|
|
317
|
+
buffer_length,
|
|
318
|
+
zsubboxsize,
|
|
319
|
+
origin=zorigin,
|
|
320
|
+
subbox_origin=subbox_zorigin,
|
|
321
|
+
)
|
|
322
|
+
return datap
|
|
@@ -0,0 +1,167 @@
|
|
|
1
|
+
import numpy as np
|
|
2
|
+
|
|
3
|
+
from .. import randoms
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
from typing import Tuple, Union, List
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
def buffer_random_2D(
|
|
10
|
+
npart: int,
|
|
11
|
+
boxsize: Union[float, List[float]],
|
|
12
|
+
buffer_length: float,
|
|
13
|
+
origin: Union[float, List[float]] = 0.0,
|
|
14
|
+
) -> Tuple[np.ndarray, np.ndarray]:
|
|
15
|
+
"""
|
|
16
|
+
Generates random buffer particles around a 2D box.
|
|
17
|
+
|
|
18
|
+
Parameters
|
|
19
|
+
----------
|
|
20
|
+
npart : int
|
|
21
|
+
Number of particles in the 2D box.
|
|
22
|
+
boxsize : float or list
|
|
23
|
+
Box size.
|
|
24
|
+
buffer_length : float
|
|
25
|
+
Length of the buffer region.
|
|
26
|
+
origin : float or list, optional
|
|
27
|
+
Origin point.
|
|
28
|
+
|
|
29
|
+
Returns
|
|
30
|
+
-------
|
|
31
|
+
x : array
|
|
32
|
+
Random x-values.
|
|
33
|
+
y : array
|
|
34
|
+
Random y-values.
|
|
35
|
+
"""
|
|
36
|
+
if np.isscalar(origin):
|
|
37
|
+
xorigin, yorigin = origin, origin
|
|
38
|
+
else:
|
|
39
|
+
xorigin, yorigin = origin[0], origin[1]
|
|
40
|
+
if np.isscalar(boxsize):
|
|
41
|
+
xboxsize, yboxsize = boxsize, boxsize
|
|
42
|
+
else:
|
|
43
|
+
xboxsize, yboxsize = boxsize[0], boxsize[1]
|
|
44
|
+
# Determine number of particles needed in the padded region to maintain
|
|
45
|
+
# the average density.
|
|
46
|
+
part_dens = npart / (xboxsize * yboxsize)
|
|
47
|
+
# box edge 1
|
|
48
|
+
_xmin = xorigin - buffer_length
|
|
49
|
+
_xmax = xorigin + xboxsize
|
|
50
|
+
_ymin = yorigin - buffer_length
|
|
51
|
+
_ymax = yorigin
|
|
52
|
+
size1 = int(part_dens * (_xmax - _xmin) * (_ymax - _ymin))
|
|
53
|
+
x1, y1 = randoms.random_box(size1, _xmin, _xmax, _ymin, _ymax)
|
|
54
|
+
# box edge 2
|
|
55
|
+
_xmin = xorigin + xboxsize
|
|
56
|
+
_xmax = xorigin + xboxsize + buffer_length
|
|
57
|
+
_ymin = yorigin - buffer_length
|
|
58
|
+
_ymax = yorigin + yboxsize
|
|
59
|
+
size2 = int(part_dens * (_xmax - _xmin) * (_ymax - _ymin))
|
|
60
|
+
x2, y2 = randoms.random_box(size2, _xmin, _xmax, _ymin, _ymax)
|
|
61
|
+
# box edge 3
|
|
62
|
+
_xmin = xorigin
|
|
63
|
+
_xmax = xorigin + xboxsize + buffer_length
|
|
64
|
+
_ymin = yorigin + yboxsize
|
|
65
|
+
_ymax = yorigin + yboxsize + buffer_length
|
|
66
|
+
size3 = int(part_dens * (_xmax - _xmin) * (_ymax - _ymin))
|
|
67
|
+
x3, y3 = randoms.random_box(size3, _xmin, _xmax, _ymin, _ymax)
|
|
68
|
+
# box edge 4
|
|
69
|
+
_xmin = xorigin - buffer_length
|
|
70
|
+
_xmax = xorigin
|
|
71
|
+
_ymin = yorigin
|
|
72
|
+
_ymax = yorigin + yboxsize + buffer_length
|
|
73
|
+
size4 = int(part_dens * (_xmax - _xmin) * (_ymax - _ymin))
|
|
74
|
+
x4, y4 = randoms.random_box(size4, _xmin, _xmax, _ymin, _ymax)
|
|
75
|
+
x = np.concatenate([x1, x2, x3, x4])
|
|
76
|
+
y = np.concatenate([y1, y2, y3, y4])
|
|
77
|
+
return x, y
|
|
78
|
+
|
|
79
|
+
|
|
80
|
+
def buffer_random_3D(
|
|
81
|
+
npart: int,
|
|
82
|
+
boxsize: Union[float, List[float]],
|
|
83
|
+
buffer_length: float,
|
|
84
|
+
origin: Union[float, List[float]] = 0.0,
|
|
85
|
+
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
|
|
86
|
+
"""
|
|
87
|
+
Generates random buffer particles around a 3D box.
|
|
88
|
+
|
|
89
|
+
Parameters
|
|
90
|
+
----------
|
|
91
|
+
npart : int
|
|
92
|
+
Number of particles in the 3D box.
|
|
93
|
+
boxsize : float or list
|
|
94
|
+
Box size.
|
|
95
|
+
buffer_length : float
|
|
96
|
+
Length of the buffer region.
|
|
97
|
+
origin : float or list, optional
|
|
98
|
+
Origin point.
|
|
99
|
+
|
|
100
|
+
Returns
|
|
101
|
+
-------
|
|
102
|
+
x : array
|
|
103
|
+
Random x-values.
|
|
104
|
+
y : array
|
|
105
|
+
Random y-values.
|
|
106
|
+
z : array
|
|
107
|
+
Random z-values.
|
|
108
|
+
"""
|
|
109
|
+
if np.isscalar(origin):
|
|
110
|
+
xorigin, yorigin, zorigin = origin, origin, origin
|
|
111
|
+
else:
|
|
112
|
+
xorigin, yorigin, zorigin = origin[0], origin[1], origin[2]
|
|
113
|
+
if np.isscalar(boxsize):
|
|
114
|
+
xboxsize, yboxsize, zboxsize = boxsize, boxsize, boxsize
|
|
115
|
+
else:
|
|
116
|
+
xboxsize, yboxsize, zboxsize = boxsize[0], boxsize[1], boxsize[2]
|
|
117
|
+
box_vol = xboxsize * yboxsize * zboxsize
|
|
118
|
+
part_dens = npart / box_vol
|
|
119
|
+
# Divide into three regions along z-axis
|
|
120
|
+
# Region 1: zrange = [-buffer_length, 0.]
|
|
121
|
+
# Region 2: zrange = [0., boxsize]
|
|
122
|
+
# Region 3: zrange = [boxsize, boxsize+buffer_length]
|
|
123
|
+
# Splitting region 2, into four regions.
|
|
124
|
+
# Subregion 21: xrange = [-buffer_length, boxsize], yrange = [-buffer_length, 0]
|
|
125
|
+
# Subregion 22: xrange = [boxsize, boxsize+buffer_length], yrange =[-buffer_length, boxsize]
|
|
126
|
+
# Subregion 23: xrange = [0, boxsize+buffer_length], yrange=[boxsize, boxsize+buffer_length]
|
|
127
|
+
# Subregion 24: xrange = [-buffer_length, 0], yrange = [0, boxsize+buffer_length]
|
|
128
|
+
# Region 1
|
|
129
|
+
xmin, xmax = xorigin - buffer_length, xorigin + xboxsize + buffer_length
|
|
130
|
+
ymin, ymax = yorigin - buffer_length, yorigin + yboxsize + buffer_length
|
|
131
|
+
zmin, zmax = zorigin - buffer_length, zorigin
|
|
132
|
+
npart1 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
|
|
133
|
+
x1, y1, z1 = randoms.random_cube(npart1, xmin, xmax, ymin, ymax, zmin, zmax)
|
|
134
|
+
# Region 3
|
|
135
|
+
xmin, xmax = xorigin - buffer_length, xorigin + xboxsize + buffer_length
|
|
136
|
+
ymin, ymax = yorigin - buffer_length, yorigin + yboxsize + buffer_length
|
|
137
|
+
zmin, zmax = zorigin + zboxsize, zorigin + zboxsize + buffer_length
|
|
138
|
+
npart3 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
|
|
139
|
+
x3, y3, z3 = randoms.random_cube(npart3, xmin, xmax, ymin, ymax, zmin, zmax)
|
|
140
|
+
# Subregion 21
|
|
141
|
+
xmin, xmax = xorigin - buffer_length, xorigin + xboxsize
|
|
142
|
+
ymin, ymax = yorigin - buffer_length, yorigin
|
|
143
|
+
zmin, zmax = zorigin, zorigin + zboxsize
|
|
144
|
+
npart21 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
|
|
145
|
+
x21, y21, z21 = randoms.random_cube(npart21, xmin, xmax, ymin, ymax, zmin, zmax)
|
|
146
|
+
# Subregion 22
|
|
147
|
+
xmin, xmax = xorigin + xboxsize, xorigin + xboxsize + buffer_length
|
|
148
|
+
ymin, ymax = yorigin - buffer_length, yorigin + yboxsize
|
|
149
|
+
zmin, zmax = zorigin, zorigin + zboxsize
|
|
150
|
+
npart22 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
|
|
151
|
+
x22, y22, z22 = randoms.random_cube(npart22, xmin, xmax, ymin, ymax, zmin, zmax)
|
|
152
|
+
# Subregion 23
|
|
153
|
+
xmin, xmax = xorigin, xorigin + xboxsize + buffer_length
|
|
154
|
+
ymin, ymax = yorigin + yboxsize, yorigin + yboxsize + buffer_length
|
|
155
|
+
zmin, zmax = zorigin, zorigin + zboxsize
|
|
156
|
+
npart23 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
|
|
157
|
+
x23, y23, z23 = randoms.random_cube(npart23, xmin, xmax, ymin, ymax, zmin, zmax)
|
|
158
|
+
# Subregion 24
|
|
159
|
+
xmin, xmax = xorigin - buffer_length, xorigin
|
|
160
|
+
ymin, ymax = yorigin, yorigin + yboxsize + buffer_length
|
|
161
|
+
zmin, zmax = zorigin, zorigin + zboxsize
|
|
162
|
+
npart24 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
|
|
163
|
+
x24, y24, z24 = randoms.random_cube(npart24, xmin, xmax, ymin, ymax, zmin, zmax)
|
|
164
|
+
x = np.concatenate([x1, x21, x22, x23, x24, x3])
|
|
165
|
+
y = np.concatenate([y1, y21, y22, y23, y24, y3])
|
|
166
|
+
z = np.concatenate([z1, z21, z22, z23, z24, z3])
|
|
167
|
+
return x, y, z
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
from .points import x2points
|
|
2
|
+
from .points import points2x
|
|
3
|
+
from .points import xy2points
|
|
4
|
+
from .points import points2xy
|
|
5
|
+
from .points import xyz2points
|
|
6
|
+
from .points import points2xyz
|
|
7
|
+
from .points import coord2points
|
|
8
|
+
|
|
9
|
+
from .mpi_points import split_limits_by_grid
|
|
10
|
+
from .mpi_points import mpi_find_range_2D
|
|
11
|
+
from .mpi_points import mpi_find_range_3D
|
|
12
|
+
from .mpi_points import mpi_open_2D
|
|
13
|
+
from .mpi_points import mpi_open_3D
|
|
14
|
+
from .mpi_points import check_coords_at_MPI_0
|
|
15
|
+
from .mpi_points import MPI_SortByX
|
|
16
|
+
from .mpi_points import distribute_points_by_x
|