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.
Files changed (91) hide show
  1. docs/source/conf.py +56 -0
  2. fiesta/__init__.py +12 -0
  3. fiesta/boundary/__init__.py +18 -0
  4. fiesta/boundary/mpi_periodic.py +216 -0
  5. fiesta/boundary/mpi_randoms.py +215 -0
  6. fiesta/boundary/periodic.py +322 -0
  7. fiesta/boundary/randoms.py +167 -0
  8. fiesta/coords/__init__.py +16 -0
  9. fiesta/coords/mpi_points.py +639 -0
  10. fiesta/coords/points.py +153 -0
  11. fiesta/dtfe/__init__.py +19 -0
  12. fiesta/dtfe/dtfe2d.py +562 -0
  13. fiesta/dtfe/dtfe3d.py +759 -0
  14. fiesta/dtfe/dtfe4grid.py +1709 -0
  15. fiesta/dtfe/mpi_dtfe4grid.py +1146 -0
  16. fiesta/gridsph/__init__.py +9 -0
  17. fiesta/gridsph/gridsph.py +221 -0
  18. fiesta/gridsph/integral_image.py +46 -0
  19. fiesta/gridsph/mpi_gridsph.py +412 -0
  20. fiesta/interp/__init__.py +6 -0
  21. fiesta/interp/bilinear.py +273 -0
  22. fiesta/interp/trilinear.py +339 -0
  23. fiesta/kdtree/__init__.py +3 -0
  24. fiesta/kdtree/kdtree1d.py +87 -0
  25. fiesta/kdtree/kdtree2d.py +97 -0
  26. fiesta/kdtree/kdtree3d.py +112 -0
  27. fiesta/maths/__init__.py +10 -0
  28. fiesta/maths/diff.py +213 -0
  29. fiesta/maths/matrix.py +122 -0
  30. fiesta/maths/mpi_diff.py +116 -0
  31. fiesta/p2g/__init__.py +11 -0
  32. fiesta/p2g/deconvol.py +255 -0
  33. fiesta/p2g/mpi_part2grid.py +271 -0
  34. fiesta/p2g/part2grid.py +214 -0
  35. fiesta/randoms/__init__.py +3 -0
  36. fiesta/randoms/cartesian.py +102 -0
  37. fiesta/sph/__init__.py +12 -0
  38. fiesta/sph/kernels.py +87 -0
  39. fiesta/sph/mpi_sph4grid.py +312 -0
  40. fiesta/sph/sph1d.py +167 -0
  41. fiesta/sph/sph2d.py +167 -0
  42. fiesta/sph/sph3d.py +174 -0
  43. fiesta/sph/sph4grid.py +269 -0
  44. fiesta/src/__init__.py +69 -0
  45. fiesta/src/bilinear.py +307 -0
  46. fiesta/src/delaunay2d.py +190 -0
  47. fiesta/src/delaunay3d.py +244 -0
  48. fiesta/src/differentiate.py +248 -0
  49. fiesta/src/grid.py +52 -0
  50. fiesta/src/gridsph.py +831 -0
  51. fiesta/src/matrix.py +147 -0
  52. fiesta/src/part2grid_2d.py +291 -0
  53. fiesta/src/part2grid_3d.py +346 -0
  54. fiesta/src/part2grid_pix.py +306 -0
  55. fiesta/src/part2grid_wei.py +105 -0
  56. fiesta/src/polygon.py +72 -0
  57. fiesta/src/polyhedron.py +46 -0
  58. fiesta/src/trilinear.py +429 -0
  59. fiesta/src/voronoi2d.py +96 -0
  60. fiesta/src/voronoi3d.py +111 -0
  61. fiesta/utils/__init__.py +7 -0
  62. fiesta/utils/complex.py +37 -0
  63. fiesta/utils/lists.py +15 -0
  64. fiesta/utils/vectors.py +41 -0
  65. fiesta_pkg-1.0.2.dist-info/METADATA +146 -0
  66. fiesta_pkg-1.0.2.dist-info/RECORD +91 -0
  67. fiesta_pkg-1.0.2.dist-info/WHEEL +5 -0
  68. fiesta_pkg-1.0.2.dist-info/top_level.txt +3 -0
  69. tests/mpi_tests/test_mpi_boundary.py +194 -0
  70. tests/mpi_tests/test_mpi_coords.py +373 -0
  71. tests/mpi_tests/test_mpi_diff.py +113 -0
  72. tests/mpi_tests/test_mpi_dtfe4grid.py +245 -0
  73. tests/mpi_tests/test_mpi_gridsph.py +377 -0
  74. tests/mpi_tests/test_mpi_interp.py +340 -0
  75. tests/mpi_tests/test_mpi_part2grid.py +227 -0
  76. tests/mpi_tests/test_mpi_randoms.py +108 -0
  77. tests/mpi_tests/test_mpi_routines.py +215 -0
  78. tests/mpi_tests/test_mpi_sph4grid.py +353 -0
  79. tests/normal_tests/test_boundary.py +126 -0
  80. tests/normal_tests/test_coords.py +91 -0
  81. tests/normal_tests/test_dtfe.py +747 -0
  82. tests/normal_tests/test_gridsph.py +456 -0
  83. tests/normal_tests/test_interp.py +106 -0
  84. tests/normal_tests/test_kdtree.py +79 -0
  85. tests/normal_tests/test_maths.py +52 -0
  86. tests/normal_tests/test_mpi_dtfe4grid.py +339 -0
  87. tests/normal_tests/test_p2g.py +178 -0
  88. tests/normal_tests/test_randoms.py +26 -0
  89. tests/normal_tests/test_sph.py +128 -0
  90. tests/normal_tests/test_sph4grid.py +331 -0
  91. 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