Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/zncl2222/uc_sgsim
An uncondition random field generation tools that are easy to use
https://github.com/zncl2222/uc_sgsim
c geostatistics python simulation stochastic-simulation
Last synced: 9 days ago
JSON representation
An uncondition random field generation tools that are easy to use
- Host: GitHub
- URL: https://github.com/zncl2222/uc_sgsim
- Owner: Zncl2222
- License: mit
- Created: 2021-11-18T08:24:58.000Z (about 3 years ago)
- Default Branch: main
- Last Pushed: 2024-04-05T01:48:25.000Z (9 months ago)
- Last Synced: 2024-04-05T02:46:15.895Z (9 months ago)
- Topics: c, geostatistics, python, simulation, stochastic-simulation
- Language: C
- Homepage:
- Size: 6.7 MB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 10
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
[](https://github.com/Zncl2222/Stochastic_UC_SGSIM/actions/workflows/github-pre-commit.yml)
[](https://github.com/Zncl2222/Stochastic_UC_SGSIM/actions/workflows/cmake.yml)
[](https://github.com/Zncl2222/Stochastic_UC_SGSIM/actions/workflows/sonarcloud.yml)
[](https://github.com/Zncl2222/Stochastic_UC_SGSIM/actions/workflows/codeql.yml)
[](https://codecov.io/gh/Zncl2222/uc_sgsim)
Sonar Cloud Quality
Metric
Python
C
Quality Gate
Reliability Rating
Security Rating
Maintainability Rating
> __Warning__
> This project is still in the pre-dev stage, the API usuage may be subject to change
## UnConditional Sequential Gaussian SIMulation (UCSGSIM)
An unconditional random field generation tools that are easy to use.
## Introduction to UCSGSIM
UnConditional Sequential Gaussian Simulation (UCSGSIM) is a method for generating random fields that is based on the kriging interpolation technique.
Unconditional simulation does not adhere to the patterns observed in the data but instead follows the user's settings, such as mean and variance.
**The core ideas of UCSGSIM are:**
1. Create the grid (no data values exist at this stage).
$$ \Omega\to R $$
2. Select a random point within the model (draw one random value from the x_grid).
$$ X = RandomValue(\Omega), X:\Omega\to R $$
3. Choose the **theoretical covariance model** to use and set the **sill** and **range** properly.
$$ Gaussian = (C_{0} - s)(1 - e^{-h^{2}/r^{2}a})$$
$$ Spherical = (C_{0} - s)(3h/2r - h^3/2r^3)$$
$$ Exponential = (C_{0} - s)(1 - e^{-h/ra})$$
4. If there are more than one data value close to the visited point (based on the **range** of the covariance model), proceed to the next step. Otherwise, draw a random value from a normal distribution as the simulation result for this iteration.
$$ Z_{k}({X_{simulation}}) = RandomNormal(m = 0 ,\sigma^2 = Sill)$$
5. Calculate **weights** from the **data covaraince** and **distance coavariance**
$$ \sum_{j=1}^{n}\omega_{j} = C(X_{data}^{i},X_{data}^{i})C^{-1}(X_i,X_i), i=1...N $$
6. Calculate the **kriging estimate** from the **weights** and **data value**
$$ Z_{k}(X_{estimate}) = \sum_{i=1}^{n} \omega_{i} Z(X_{data}) + (1- \sum_{i=1}^{n} \omega_{i} m_{g}) $$
7. Calculate the **kriging error (kriging variance)** from **weights** and **data covariance**
$$ \sigma_{krige}^{2} = \sum_{i=1}^{n}\omega_{i}C(X_{data}^{i},X_{data}^{i}) $$
8. Draw a random value from the normal distribution and add to the **kriging estimate**.
$$ Z(X_{simulation}) = Z(X_{estimate}) + RandomNormal(m = 0, \sigma^2 = \sigma_{krige}^{2}) $$
9. Repeat 2 ~ 8 until the entire model is simulated.
10. Repeat 1 ~ 9 with different **randomseed number** to produce mutiple realizations.
## Installation
```bash
pip install uc-sgsim
```
## Features
* One dimensional unconditional randomfield generation with sequential gaussian simulation algorithm
* Muti-cores simulation (mutiprocessing)
* Ability to generate random fields in Python using either a C interface via ctype or directly in Python using the NumPy and SciPy libraries.
## Examples
```py
import matplotlib.pyplot as plt
import uc_sgsim as uc
from uc_sgsim.cov_model import Gaussian
if __name__ == '__main__':
x = 151 # Model grid, only 1D case is support now
bw_s = 1 # lag step
bw_l = 35 # lag range
randomseed = 151 # randomseed for simulation
k_range = 17.32 # effective range of covariance model
sill = 1 # sill of covariance model
nR = 10 # numbers of realizations in each CPU cores,
# if nR = 1 n_process = 8
# than you will compute total 8 realizations
# Create Covariance model first
cov_model = Gaussian(bw_l, bw_s, k_range, sill)
# Create simulation and input the Cov model
# You could also set z_min, z_max and max_neighbor for sgsim by key words
# sgsim = uc.UCSgsimDLL(x, nR, cov_model, z_min=-6, z_max=6, max_neigh=10)
# set z_min, z_max and max_neighbor by directly assign
# sgsim.z_min = -6
# sgsim.z_max = 6
# sgsim.max_neigh = 10
# Create simulation with default z_min, z_max and max_neigh params
sgsim_py = uc.UCSgsim(x, nR, cov_model) # run sgsim with python
sgsim_c = uc.UCSgsimDLL(x, nR, cov_model) # run sgsim with c
# Start compute with n CPUs
sgsim_c.compute(n_process=2, randomseed=randomseed)
sgsim_py.compute(n_process=2, randomseed=987654)
sgsim_c.mean_plot('ALL') # Plot mean
sgsim_c.variance_plot() # Plot variance
sgsim_c.cdf_plot(x_location=10) # CDF
sgsim_c.hist_plot(x_location=10) # Hist
sgsim_c.variogram_compute(n_process=2) # Compute variogram before plotting
# Plot variogram and mean variogram for validation
sgsim.variogram_plot()
# Save random_field and variogram
sgsim_c.save_random_field('randomfields.csv', save_single=True)
sgsim_c.save_variogram('variograms.csv', save_single=True)
# show figure
plt.show()
```
If you prefer to utilize pure C to execute this code, you can make modifications to the c_example.c file located in the root directory. Once you've made the necessary changes to c_example.c, you can compile and execute the code using the following commands:
On Linux
```bash
sh cmake_build.sh
```
On Windows
```bat
cmake_build.bat
```
C example file
```c
// c_example.c
# include
# include
# include "./uc_sgsim/c_core/include/sgsim.h"
# include "./uc_sgsim/c_core/include/cov_model.h"
# if defined(__linux__) || defined(__unix__)
# define PAUSE printf("Press Enter key to continue..."); fgetc(stdin);//NOLINT
# elif _WIN32
# define PAUSE system("PAUSE");
# endif
int main() {
// you can also set z_min and z_max at sgsim_t. Default value will depend on
// sill value in cov_model_t
sgsim_t sgsim_example = {
.x_len = 150,
.realization_numbers = 5,
.randomseed = 12345,
.kriging_method = 1,
.if_alloc_memory = 1, // This should be equal to 1 if you want to run by c.
};
// you can also set max_negibor at cov_model_t. Defualt value is 4.
cov_model_t cov_example = {
.bw_l = 35,
.bw_s = 1,
.k_range = 17.32,
.use_cov_cache = 0,
.sill = 1,
.nugget = 0,
};
sgsim_run(&sgsim_example, &cov_example, 0);
sgsim_t_free(&sgsim_example);
PAUSE
return 0;
}
```
## Future plans
* 2D unconditional randomfield generation
* GUI (pyhton)
* More covariance models
* More kriging methods (etc. Oridinary Kriging)
* Performance enhancement
* Providing more comprehensive documentation and user-friendly design improvements.
## Performance
```
Parameters:
model len = 150
number of realizations = 1000
Range scale = 17.32
Variogram model = Gaussian model
---------------------------------------------------------------------------------------
Testing platform:
CPU: AMD Ryzen 9 4900 hs
RAM: DDR4 - 3200 40GB (Dual channel 16GB)
Disk: WD SN530
```