def test_assertions(self): # self.cov_model.dim = 0 # self.assertRaises(ValueError, SRF, self.cov_model, self.mean, self.mode_no) # self.cov_model.dim = 4 # self.assertRaises(ValueError, SRF, self.cov_model, self.mean, self.mode_no) self.cov_model.dim = 3 self.cov_model.anis = (0.25, 0.5) srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) self.assertRaises(ValueError, srf, [self.x_tuple]) self.assertRaises(ValueError, srf, [self.x_grid, self.y_grid]) srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) self.assertRaises(ValueError, srf, [self.x_tuple, self.y_tuple]) self.assertRaises(ValueError, srf, [self.x_grid, self.y_grid, self.z_grid])
def test_calls(self): srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field = srf((self.x_tuple, self.y_tuple), seed=self.seed) field2 = srf.unstructured((self.x_tuple, self.y_tuple), seed=self.seed) self.assertAlmostEqual(field[0], srf.field[0]) self.assertAlmostEqual(field[0], field2[0]) field = srf( (self.x_tuple, self.y_tuple), seed=self.seed, mesh_type="structured", ) field2 = srf.structured((self.x_tuple, self.y_tuple), seed=self.seed) self.assertAlmostEqual(field[0, 0], srf.field[0, 0]) self.assertAlmostEqual(field[0, 0], field2[0, 0])
def test_anisotropy_2d(self): self.cov_model.dim = 2 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field_iso = srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") self.cov_model.anis = 0.5 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field_aniso = srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") self.assertAlmostEqual(field_iso[0, 0], field_aniso[0, 0]) self.assertAlmostEqual(field_iso[0, 4], field_aniso[0, 2]) self.assertAlmostEqual(field_iso[0, 10], field_aniso[0, 5])
def setUp(self): self.test_dir = tempfile.mkdtemp() # structured field with a size 100x100x100 and a grid-size of 1x1x1 x = y = z = range(100) model = Gaussian(dim=3, var=0.6, len_scale=20) self.srf_structured = SRF(model) self.srf_structured((x, y, z), mesh_type="structured") # unstrucutred field seed = MasterRNG(19970221) rng = np.random.RandomState(seed()) x = rng.randint(0, 100, size=10000) y = rng.randint(0, 100, size=10000) model = Exponential( dim=2, var=1, len_scale=[12.0, 3.0], angles=np.pi / 8.0 ) self.srf_unstructured = SRF(model, seed=20170519) self.srf_unstructured([x, y])
def test_shape_1d(self): self.cov_model.dim = 1 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field_str = srf([self.x_grid], seed=self.seed, mesh_type="structured") field_unstr = srf( [self.x_tuple], seed=self.seed, mesh_type="unstructured" ) self.assertEqual(field_str.shape, (len(self.x_grid),)) self.assertEqual(field_unstr.shape, (len(self.x_tuple),))
def test_rotation_struct_2d(self): self.cov_model.dim = 2 self.cov_model.anis = 0.25 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field = srf( (self.x_grid_c, self.y_grid_c), seed=self.seed, mesh_type="structured", ) self.cov_model.angles = -np.pi / 2.0 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field_rot = srf( (self.x_grid_c, self.y_grid_c), seed=self.seed, mesh_type="structured", ) self.assertAlmostEqual(field[0, 0], field_rot[0, -1]) self.assertAlmostEqual(field[1, 2], field_rot[2, 6])
def fs(): for seed in range(256): srf = SRF(model, seed=seed) def f(x, y): # 0 -> -1, 4 -> 1 # 0 -> -.25, 1 -> .25 return srf((x * .5 - 1.0, y * .5 - .25)) print(seed) yield f
def test_rotation_unstruct_2d(self): self.cov_model.dim = 2 x_len = len(self.x_grid_c) y_len = len(self.y_grid_c) x_u, y_u = np.meshgrid(self.x_grid_c, self.y_grid_c) x_u = np.reshape(x_u, x_len * y_len) y_u = np.reshape(y_u, x_len * y_len) self.cov_model.anis = 0.25 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field = srf((x_u, y_u), seed=self.seed, mesh_type="unstructured") field_str = np.reshape(field, (y_len, x_len)) self.cov_model.angles = -np.pi / 2.0 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field_rot = srf((x_u, y_u), seed=self.seed, mesh_type="unstructured") field_rot_str = np.reshape(field_rot, (y_len, x_len)) self.assertAlmostEqual(field_str[0, 0], field_rot_str[-1, 0]) self.assertAlmostEqual(field_str[1, 2], field_rot_str[-3, 1])
def test_srf(self): D0 = np.array((0.0, 0.0)) cov_model = Gaussian(dim=2, var=0.01, len_scale=10.0) srf = SRF(cov_model, generator="VectorField", seed=5747387) sim = Simulation(2, srf, D0, self.T, self.dt) sim.initial_condition(self.pos_2d, self.distribution_2d) mean_drift = srf.generator.mean_u * (self.T / self.dt) sim() self.assertAlmostEqual(sim.pos[0, 0], mean_drift, places=0) self.assertAlmostEqual(sim.pos[1, 1], 0.0, places=0) self.assertAlmostEqual(sim.pos[0, -1], mean_drift, places=0)
def test_anisotropy_3d(self): self.cov_model.dim = 3 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field_iso = srf( (self.x_grid, self.y_grid, self.z_grid), seed=self.seed, mesh_type="structured", ) self.cov_model.anis = (0.5, 4.0) srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field_aniso = srf( (self.x_grid, self.y_grid, self.z_grid), seed=self.seed, mesh_type="structured", ) self.assertAlmostEqual(field_iso[0, 0, 0], field_aniso[0, 0, 0]) self.assertAlmostEqual(field_iso[0, 4, 0], field_aniso[0, 2, 0]) self.assertAlmostEqual(field_iso[0, 10, 0], field_aniso[0, 5, 0]) self.assertAlmostEqual(field_iso[0, 0, 0], field_aniso[0, 0, 0]) self.assertAlmostEqual(field_iso[0, 0, 1], field_aniso[0, 0, 4]) self.assertAlmostEqual(field_iso[0, 0, 3], field_aniso[0, 0, 12])
def test_shape_2d(self): self.cov_model.dim = 2 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) field_str = srf( (self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured" ) field_unstr = srf( (self.x_tuple, self.y_tuple), seed=self.seed, mesh_type="unstructured", ) self.assertEqual(field_str.shape, (len(self.x_grid), len(self.y_grid))) self.assertEqual(field_unstr.shape, (len(self.x_tuple),))
def test_extdrift(self): ext_drift = [] cond_drift = [] for i, grid in enumerate(self.grids): dim = i + 1 model = Exponential( dim=dim, var=2, len_scale=10, anis=[0.9, 0.8], angles=[2, 1, 0.5], ) srf = SRF(model) field = srf(grid) ext_drift.append(field) field = field.reshape(self.grid_shape[:dim]) cond_drift.append(field[self.data_idx[:dim]]) for Model in self.cov_models: for dim in self.dims: model = Model( dim=dim, var=2, len_scale=10, anis=[0.5, 0.2], angles=[0.4, 0.2, 0.1], ) extdrift = krige.ExtDrift( model, self.cond_pos[:dim], self.cond_val, cond_drift[dim - 1], ) field_1, __ = extdrift.unstructured( self.grids[dim - 1], ext_drift=ext_drift[dim - 1] ) field_1 = field_1.reshape(self.grid_shape[:dim]) field_2, __ = extdrift.structured( self.pos[:dim], ext_drift=ext_drift[dim - 1] ) # extdrift.plot() self.assertAlmostEqual( np.max(np.abs(field_1 - field_2)), 0.0, places=2 ) for i, val in enumerate(self.cond_val): self.assertAlmostEqual( field_2[self.data_idx[:dim]][i], val, places=2 )
def test_transform(self): self.cov_model.dim = 2 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.normal_force_moments(srf) # force ergodicity of the given field self.assertAlmostEqual(srf.field.mean(), srf.mean) self.assertAlmostEqual(srf.field.var(), srf.model.var) tf.zinnharvey(srf) # make high values mostly connected tf.normal_force_moments(srf) # force ergodicity of the given field tf.normal_to_lognormal(srf) # log-normal srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.normal_to_arcsin(srf) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.normal_to_uquad(srf) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.normal_to_uniform(srf)
def random_field_generator(function_space, minval=0, maxval=1, var=1e-2, len_scale=1, len_low=0, seed=20170519): mesh = function_space.mesh() dim = mesh.geometric_dimension() model = TPLStable(dim=dim, var=var, len_scale=len_scale, len_low=len_low) # model = Exponential(dim=dim, var=var, len_scale=len_scale) # FIXME: Diego, the exponential model, instead of TPLStable, resulted in some chemical equilibrium errors (returning to previous at the moment) srf = SRF(model, seed=seed) ndofs = function_space.dim() size = int(ndofs**(1 / dim)) xyz = [range(size) for _ in range(dim)] data = srf(xyz, mesh_type="structured") # The min and max values of x,y,z in the mesh xyz_min = [mesh.coordinates.dat.data[:, i].min() for i in range(dim)] xyz_max = [mesh.coordinates.dat.data[:, i].max() for i in range(dim)] xyz = [np.linspace(xyz_min[i], xyz_max[i], size) for i in range(dim)] datainterp = RegularGridInterpolator(xyz, data) # Now make the VectorFunctionSpace corresponding to V. W = fire.VectorFunctionSpace(mesh, function_space.ufl_element()) # Next, interpolate the coordinates onto the nodes of W. X = fire.interpolate(mesh.coordinates, W) # Make an output function. k = fire.Function(function_space, name="Permeability") # Use the external data function to interpolate the values of f. kdata = np.array([datainterp(xyz) for xyz in X.dat.data_ro]) # k.dat.data[:] = mydata(X.dat.data_ro) k.dat.data[:] = rescale_field(kdata, minval, maxval)[:, 0] return k
def test_incomprrandmeth(self): self.cov_model = Gaussian(dim=2, var=0.5, len_scale=1.0, mode_no=100) srf = SRF( self.cov_model, mean=self.mean, mode_no=self.mode_no, generator="IncomprRandMeth", mean_velocity=0.5, ) field = srf((self.x_tuple, self.y_tuple), seed=476356) self.assertAlmostEqual(field[0, 0], 1.23693272) self.assertAlmostEqual(field[0, 1], 0.89242284) field = srf( (self.x_grid, self.y_grid), seed=4734654, mesh_type="structured" ) self.assertAlmostEqual(field[0, 0, 0], 1.07812013) self.assertAlmostEqual(field[0, 1, 0], 1.06180674)
def test_meshio(self): points = np.array([ [0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0], ]) cells = [("tetra", np.array([[0, 1, 2, 3]]))] mesh = meshio.Mesh(points, cells) model = Gaussian(dim=3, len_scale=0.1) srf = SRF(model) srf.mesh(mesh, points="points") self.assertEqual(len(srf.field), 4) srf.mesh(mesh, points="centroids") self.assertEqual(len(srf.field), 1)
def test_transform(self): self.cov_model.dim = 2 srf = SRF(self.cov_model, mean=self.mean, mode_no=self.mode_no) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.normal_force_moments(srf) # force ergodicity of the given field self.assertAlmostEqual(srf.field.mean(), srf.mean) self.assertAlmostEqual(srf.field.var(), srf.model.var) tf.zinnharvey(srf) # make high values mostly connected tf.normal_force_moments(srf) # force ergodicity of the given field tf.normal_to_lognormal(srf) # log-normal srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.normal_to_arcsin(srf) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.normal_to_uquad(srf) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.normal_to_uniform(srf) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.binary(srf) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") tf.boxcox(srf) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") values = np.linspace(np.min(srf.field), np.max(srf.field), 3) tf.discrete(srf, values) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") values = [-1, 0, 1] thresholds = [-0.9, 0.1] tf.discrete(srf, values, thresholds) np.testing.assert_array_equal(np.unique(srf.field), [-1, 0, 1]) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") values = [-1, 0, 1] tf.discrete(srf, values, thresholds="arithmetic") np.testing.assert_array_equal(np.unique(srf.field), [-1.0, 0.0, 1.0]) srf((self.x_grid, self.y_grid), seed=self.seed, mesh_type="structured") values = [-1, 0, 0.5, 1] tf.discrete(srf, values, thresholds="equal") np.testing.assert_array_equal(np.unique(srf.field), values)
def test_simple(self): for Model in self.cov_models: for dim in self.dims: model = Model( dim=dim, var=0.5, len_scale=2, anis=[0.1, 1], angles=[0.5, 0, 0], ) srf = SRF(model, self.mean, seed=19970221) srf.set_condition(self.cond_pos[:dim], self.cond_val, "simple") field_1 = srf.unstructured(self.pos[:dim]) field_2 = srf.structured(self.pos[:dim]) for i, val in enumerate(self.cond_val): self.assertAlmostEqual(val, field_1[i], places=2) self.assertAlmostEqual(val, field_2[dim * (i, )], places=2)
class TestExport(unittest.TestCase): def setUp(self): self.test_dir = tempfile.mkdtemp() # structured field with a size 100x100x100 and a grid-size of 1x1x1 x = y = z = range(50) model = Gaussian(dim=3, var=0.6, len_scale=20) self.srf_structured = SRF(model) self.srf_structured((x, y, z), mesh_type="structured") # unstrucutred field seed = MasterRNG(19970221) rng = np.random.RandomState(seed()) x = rng.randint(0, 100, size=1000) y = rng.randint(0, 100, size=1000) model = Exponential(dim=2, var=1, len_scale=[12.0, 3.0], angles=np.pi / 8.0) self.srf_unstructured = SRF(model, seed=20170519) self.srf_unstructured([x, y]) def tearDown(self): # Remove the test data directory after the test shutil.rmtree(self.test_dir) @unittest.skipIf(not HAS_PYVISTA, "PyVista is not installed.") def test_pyvista(self): mesh = self.srf_structured.to_pyvista() self.assertIsInstance(mesh, pv.RectilinearGrid) mesh = self.srf_unstructured.to_pyvista() self.assertIsInstance(mesh, pv.UnstructuredGrid) def test_pyevtk_export(self): # Structured sfilename = os.path.join(self.test_dir, "structured") self.srf_structured.vtk_export(sfilename) self.assertTrue(os.path.isfile(sfilename + ".vtr")) # Unstructured ufilename = os.path.join(self.test_dir, "unstructured") self.srf_unstructured.vtk_export(ufilename) self.assertTrue(os.path.isfile(ufilename + ".vtu"))
import numpy as np from gstools import Gaussian, SRF import matplotlib.pyplot as plt # condtions cond_pos = [0.3, 1.9, 1.1, 3.3, 4.7] cond_val = [0.47, 0.56, 0.74, 1.47, 1.74] gridx = np.linspace(0.0, 15.0, 151) # spatial random field class model = Gaussian(dim=1, var=0.5, len_scale=2) srf = SRF(model) srf.set_condition(cond_pos, cond_val, "ordinary") fields = [] for i in range(100): if i % 10 == 0: print(i) fields.append(srf(gridx, seed=i)) label = "Conditioned ensemble" if i == 0 else None plt.plot(gridx, fields[i], color="k", alpha=0.1, label=label) plt.plot(gridx, np.full_like(gridx, srf.mean), label="estimated mean") plt.plot(gridx, np.mean(fields, axis=0), linestyle=":", label="Ensemble mean") plt.plot(gridx, srf.krige_field, linestyle="dashed", label="kriged field") plt.scatter(cond_pos, cond_val, color="k", zorder=10, label="Conditions") plt.legend() plt.show()
""" Detrended Ordinary Kriging -------------------------- """ import numpy as np from gstools import SRF, Gaussian, krige def trend(x): """Example for a simple linear trend.""" return x * 0.1 + 1 # synthetic condtions with trend/drift drift_model = Gaussian(dim=1, var=0.1, len_scale=2) drift = SRF(drift_model, seed=101) cond_pos = np.linspace(0.1, 8, 10) cond_val = drift(cond_pos) + trend(cond_pos) # resulting grid gridx = np.linspace(0.0, 15.0, 151) drift_field = drift(gridx) + trend(gridx) # kriging model = Gaussian(dim=1, var=0.1, len_scale=2) krig_trend = krige.Ordinary(model, cond_pos, cond_val, trend) krig_trend(gridx) ax = krig_trend.plot() ax.scatter(cond_pos, cond_val, color="k", zorder=10, label="Conditions") ax.plot(gridx, trend(gridx), ":", label="linear trend") ax.plot(gridx, drift_field, "--", label="original field") ax.legend()
from ogs5py import OGS, by_id, show_vtk, specialrange #from matplotlib import pyplot as plt from gstools import SRF, Gaussian # discretization and parameters rad = specialrange(0, 1000, 100, typ="cub") obs = rad[21] angles = 32 storage = 1e-3 transmissivity = 1e-4 rate = -1e-3 # covariance model for conductivity field cov_model = Gaussian(dim=2, var=2, len_scale=100, anis=[1]) srf = SRF(model=cov_model, mean=-9, seed=1000) # model setup model = OGS(task_root="pump_2d_steady", task_id="model", output_dir="out") model.pcs.add_block( PCS_TYPE="GROUNDWATER_FLOW", NUM_TYPE="NEW", TIM_TYPE="STEADY") # generate a radial mesh and geometry ("boundary" polyline) model.msh.generate("radial", dim=2, rad=rad, angles=angles) model.gli.generate("radial", dim=2, rad_out=rad[-1], angles=angles) model.gli.add_points([0.0, 0.0, 0.0], "pwell") # generate a 2D conductivity field cond = np.exp(srf.mesh(model.msh)) model.mpd.add(name="conductivity") model.mpd.add_block( # edit recent mpd file
from gstools import SRF, Gaussian from gstools import transform as tf # structured field with a size of 100x100 and a grid-size of 1x1 x = y = range(100) model = Gaussian(dim=2, var=1, len_scale=10) srf = SRF(model, seed=20170519) srf.structured([x, y]) tf.zinnharvey(srf, conn="high") srf.plot()
import numpy as np import matplotlib.pyplot as plt from gstools import SRF, TPLStable x = y = np.linspace(0, 100, 100) model = TPLStable( dim=2, # spatial dimension var= 1, # variance (C is calculated internally, so that the variance is actually 1) len_low=0, # lower truncation of the power law len_scale=10, # length scale (a.k.a. range), len_up = len_low + len_scale nugget=0.1, # nugget anis=0.5, # anisotropy between main direction and transversal ones angles=np.pi / 4, # rotation angles alpha=1.5, # shape parameter from the stable model hurst=0.7, # hurst coefficient from the power law ) srf = SRF(model, mean=1, mode_no=1000, seed=19970221, verbose=True) field = srf((x, y), mesh_type='structured', force_moments=True) # show the field in xy coordinates plt.imshow(field.T, origin="lower") plt.show()
# round nodes ogs.msh.NODES[:, 1] = np.around(ogs.msh.NODES[:, 1], 0) ogs.msh.NODES[:, 0] = np.around(ogs.msh.NODES[:, 0], 4) ogs.msh.NODES[:, 2] = np.around(ogs.msh.NODES[:, 2], 4) # ------------------------ heterogeneous field -------------------------------- # # get the centroids of the mesh-elements to evaluate the field cent = ogs.msh.centroids_flat # split up in x and z coordinates x = cent[:, 0] z = cent[:, 2] # generate the random field cov_model = Gaussian(dim=dim, var=var, len_scale=len_scale) srf = SRF(cov_model, mean=mean, seed=seed) # use unstructured for a 2D vertical mesh field = srf((x, z), mesh_type='unstructured', force_moments=True) #, mode_no=100) # conductivities as log-normal distributed from the field data cond = np.exp(field) from scipy.stats.mstats import gmean, hmean arimean = np.mean(cond) harmean = hmean(cond) geomean = gmean(cond) print("The geometric mean is: " + str(geomean)) #plt.hist(field) # show the heterogeneous field plt.figure(figsize=(20, thickness / length * 20)) cond_log = np.log10(cond)
label='exp. variogram in y-dir') pt.legend() pt.show() print('semivariogram model (isotropic):\n', fit_model) print('semivariogram model (in x-dir.):\n', fit_model_x) print('semivariogram model (in y-dir.):\n', fit_model_y) ############################################################################### # creating a SRF from the Herten parameters ################################### ############################################################################### from gstools import SRF srf = SRF(fit_model, seed=19770928) print('Calculating SRF') new_herten = srf((x_s, y_s), mesh_type='structured') pt.imshow(new_herten.T, origin='lower') pt.show() ############################################################################### # cleanup ##################################################################### ############################################################################### # comment all in case you want to keep the data for playing around with it os.remove('data.zip') os.remove('scripts.zip') rmtree('Herten-analog') rmtree('tools')
import numpy as np from gstools import SRF, Exponential, Stable, vario_estimate_unstructured # generate a synthetic field with an exponential model x = np.random.RandomState(19970221).rand(1000) * 100.0 y = np.random.RandomState(20011012).rand(1000) * 100.0 model = Exponential(dim=2, var=2, len_scale=8) srf = SRF(model, mean=0, seed=19970221) field = srf((x, y)) # estimate the variogram of the field with 40 bins bins = np.arange(40) bin_center, gamma = vario_estimate_unstructured((x, y), field, bins) # fit the variogram with a stable model. (no nugget fitted) fit_model = Stable(dim=2) fit_model.fit_variogram(bin_center, gamma, nugget=False) # output ax = fit_model.plot(x_max=40) ax.plot(bin_center, gamma) print(fit_model)
import numpy as np import matplotlib.pyplot as pt from gstools import SRF, Exponential from gstools.random import MasterRNG from gstools import vtk_export # creating our own unstructured grid seed = MasterRNG(19970221) rng = np.random.RandomState(seed()) x = rng.randint(0, 100, size=10000) y = rng.randint(0, 100, size=10000) model = Exponential(dim=2, var=1, len_scale=[12., 3.], angles=np.pi / 8.) srf = SRF(model, seed=20170519) field = srf((x, y)) vtk_export('field', (x, y), field) pt.tricontourf(x, y, field.T) pt.axes().set_aspect('equal') pt.show()
import numpy as np import matplotlib.pyplot as pt from gstools import SRF, Gaussian from gstools.random import MasterRNG x = y = np.arange(100) model = Gaussian(dim=2, var=1, len_scale=10) srf = SRF(model) ens_no = 4 field = [] seed = MasterRNG(20170519) for i in range(ens_no): field.append(srf((x, y), seed=seed(), mesh_type="structured")) fig, ax = pt.subplots(2, 2, sharex=True, sharey=True) ax = ax.flatten() for i in range(ens_no): ax[i].imshow(field[i].T, origin="lower") pt.show()
import numpy as np import matplotlib.pyplot as pt from gstools import SRF, Exponential from gstools.random import MasterRNG # creating our own unstructured grid seed = MasterRNG(19970221) rng = np.random.RandomState(seed()) x = rng.randint(0, 100, size=10000) y = rng.randint(0, 100, size=10000) model = Exponential(dim=2, var=1, len_scale=[12.0, 3.0], angles=np.pi / 8.0) srf = SRF(model, seed=20170519) field = srf((x, y)) srf.vtk_export("field") pt.tricontourf(x, y, field.T) pt.axes().set_aspect("equal") pt.show()