Upload 224 files

.gitattributes

@@ -33,3 +33,23 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/06_ensemble.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/07_00_std.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/07_03_zinnharvey.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/07_04_arcsin.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/09_cond_ens.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/3d_gau_field.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/3d_pgs.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/cond_ens.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/gau_field.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/GS_3d_vector_field.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/GS_pyvista_cut.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/paraview.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/pyvista_export.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/srf_tut_exp_ani_rot.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/srf_tut_gau_field.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/srf_tut_unstr.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/vario_tut_herten.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/vario_tut_new_herten.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/vec_srf_tut_exp.png filter=lfs diff=lfs merge=lfs -text
+GSTools/source/docs/source/pics/vec_srf_tut_gau.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "GSTools/mcp_output/start_mcp.py"]

GSTools/mcp_output/README_MCP.md

@@ -0,0 +1,65 @@
+# GSTools: Model Context Protocol (MCP) Service
+
+## Project Introduction
+
+GSTools is a comprehensive geostatistical Python library designed for spatial data analysis and random field modeling. It provides tools for generating spatial random fields, performing kriging interpolation, estimating variograms, and conducting advanced geostatistical analyses. The library supports multiple computational backends and offers extensive export capabilities for integration with visualization tools like ParaView and PyVista.
+
+## Installation Method
+
+To install GSTools, ensure you have Python installed on your system. GSTools requires the following dependencies:
+
+- Required: `numpy`, `scipy`, `matplotlib`
+- Optional: `pyvista`, `cartopy`
+
+You can install GSTools using pip:
+
+```
+pip install gstools
+```
+
+## Quick Start
+
+Here's a quick example to get you started with GSTools:
+
+1. **Model Definition**: Create a covariance model using classes like `Gaussian`, `Exponential`, or `Matern`.
+2. **Field Generation**: Initialize the `SRF` class with the model and call it with spatial coordinates.
+3. **Kriging Interpolation**: Use the `Krige` class for interpolation with known data points.
+4. **Export**: Export results using `vtk_export` or `to_pyvista` methods for visualization.
+
+Example usage:
+
+```
+from gstools import SRF, Gaussian
+
+# Define a Gaussian covariance model
+model = Gaussian(dim=2, var=1, len_scale=10)
+
+# Generate a spatial random field
+srf = SRF(model)
+field = srf((100, 100))
+
+# Export the field for visualization
+srf.to_pyvista()
+```
+
+## Available Tools and Endpoints List
+
+- **CovModel**: Base classes and functions for covariance models, including fitting and correlation calculations.
+- **SRF**: Handles spatial random field generation.
+- **CondSRF**: Manages conditioned field generation.
+- **Krige**: Implements kriging interpolation methods for spatial data.
+- **vario_estimate**: Provides tools for empirical variogram estimation and analysis.
+- **vtk_export**: Facilitates export of data for visualization in tools like ParaView and PyVista.
+
+## Common Issues and Notes
+
+- **Dependencies**: Ensure all required dependencies are installed. Optional dependencies enhance functionality but are not mandatory.
+- **Environment**: GSTools is compatible with Python environments that support scientific computing libraries.
+- **Performance**: The library supports backend selection for performance optimization. Use the `config` module to switch between backends like GSTools-Cython and GSTools-Core.
+
+## Reference Links or Documentation
+
+- [GSTools GitHub Repository](https://github.com/GeoStat-Framework/GSTools)
+- [GSTools Documentation](https://geostat-framework.readthedocs.io/projects/gstools/en/latest/)
+
+For more detailed information on usage and advanced features, please refer to the official documentation and GitHub repository.

GSTools/mcp_output/analysis.json

@@ -0,0 +1,541 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/GeoStat-Framework/GSTools",
+    "summary": "Imported via zip fallback, file count: 139",
+    "file_tree": {
+      ".git_archival.txt": {
+        "size": 144
+      },
+      ".github/workflows/main.yml": {
+        "size": 3938
+      },
+      ".readthedocs.yml": {
+        "size": 220
+      },
+      ".zenodo.json": {
+        "size": 1450
+      },
+      "AUTHORS.md": {
+        "size": 663
+      },
+      "CHANGELOG.md": {
+        "size": 34781
+      },
+      "CONTRIBUTING.md": {
+        "size": 1444
+      },
+      "README.md": {
+        "size": 17315
+      },
+      "docs/source/conf.py": {
+        "size": 11196
+      },
+      "examples/00_misc/00_tpl_stable.py": {
+        "size": 1974
+      },
+      "examples/00_misc/01_export.py": {
+        "size": 669
+      },
+      "examples/00_misc/02_check_rand_meth_sampling.py": {
+        "size": 2130
+      },
+      "examples/00_misc/04_herten.py": {
+        "size": 11160
+      },
+      "examples/00_misc/05_standalone_field.py": {
+        "size": 839
+      },
+      "examples/00_misc/grid_dim_origin_spacing.txt": {
+        "size": 150
+      },
+      "examples/01_random_field/00_gaussian.py": {
+        "size": 1373
+      },
+      "examples/01_random_field/01_srf_ensemble.py": {
+        "size": 1662
+      },
+      "examples/01_random_field/02_fancier.py": {
+        "size": 949
+      },
+      "examples/01_random_field/03_unstr_srf_export.py": {
+        "size": 1118
+      },
+      "examples/01_random_field/04_srf_merge.py": {
+        "size": 1648
+      },
+      "examples/01_random_field/05_mesh_ensemble.py": {
+        "size": 3278
+      },
+      "examples/01_random_field/06_pyvista_support.py": {
+        "size": 2171
+      },
+      "examples/01_random_field/07_higher_dimensions.py": {
+        "size": 2498
+      },
+      "examples/01_random_field/08_fourier.py": {
+        "size": 1528
+      },
+      "examples/01_random_field/09_fourier_trans.py": {
+        "size": 1814
+      },
+      "examples/02_cov_model/00_intro.py": {
+        "size": 2336
+      },
+      "examples/02_cov_model/01_basic_methods.py": {
+        "size": 1219
+      },
+      "examples/02_cov_model/02_aniso_rotation.py": {
+        "size": 1992
+      },
+      "examples/02_cov_model/03_spectral_methods.py": {
+        "size": 1596
+      },
+      "examples/02_cov_model/04_different_scales.py": {
+        "size": 2152
+      },
+      "examples/02_cov_model/05_additional_para.py": {
+        "size": 1436
+      },
+      "examples/02_cov_model/06_fitting_para_ranges.py": {
+        "size": 2277
+      },
+      "examples/03_variogram/00_fit_variogram.py": {
+        "size": 1067
+      },
+      "examples/03_variogram/01_find_best_model.py": {
+        "size": 2042
+      },
+      "examples/03_variogram/02_multi_vario.py": {
+        "size": 1558
+      },
+      "examples/03_variogram/03_directional_2d.py": {
+        "size": 2170
+      },
+      "examples/03_variogram/04_directional_3d.py": {
+        "size": 3300
+      },
+      "examples/03_variogram/05_auto_fit_variogram.py": {
+        "size": 1223
+      },
+      "examples/03_variogram/06_auto_bin_latlon.py": {
+        "size": 3015
+      },
+      "examples/04_vector_field/00_2d_vector_field.py": {
+        "size": 1582
+      },
+      "examples/04_vector_field/01_3d_vector_field.py": {
+        "size": 2051
+      },
+      "examples/05_kriging/00_simple_kriging.py": {
+        "size": 1396
+      },
+      "examples/05_kriging/01_ordinary_kriging.py": {
+        "size": 1506
+      },
+      "examples/05_kriging/02_pykrige_interface.py": {
+        "size": 2124
+      },
+      "examples/05_kriging/03_compare_kriging.py": {
+        "size": 1048
+      },
+      "examples/05_kriging/04_extdrift_kriging.py": {
+        "size": 696
+      },
+      "examples/05_kriging/05_universal_kriging.py": {
+        "size": 1342
+      },
+      "examples/05_kriging/06_detrended_kriging.py": {
+        "size": 852
+      },
+      "examples/05_kriging/07_detrended_ordinary_kriging.py": {
+        "size": 875
+      },
+      "examples/05_kriging/08_measurement_errors.py": {
+        "size": 1634
+      },
+      "examples/05_kriging/09_pseudo_inverse.py": {
+        "size": 1208
+      },
+      "examples/06_conditioned_fields/00_condition_ensemble.py": {
+        "size": 2297
+      },
+      "examples/06_conditioned_fields/01_2D_condition_ensemble.py": {
+        "size": 2570
+      },
+      "examples/07_transformations/00_log_normal.py": {
+        "size": 430
+      },
+      "examples/07_transformations/01_binary.py": {
+        "size": 491
+      },
+      "examples/07_transformations/02_discrete.py": {
+        "size": 1427
+      },
+      "examples/07_transformations/03_zinn_harvey.py": {
+        "size": 705
+      },
+      "examples/07_transformations/04_bimodal.py": {
+        "size": 696
+      },
+      "examples/07_transformations/05_combinations.py": {
+        "size": 1530
+      },
+      "examples/08_geo_coordinates/00_field_generation.py": {
+        "size": 2184
+      },
+      "examples/08_geo_coordinates/01_dwd_krige.py": {
+        "size": 6796
+      },
+      "examples/08_geo_coordinates/de_borders.txt": {
+        "size": 24600
+      },
+      "examples/08_geo_coordinates/temp_obs.txt": {
+        "size": 49321
+      },
+      "examples/09_spatio_temporal/01_precip_1d.py": {
+        "size": 4651
+      },
+      "examples/09_spatio_temporal/02_precip_2d.py": {
+        "size": 2083
+      },
+      "examples/09_spatio_temporal/03_geographic_coordinates.py": {
+        "size": 1111
+      },
+      "examples/10_normalizer/00_lognormal_kriging.py": {
+        "size": 1984
+      },
+      "examples/10_normalizer/01_auto_fit.py": {
+        "size": 3689
+      },
+      "examples/10_normalizer/02_compare.py": {
+        "size": 2204
+      },
+      "examples/11_plurigaussian/00_simple.py": {
+        "size": 2804
+      },
+      "examples/11_plurigaussian/01_pgs.py": {
+        "size": 3698
+      },
+      "examples/11_plurigaussian/02_spatial_relations.py": {
+        "size": 3906
+      },
+      "examples/11_plurigaussian/03_correlations.py": {
+        "size": 2325
+      },
+      "examples/11_plurigaussian/04_3d_pgs.py": {
+        "size": 2657
+      },
+      "examples/11_plurigaussian/05_conditioned.py": {
+        "size": 5355
+      },
+      "examples/11_plurigaussian/06_periodic.py": {
+        "size": 2874
+      },
+      "examples/12_sum_model/00_simple_sum_model.py": {
+        "size": 2311
+      },
+      "examples/12_sum_model/01_fitting_sum_model.py": {
+        "size": 3287
+      },
+      "pyproject.toml": {
+        "size": 3193
+      },
+      "src/gstools/__init__.py": {
+        "size": 4253
+      },
+      "src/gstools/config.py": {
+        "size": 316
+      },
+      "src/gstools/covmodel/__init__.py": {
+        "size": 1515
+      },
+      "src/gstools/covmodel/base.py": {
+        "size": 62663
+      },
+      "src/gstools/covmodel/fit.py": {
+        "size": 29723
+      },
+      "src/gstools/covmodel/models.py": {
+        "size": 30714
+      },
+      "src/gstools/covmodel/plot.py": {
+        "size": 9701
+      },
+      "src/gstools/covmodel/sum_tools.py": {
+        "size": 8304
+      },
+      "src/gstools/covmodel/tools.py": {
+        "size": 19134
+      },
+      "src/gstools/covmodel/tpl_models.py": {
+        "size": 18601
+      },
+      "src/gstools/field/__init__.py": {
+        "size": 643
+      },
+      "src/gstools/field/base.py": {
+        "size": 23802
+      },
+      "src/gstools/field/cond_srf.py": {
+        "size": 10315
+      },
+      "src/gstools/field/generator.py": {
+        "size": 29699
+      },
+      "src/gstools/field/pgs.py": {
+        "size": 5758
+      },
+      "src/gstools/field/plot.py": {
+        "size": 13182
+      },
+      "src/gstools/field/srf.py": {
+        "size": 7999
+      },
+      "src/gstools/field/tools.py": {
+        "size": 9217
+      },
+      "src/gstools/field/upscaling.py": {
+        "size": 2850
+      },
+      "src/gstools/krige/__init__.py": {
+        "size": 441
+      },
+      "src/gstools/krige/base.py": {
+        "size": 30424
+      },
+      "src/gstools/krige/methods.py": {
+        "size": 21018
+      },
+      "src/gstools/krige/tools.py": {
+        "size": 2554
+      },
+      "src/gstools/normalizer/__init__.py": {
+        "size": 903
+      },
+      "src/gstools/normalizer/base.py": {
+        "size": 8573
+      },
+      "src/gstools/normalizer/methods.py": {
+        "size": 10331
+      },
+      "src/gstools/normalizer/tools.py": {
+        "size": 6386
+      },
+      "src/gstools/random/__init__.py": {
+        "size": 483
+      },
+      "src/gstools/random/rng.py": {
+        "size": 7760
+      },
+      "src/gstools/random/tools.py": {
+        "size": 4912
+      },
+      "src/gstools/tools/__init__.py": {
+        "size": 2709
+      },
+      "src/gstools/tools/export.py": {
+        "size": 7839
+      },
+      "src/gstools/tools/geometric.py": {
+        "size": 22069
+      },
+      "src/gstools/tools/misc.py": {
+        "size": 4261
+      },
+      "src/gstools/tools/special.py": {
+        "size": 7422
+      },
+      "src/gstools/transform/__init__.py": {
+        "size": 1549
+      },
+      "src/gstools/transform/array.py": {
+        "size": 11201
+      },
+      "src/gstools/transform/field.py": {
+        "size": 20373
+      },
+      "src/gstools/variogram/__init__.py": {
+        "size": 667
+      },
+      "src/gstools/variogram/binning.py": {
+        "size": 3494
+      },
+      "src/gstools/variogram/variogram.py": {
+        "size": 20991
+      },
+      "tests/data/variogram.txt": {
+        "size": 5000
+      },
+      "tests/test_condition.py": {
+        "size": 6012
+      },
+      "tests/test_covmodel.py": {
+        "size": 16534
+      },
+      "tests/test_export.py": {
+        "size": 1974
+      },
+      "tests/test_field.py": {
+        "size": 4053
+      },
+      "tests/test_fouriergen.py": {
+        "size": 3566
+      },
+      "tests/test_incomprrandmeth.py": {
+        "size": 2110
+      },
+      "tests/test_krige.py": {
+        "size": 11094
+      },
+      "tests/test_latlon.py": {
+        "size": 5935
+      },
+      "tests/test_normalizer.py": {
+        "size": 7142
+      },
+      "tests/test_pgs.py": {
+        "size": 7161
+      },
+      "tests/test_randmeth.py": {
+        "size": 2744
+      },
+      "tests/test_rng.py": {
+        "size": 4257
+      },
+      "tests/test_srf.py": {
+        "size": 12933
+      },
+      "tests/test_sum_model.py": {
+        "size": 8835
+      },
+      "tests/test_temporal.py": {
+        "size": 2304
+      },
+      "tests/test_transform.py": {
+        "size": 6352
+      },
+      "tests/test_variogram_structured.py": {
+        "size": 11183
+      },
+      "tests/test_variogram_unstructured.py": {
+        "size": 15024
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.src.gstools"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": false,
+    "pyproject": true,
+    "setup_cfg": false,
+    "setup_py": false
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "src.gstools.covmodel",
+        "module": "base",
+        "functions": [
+          "fit_variogram",
+          "cor"
+        ],
+        "classes": [
+          "CovModel"
+        ],
+        "description": "Provides base classes and functions for covariance models, including fitting and correlation calculations."
+      },
+      {
+        "package": "src.gstools.field",
+        "module": "base",
+        "functions": [
+          "generate_field"
+        ],
+        "classes": [
+          "SRF",
+          "CondSRF"
+        ],
+        "description": "Handles spatial random field generation and conditioned field generation."
+      },
+      {
+        "package": "src.gstools.krige",
+        "module": "base",
+        "functions": [
+          "kriging_interpolation"
+        ],
+        "classes": [
+          "Krige"
+        ],
+        "description": "Implements kriging interpolation methods for spatial data."
+      },
+      {
+        "package": "src.gstools.variogram",
+        "module": "variogram",
+        "functions": [
+          "vario_estimate"
+        ],
+        "classes": [],
+        "description": "Provides tools for empirical variogram estimation and analysis."
+      },
+      {
+        "package": "src.gstools.tools",
+        "module": "export",
+        "functions": [
+          "vtk_export",
+          "to_pyvista"
+        ],
+        "classes": [],
+        "description": "Facilitates export of data for visualization in tools like ParaView and PyVista."
+      }
+    ],
+    "cli_commands": [],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.9
+    },
+    "dependencies": {
+      "required": [
+        "numpy",
+        "scipy",
+        "matplotlib"
+      ],
+      "optional": [
+        "pyvista",
+        "cartopy"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.9,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/GeoStat-Framework/GSTools",
+    "repo_name": "GSTools",
+    "content": "GeoStat-Framework/GSTools\nGSTools Overview\nInstallation and Setup\nLibrary Structure and API\nCore Concepts\nCovariance Models\nSpatial Random Fields\nVariogram Theory and Estimation\nField Generation\nBasic Field Generation\nConditioned Fields\nPlurigaussian Simulation\nVariogram Analysis\nEmpirical Variogram Estimation\nModel Fitting and Validation\nDirectional and Anisotropic Analysis\nKriging and Interpolation\nKriging Methods\nGeographic and Temporal Kriging\nAdvanced Features\nField Transformations\nSum Models and Multi-Scale Analysis\nGeographic Coordinate Systems\nVisualization and Export\nField Plotting and Visualization\nData Export and Integration\nDevelopment and Testing\nCI/CD Pipeline\nDocumentation System\nGSTools Overview\ndocs/Makefile\ndocs/source/_templates/layout.html\ndocs/source/authors.rst\ndocs/source/changelog.rst\ndocs/source/conf.py\ndocs/source/contents.rst\ndocs/source/index.rst\nsrc/gstools/__init__.py\nsrc/gstools/tools/__init__.py\nPurpose and Scope\nThis document provides a comprehensive overview of GSTools, a Python library for geostatistical modeling and spatial analysis. It covers the library's core architecture, main components, and how different subsystems interact to enable spatial random field generation, kriging, and variogram analysis.\nFor specific installation procedures and backend configuration, seeInstallation and Setup. For detailed library structure and API organization, seeLibrary Structure and API.\nWhat is GSTools?\nGSTools is a comprehensive geostatistical Python library designed for spatial data analysis and random field modeling. The library provides tools for generating spatial random fields, performing kriging interpolation, estimating variograms, and conducting advanced geostatistical analyses.\nThe library supports multiple computational backends and provides extensive export capabilities for integration with visualization tools like ParaView and PyVista. GSTools is built around a modular architecture that separates core mathematical models from field generation algorithms and interpolation methods.\nSources:README.md29-44docs/source/index.rst22-37src/gstools/__init__.py1-9\nCore System Architecture\nComputational BackendsInfrastructureAdvanced FeaturesCore Geostatistical ComponentsCovModel FrameworkBase class + implementationsGaussian, Exponential, MaternSRF - Spatial Random FieldsField generation enginesRandMeth, Fourier generatorsKriging SystemSimple, Ordinary, UniversalInterpolation methodsVariogram Estimationvario_estimate functionsEmpirical variogram calculationCondSRFConditioned field generationKriging-based conditioningPGS - Plurigaussian SimulationCategorical field generationMulti-Gaussian approachSumModelMulti-scale model combinationNested covariance structuresField TransformationsData normalizationDistribution conversionsconfig moduleBackend selectionThreading controltools subpackageVTK export, geometryUtility functionsrandom subpackageRNG managementSeeded generationGSTools-CythonOpenMP parallel backendGSTools-CoreRust backend (optional)\nComputational Backends\nInfrastructure\nAdvanced Features\nCore Geostatistical Components\nCovModel FrameworkBase class + implementationsGaussian, Exponential, Matern\nSRF - Spatial Random FieldsField generation enginesRandMeth, Fourier generators\nKriging SystemSimple, Ordinary, UniversalInterpolation methods\nVariogram Estimationvario_estimate functionsEmpirical variogram calculation\nCondSRFConditioned field generationKriging-based conditioning\nPGS - Plurigaussian SimulationCategorical field generationMulti-Gaussian approach\nSumModelMulti-scale model combinationNested covariance structures\nField TransformationsData normalizationDistribution conversions\nconfig moduleBackend selectionThreading control\ntools subpackageVTK export, geometryUtility functions\nrandom subpackageRNG managementSeeded generation\nGSTools-CythonOpenMP parallel backend\nGSTools-CoreRust backend (optional)\nGSTools Core System Architecture\nThis diagram shows the fundamental architecture of GSTools, organized around four core geostatistical components that work cyclically together. TheCovModelframework provides mathematical foundations,SRFgenerates spatial fields,Krigeperforms interpolation, and variogram estimation enables model parameter fitting. Advanced features extend these capabilities while a configurable infrastructure layer manages backends and utilities.\nSources:README.md33-44src/gstools/__init__.py12-26src/gstools/__init__.py137-147\nMain Components and Code Organization\nKey Public Classesgstools Package StructureSupport SubpackagesCore Subpackagesgstools.init.pyTop-level importsPublic API definitiongstools.covmodelCovModel base classGaussian, Exponential, MaternStable, Rational, etc.gstools.fieldSRF, CondSRF, PGS classesField generation algorithmsgstools.krigeKrige base classSimple, Ordinary, Universalgstools.variogramvario_estimate functionsEmpirical variogram toolsgstools.toolsvtk_export functionsGeometric utilitiesEARTH_RADIUS constantsgstools.randomRNG managementMasterRNG classgstools.transformField transformationsData preprocessinggstools.normalizerData normalizationDistribution fittinggstools.configBackend configurationThreading settingsCovModelUser-defined modelscor() method overrideSRFSpatial Random Fieldcallmethod for generationKrigeKriging interpolationcallmethod for predictionCondSRFConditioned fieldsset_pos() method\nKey Public Classes\ngstools Package Structure\nSupport Subpackages\nCore Subpackages\ngstools.init.pyTop-level importsPublic API definition\ngstools.covmodelCovModel base classGaussian, Exponential, MaternStable, Rational, etc.\ngstools.fieldSRF, CondSRF, PGS classesField generation algorithms\ngstools.krigeKrige base classSimple, Ordinary, Universal\ngstools.variogramvario_estimate functionsEmpirical variogram tools\ngstools.toolsvtk_export functionsGeometric utilitiesEARTH_RADIUS constants\ngstools.randomRNG managementMasterRNG class\ngstools.transformField transformationsData preprocessing\ngstools.normalizerData normalizationDistribution fitting\ngstools.configBackend configurationThreading settings\nCovModelUser-defined modelscor() method override\nSRFSpatial Random Fieldcallmethod for generation\nKrigeKriging interpolationcallmethod for prediction\nCondSRFConditioned fieldsset_pos() method\nGSTools Package Structure and Code Organization\nThis diagram maps the library's package structure to its main public classes, showing how the modular organization enables different aspects of geostatistical analysis. Each subpackage contains specific functionality, with the main__init__.pyfile providing a unified public API that imports key classes and functions from their respective subpackages.\n__init__.py\nSources:src/gstools/__init__.py137-147src/gstools/__init__.py201-252src/gstools/tools/__init__.py75-83\nKey Geostatistical Workflows\nGSTools implements several fundamental geostatistical workflows through its core components:\nField Generation Workflow\nModel Definition: Create covariance model using classes likeGaussian,Exponential, orMatern\nExponential\nField Generation: InitializeSRFclass with the model and call with spatial coordinates\nConditioning(optional): UseCondSRFto honor known observations\nExport: Export results usingvtk_exportorto_pyvistamethods\nVariogram Analysis Workflow\nEmpirical Estimation: Usevario_estimatefunction to compute sample variogram\nvario_estimate\nModel Fitting: Applyfit_variogrammethod on covariance model classes\nfit_variogram\nValidation: Validate fitted parameters against empirical data\nIteration: Refine model parameters based on validation results\nKriging Interpolation Workflow\nSetup: InitializeKrigeclass with covariance model and known data points\nPrediction: Call kriging object with target locations for interpolation\nIntegration: Combine withSRFfor conditioned field generation\nSources:README.md117-227docs/source/index.rst171-293\nBackend System Architecture\nGSTools-Cython\nGSTools-Core\nGSTools supports two computational backends controlled through theconfigmodule:\nDefault Backend: UsesGSTools-Cythonwith optional OpenMP parallelization\nGSTools-Cython\nRust Backend: UsesGSTools-Corefor enhanced performance and automatic parallelization\nGSTools-Core\nRuntime Switching: Backend selection viaconfig.USE_GSTOOLS_COREflag\nconfig.USE_GSTOOLS_CORE\nThe backend system is transparent to users - the same API calls work regardless of the selected backend, with performance optimizations handled automatically.\nSources:docs/source/index.rst81-135README.md58-74\nIntegration and Export Capabilities\nGSTools provides extensive integration capabilities with the scientific Python ecosystem:\nVisualization Integration\nVTK Export:vtk_exportfunctions for ParaView visualization\nPyVista Integration:to_pyvistamethods for interactive 3D plotting\nMatplotlib Support: Built-in plotting methods for 2D visualization\nGeographic Support\nCoordinate Systems: Native support for latitude/longitude coordinates\nEarth Scaling: Built-in constants likeEARTH_RADIUSandKM_SCALE\nEARTH_RADIUS\nCartopy Integration: Seamless integration with geographic plotting libraries\nData Format Support\nNumPy Arrays: Direct compatibility with NumPy array structures\nMesh Formats: Support for structured and unstructured meshes\nMultiple Dimensions: 1D, 2D, and 3D field generation and analysis\nSources:src/gstools/tools/__init__.py112-123README.md143-184docs/source/index.rst202-246\nRefresh this wiki\nOn this page\nGSTools Overview\nPurpose and Scope\nWhat is GSTools?\nCore System Architecture\nMain Components and Code Organization\nKey Geostatistical Workflows\nField Generation Workflow\nVariogram Analysis Workflow\nKriging Interpolation Workflow\nBackend System Architecture\nIntegration and Export Capabilities\nVisualization Integration\nGeographic Support\nData Format Support",
+    "model": "gpt-4o-2024-08-06",
+    "source": "selenium",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o-2024-08-06"
+  },
+  "risk": {
+    "import_feasibility": 0.9,
+    "intrusiveness_risk": "low",
+    "complexity": "medium"
+  }
+}

GSTools/mcp_output/diff_report.md

@@ -0,0 +1,64 @@
+# GSTools Project Difference Report
+
+**Date:** February 2, 2026  
+**Time:** 11:49:10  
+**Repository:** GSTools  
+**Project Type:** Python Library  
+**Main Features:** Basic Functionality  
+**Intrusiveness:** None  
+**Workflow Status:** Success  
+**Test Status:** Failed  
+
+## Project Overview
+
+GSTools is a Python library designed to provide basic functionalities for geostatistical modeling and analysis. The project aims to offer a robust set of tools for users in the geosciences field, facilitating the creation and manipulation of spatial data models.
+
+## Difference Analysis
+
+### New Files
+
+In this update, 8 new files have been added to the repository. These files likely introduce new features or enhancements to the existing functionalities of the GSTools library. However, no existing files were modified, indicating that the new additions are supplementary rather than replacements or alterations of current code.
+
+### Modified Files
+
+There were no modifications to existing files in this update. This suggests that the new features or functionalities were implemented in a way that does not interfere with the current codebase, maintaining the integrity of the existing system.
+
+## Technical Analysis
+
+### Workflow Status
+
+The workflow status is marked as successful, indicating that the integration and deployment processes were executed without any issues. This suggests that the new files were correctly integrated into the project structure.
+
+### Test Status
+
+The test status is marked as failed, which is a critical issue that needs immediate attention. The failure in testing indicates that the new additions may have introduced bugs or that the new functionalities are not performing as expected. This could also imply that the test cases themselves need to be updated to accommodate the new features.
+
+## Recommendations and Improvements
+
+1. **Immediate Testing Review:** Conduct a thorough review of the test cases to identify the cause of the failure. Ensure that all new functionalities are covered by appropriate test cases.
+
+2. **Debugging and Issue Resolution:** Identify and resolve any bugs introduced by the new files. This may involve debugging the new code and ensuring compatibility with existing functionalities.
+
+3. **Documentation Update:** Update the project documentation to reflect the new features and provide guidance on their usage. This will help users understand and utilize the new functionalities effectively.
+
+4. **Code Review:** Conduct a code review to ensure that the new additions adhere to the project's coding standards and best practices.
+
+## Deployment Information
+
+The deployment of the new files was successful, as indicated by the workflow status. However, due to the failed test status, it is recommended to hold off on any further deployment until the issues are resolved and all tests pass successfully.
+
+## Future Planning
+
+1. **Enhanced Testing Framework:** Consider enhancing the testing framework to better accommodate future updates and ensure comprehensive coverage of all functionalities.
+
+2. **Feature Expansion:** Plan for future expansions of the library by identifying potential areas for new features or improvements based on user feedback and industry trends.
+
+3. **Community Engagement:** Engage with the user community to gather feedback on the new features and identify any additional needs or issues that may not have been addressed.
+
+## Conclusion
+
+The recent update to the GSTools project introduced 8 new files, expanding the library's capabilities. While the integration was successful, the failure in testing highlights the need for immediate attention to ensure the reliability and functionality of the new additions. By addressing the test failures and updating documentation, the project can continue to provide valuable tools for geostatistical analysis.
+
+---
+
+This report provides a comprehensive overview of the recent changes to the GSTools project, along with actionable recommendations to address current issues and plan for future improvements.

GSTools/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,248 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+try:
+    from src.gstools.covmodel import CovModel
+    from src.gstools.field import SRF, CondSRF, PGS
+    from src.gstools.krige import Krige
+    from src.gstools.variogram import vario_estimate
+    from src.gstools.tools import vtk_export, to_pyvista
+    from src.gstools.random import MasterRNG
+    from src.gstools.transform import FieldTransform
+    from src.gstools.normalizer import DataNormalizer
+    from src.gstools.config import config
+except ImportError as e:
+    print(f"Import failed: {e}. Ensure the source directory is correctly set.")
+    # Fallback mode
+    fallback_mode = True
+else:
+    fallback_mode = False
+
+class Adapter:
+    """
+    Adapter class for GSTools library, providing methods to utilize core functionalities.
+    """
+
+    def __init__(self):
+        self.mode = "import" if not fallback_mode else "fallback"
+
+    # CovModel Methods
+    def create_cov_model(self, model_type, **kwargs):
+        """
+        Create a covariance model instance.
+        
+        Parameters:
+        - model_type: str, type of the covariance model (e.g., 'Gaussian', 'Exponential')
+        - kwargs: additional parameters for the model
+        
+        Returns:
+        - dict: status and model instance or error message
+        """
+        try:
+            model = CovModel(model_type, **kwargs)
+            return {"status": "success", "model": model}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # SRF Methods
+    def create_srf(self, cov_model, **kwargs):
+        """
+        Create a spatial random field instance.
+        
+        Parameters:
+        - cov_model: CovModel instance
+        - kwargs: additional parameters for the SRF
+        
+        Returns:
+        - dict: status and SRF instance or error message
+        """
+        try:
+            srf = SRF(cov_model, **kwargs)
+            return {"status": "success", "srf": srf}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # CondSRF Methods
+    def create_cond_srf(self, cov_model, **kwargs):
+        """
+        Create a conditioned spatial random field instance.
+        
+        Parameters:
+        - cov_model: CovModel instance
+        - kwargs: additional parameters for the CondSRF
+        
+        Returns:
+        - dict: status and CondSRF instance or error message
+        """
+        try:
+            cond_srf = CondSRF(cov_model, **kwargs)
+            return {"status": "success", "cond_srf": cond_srf}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # PGS Methods
+    def create_pgs(self, cov_model, **kwargs):
+        """
+        Create a plurigaussian simulation instance.
+        
+        Parameters:
+        - cov_model: CovModel instance
+        - kwargs: additional parameters for the PGS
+        
+        Returns:
+        - dict: status and PGS instance or error message
+        """
+        try:
+            pgs = PGS(cov_model, **kwargs)
+            return {"status": "success", "pgs": pgs}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Krige Methods
+    def create_krige(self, cov_model, **kwargs):
+        """
+        Create a kriging instance.
+        
+        Parameters:
+        - cov_model: CovModel instance
+        - kwargs: additional parameters for the Krige
+        
+        Returns:
+        - dict: status and Krige instance or error message
+        """
+        try:
+            krige = Krige(cov_model, **kwargs)
+            return {"status": "success", "krige": krige}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Variogram Methods
+    def estimate_variogram(self, data, **kwargs):
+        """
+        Estimate the variogram from data.
+        
+        Parameters:
+        - data: array-like, input data for variogram estimation
+        - kwargs: additional parameters for the variogram estimation
+        
+        Returns:
+        - dict: status and variogram result or error message
+        """
+        try:
+            variogram = vario_estimate(data, **kwargs)
+            return {"status": "success", "variogram": variogram}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Tools Methods
+    def export_to_vtk(self, field, filename):
+        """
+        Export field data to VTK format.
+        
+        Parameters:
+        - field: field data to export
+        - filename: str, output filename
+        
+        Returns:
+        - dict: status and message
+        """
+        try:
+            vtk_export(field, filename)
+            return {"status": "success", "message": "Exported to VTK successfully."}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    def convert_to_pyvista(self, field):
+        """
+        Convert field data to PyVista format.
+        
+        Parameters:
+        - field: field data to convert
+        
+        Returns:
+        - dict: status and PyVista object or error message
+        """
+        try:
+            pv_object = to_pyvista(field)
+            return {"status": "success", "pyvista": pv_object}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Random Methods
+    def create_rng(self, seed=None):
+        """
+        Create a random number generator instance.
+        
+        Parameters:
+        - seed: int, optional seed for RNG
+        
+        Returns:
+        - dict: status and RNG instance or error message
+        """
+        try:
+            rng = MasterRNG(seed)
+            return {"status": "success", "rng": rng}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Transform Methods
+    def apply_field_transform(self, field, transform_type, **kwargs):
+        """
+        Apply a transformation to a field.
+        
+        Parameters:
+        - field: field data to transform
+        - transform_type: str, type of transformation
+        - kwargs: additional parameters for the transformation
+        
+        Returns:
+        - dict: status and transformed field or error message
+        """
+        try:
+            transform = FieldTransform(transform_type, **kwargs)
+            transformed_field = transform.apply(field)
+            return {"status": "success", "transformed_field": transformed_field}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Normalizer Methods
+    def normalize_data(self, data, method, **kwargs):
+        """
+        Normalize data using a specified method.
+        
+        Parameters:
+        - data: array-like, data to normalize
+        - method: str, normalization method
+        - kwargs: additional parameters for normalization
+        
+        Returns:
+        - dict: status and normalized data or error message
+        """
+        try:
+            normalizer = DataNormalizer(method, **kwargs)
+            normalized_data = normalizer.normalize(data)
+            return {"status": "success", "normalized_data": normalized_data}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Config Methods
+    def configure_backend(self, use_core=False):
+        """
+        Configure the computational backend.
+        
+        Parameters:
+        - use_core: bool, whether to use the GSTools-Core backend
+        
+        Returns:
+        - dict: status and message
+        """
+        try:
+            config.USE_GSTOOLS_CORE = use_core
+            return {"status": "success", "message": f"Backend set to {'GSTools-Core' if use_core else 'GSTools-Cython'}."}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}

GSTools/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

GSTools/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,99 @@
+import os
+import sys
+
+# Path settings to include the local source directory
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+from gstools.covmodel import CovModel
+from gstools.field import SRF
+from gstools.krige import Krige
+from gstools.variogram import vario_estimate
+
+# Create the FastMCP service application
+mcp = FastMCP("geostat_service")
+
+@mcp.tool(name="create_cov_model", description="Create a covariance model")
+def create_cov_model(model_type: str, parameters: dict) -> dict:
+    """
+    Create a covariance model based on the specified type and parameters.
+
+    Parameters:
+    - model_type: The type of covariance model (e.g., 'Gaussian', 'Exponential').
+    - parameters: A dictionary of parameters for the model.
+
+    Returns:
+    - A dictionary with success status and the created model or error message.
+    """
+    try:
+        model = CovModel(model_type, **parameters)
+        return {"success": True, "result": model}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool(name="generate_random_field", description="Generate a spatial random field")
+def generate_random_field(model: CovModel, grid: list) -> dict:
+    """
+    Generate a spatial random field using the specified covariance model and grid.
+
+    Parameters:
+    - model: The covariance model to use for field generation.
+    - grid: A list defining the spatial grid.
+
+    Returns:
+    - A dictionary with success status and the generated field or error message.
+    """
+    try:
+        srf = SRF(model)
+        field = srf(grid)
+        return {"success": True, "result": field}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool(name="perform_kriging", description="Perform kriging interpolation")
+def perform_kriging(model: CovModel, data_points: list, target_points: list) -> dict:
+    """
+    Perform kriging interpolation using the specified covariance model and data points.
+
+    Parameters:
+    - model: The covariance model to use for kriging.
+    - data_points: A list of known data points.
+    - target_points: A list of target points for interpolation.
+
+    Returns:
+    - A dictionary with success status and the interpolated values or error message.
+    """
+    try:
+        krige = Krige(model, data_points)
+        interpolated_values = krige(target_points)
+        return {"success": True, "result": interpolated_values}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool(name="estimate_variogram", description="Estimate an empirical variogram")
+def estimate_variogram(data: list) -> dict:
+    """
+    Estimate an empirical variogram from the given data.
+
+    Parameters:
+    - data: A list of spatial data points.
+
+    Returns:
+    - A dictionary with success status and the estimated variogram or error message.
+    """
+    try:
+        variogram = vario_estimate(data)
+        return {"success": True, "result": variogram}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def create_app() -> FastMCP:
+    """
+    Create and return the FastMCP application instance.
+
+    Returns:
+    - The FastMCP instance for the service.
+    """
+    return mcp

GSTools/mcp_output/requirements.txt

@@ -0,0 +1,12 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+gstools-cython>=1,<2
+emcee>=3.0.0
+hankel>=1.0.0
+meshio>=5.1.0
+numpy>=1.20.0
+pyevtk>=1.1.1
+scipy>=1.1.0
+matplotlib

GSTools/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

GSTools/mcp_output/workflow_summary.json

@@ -0,0 +1,194 @@
+{
+  "repository": {
+    "name": "GSTools",
+    "url": "https://github.com/GeoStat-Framework/GSTools",
+    "local_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/GSTools",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "medium",
+    "intrusiveness_risk": "low"
+  },
+  "execution": {
+    "start_time": 1770004008.1445622,
+    "end_time": 1770004103.8815975,
+    "duration": 95.73703622817993,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 1,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.src.gstools"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": false,
+      "pyproject": true,
+      "setup_cfg": false,
+      "setup_py": false
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.9,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/GeoStat-Framework/GSTools",
+      "repo_name": "GSTools",
+      "content": "GeoStat-Framework/GSTools\nGSTools Overview\nInstallation and Setup\nLibrary Structure and API\nCore Concepts\nCovariance Models\nSpatial Random Fields\nVariogram Theory and Estimation\nField Generation\nBasic Field Generation\nConditioned Fields\nPlurigaussian Simulation\nVariogram Analysis\nEmpirical Variogram Estimation\nModel Fitting and Validation\nDirectional and Anisotropic Analysis\nKriging and Interpolation\nKriging Methods\nGeographic and Temporal Kriging\nAdvanced Features\nField Transformations\nSum Models and Multi-Scale Analysis\nGeographic Coordinate Systems\nVisualization and Export\nField Plotting and Visualization\nData Export and Integration\nDevelopment and Testing\nCI/CD Pipeline\nDocumentation System\nGSTools Overview\ndocs/Makefile\ndocs/source/_templates/layout.html\ndocs/source/authors.rst\ndocs/source/changelog.rst\ndocs/source/conf.py\ndocs/source/contents.rst\ndocs/source/index.rst\nsrc/gstools/__init__.py\nsrc/gstools/tools/__init__.py\nPurpose and Scope\nThis document provides a comprehensive overview of GSTools, a Python library for geostatistical modeling and spatial analysis. It covers the library's core architecture, main components, and how different subsystems interact to enable spatial random field generation, kriging, and variogram analysis.\nFor specific installation procedures and backend configuration, seeInstallation and Setup. For detailed library structure and API organization, seeLibrary Structure and API.\nWhat is GSTools?\nGSTools is a comprehensive geostatistical Python library designed for spatial data analysis and random field modeling. The library provides tools for generating spatial random fields, performing kriging interpolation, estimating variograms, and conducting advanced geostatistical analyses.\nThe library supports multiple computational backends and provides extensive export capabilities for integration with visualization tools like ParaView and PyVista. GSTools is built around a modular architecture that separates core mathematical models from field generation algorithms and interpolation methods.\nSources:README.md29-44docs/source/index.rst22-37src/gstools/__init__.py1-9\nCore System Architecture\nComputational BackendsInfrastructureAdvanced FeaturesCore Geostatistical ComponentsCovModel FrameworkBase class + implementationsGaussian, Exponential, MaternSRF - Spatial Random FieldsField generation enginesRandMeth, Fourier generatorsKriging SystemSimple, Ordinary, UniversalInterpolation methodsVariogram Estimationvario_estimate functionsEmpirical variogram calculationCondSRFConditioned field generationKriging-based conditioningPGS - Plurigaussian SimulationCategorical field generationMulti-Gaussian approachSumModelMulti-scale model combinationNested covariance structuresField TransformationsData normalizationDistribution conversionsconfig moduleBackend selectionThreading controltools subpackageVTK export, geometryUtility functionsrandom subpackageRNG managementSeeded generationGSTools-CythonOpenMP parallel backendGSTools-CoreRust backend (optional)\nComputational Backends\nInfrastructure\nAdvanced Features\nCore Geostatistical Components\nCovModel FrameworkBase class + implementationsGaussian, Exponential, Matern\nSRF - Spatial Random FieldsField generation enginesRandMeth, Fourier generators\nKriging SystemSimple, Ordinary, UniversalInterpolation methods\nVariogram Estimationvario_estimate functionsEmpirical variogram calculation\nCondSRFConditioned field generationKriging-based conditioning\nPGS - Plurigaussian SimulationCategorical field generationMulti-Gaussian approach\nSumModelMulti-scale model combinationNested covariance structures\nField TransformationsData normalizationDistribution conversions\nconfig moduleBackend selectionThreading control\ntools subpackageVTK export, geometryUtility functions\nrandom subpackageRNG managementSeeded generation\nGSTools-CythonOpenMP parallel backend\nGSTools-CoreRust backend (optional)\nGSTools Core System Architecture\nThis diagram shows the fundamental architecture of GSTools, organized around four core geostatistical components that work cyclically together. TheCovModelframework provides mathematical foundations,SRFgenerates spatial fields,Krigeperforms interpolation, and variogram estimation enables model parameter fitting. Advanced features extend these capabilities while a configurable infrastructure layer manages backends and utilities.\nSources:README.md33-44src/gstools/__init__.py12-26src/gstools/__init__.py137-147\nMain Components and Code Organization\nKey Public Classesgstools Package StructureSupport SubpackagesCore Subpackagesgstools.init.pyTop-level importsPublic API definitiongstools.covmodelCovModel base classGaussian, Exponential, MaternStable, Rational, etc.gstools.fieldSRF, CondSRF, PGS classesField generation algorithmsgstools.krigeKrige base classSimple, Ordinary, Universalgstools.variogramvario_estimate functionsEmpirical variogram toolsgstools.toolsvtk_export functionsGeometric utilitiesEARTH_RADIUS constantsgstools.randomRNG managementMasterRNG classgstools.transformField transformationsData preprocessinggstools.normalizerData normalizationDistribution fittinggstools.configBackend configurationThreading settingsCovModelUser-defined modelscor() method overrideSRFSpatial Random Fieldcallmethod for generationKrigeKriging interpolationcallmethod for predictionCondSRFConditioned fieldsset_pos() method\nKey Public Classes\ngstools Package Structure\nSupport Subpackages\nCore Subpackages\ngstools.init.pyTop-level importsPublic API definition\ngstools.covmodelCovModel base classGaussian, Exponential, MaternStable, Rational, etc.\ngstools.fieldSRF, CondSRF, PGS classesField generation algorithms\ngstools.krigeKrige base classSimple, Ordinary, Universal\ngstools.variogramvario_estimate functionsEmpirical variogram tools\ngstools.toolsvtk_export functionsGeometric utilitiesEARTH_RADIUS constants\ngstools.randomRNG managementMasterRNG class\ngstools.transformField transformationsData preprocessing\ngstools.normalizerData normalizationDistribution fitting\ngstools.configBackend configurationThreading settings\nCovModelUser-defined modelscor() method override\nSRFSpatial Random Fieldcallmethod for generation\nKrigeKriging interpolationcallmethod for prediction\nCondSRFConditioned fieldsset_pos() method\nGSTools Package Structure and Code Organization\nThis diagram maps the library's package structure to its main public classes, showing how the modular organization enables different aspects of geostatistical analysis. Each subpackage contains specific functionality, with the main__init__.pyfile providing a unified public API that imports key classes and functions from their respective subpackages.\n__init__.py\nSources:src/gstools/__init__.py137-147src/gstools/__init__.py201-252src/gstools/tools/__init__.py75-83\nKey Geostatistical Workflows\nGSTools implements several fundamental geostatistical workflows through its core components:\nField Generation Workflow\nModel Definition: Create covariance model using classes likeGaussian,Exponential, orMatern\nExponential\nField Generation: InitializeSRFclass with the model and call with spatial coordinates\nConditioning(optional): UseCondSRFto honor known observations\nExport: Export results usingvtk_exportorto_pyvistamethods\nVariogram Analysis Workflow\nEmpirical Estimation: Usevario_estimatefunction to compute sample variogram\nvario_estimate\nModel Fitting: Applyfit_variogrammethod on covariance model classes\nfit_variogram\nValidation: Validate fitted parameters against empirical data\nIteration: Refine model parameters based on validation results\nKriging Interpolation Workflow\nSetup: InitializeKrigeclass with covariance model and known data points\nPrediction: Call kriging object with target locations for interpolation\nIntegration: Combine withSRFfor conditioned field generation\nSources:README.md117-227docs/source/index.rst171-293\nBackend System Architecture\nGSTools-Cython\nGSTools-Core\nGSTools supports two computational backends controlled through theconfigmodule:\nDefault Backend: UsesGSTools-Cythonwith optional OpenMP parallelization\nGSTools-Cython\nRust Backend: UsesGSTools-Corefor enhanced performance and automatic parallelization\nGSTools-Core\nRuntime Switching: Backend selection viaconfig.USE_GSTOOLS_COREflag\nconfig.USE_GSTOOLS_CORE\nThe backend system is transparent to users - the same API calls work regardless of the selected backend, with performance optimizations handled automatically.\nSources:docs/source/index.rst81-135README.md58-74\nIntegration and Export Capabilities\nGSTools provides extensive integration capabilities with the scientific Python ecosystem:\nVisualization Integration\nVTK Export:vtk_exportfunctions for ParaView visualization\nPyVista Integration:to_pyvistamethods for interactive 3D plotting\nMatplotlib Support: Built-in plotting methods for 2D visualization\nGeographic Support\nCoordinate Systems: Native support for latitude/longitude coordinates\nEarth Scaling: Built-in constants likeEARTH_RADIUSandKM_SCALE\nEARTH_RADIUS\nCartopy Integration: Seamless integration with geographic plotting libraries\nData Format Support\nNumPy Arrays: Direct compatibility with NumPy array structures\nMesh Formats: Support for structured and unstructured meshes\nMultiple Dimensions: 1D, 2D, and 3D field generation and analysis\nSources:src/gstools/tools/__init__.py112-123README.md143-184docs/source/index.rst202-246\nRefresh this wiki\nOn this page\nGSTools Overview\nPurpose and Scope\nWhat is GSTools?\nCore System Architecture\nMain Components and Code Organization\nKey Geostatistical Workflows\nField Generation Workflow\nVariogram Analysis Workflow\nKriging Interpolation Workflow\nBackend System Architecture\nIntegration and Export Capabilities\nVisualization Integration\nGeographic Support\nData Format Support",
+      "model": "gpt-4o-2024-08-06",
+      "source": "selenium",
+      "success": true
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/GSTools/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "Improve test coverage by adding more unit tests",
+    "Ensure all dependencies are clearly defined in a requirements.txt or environment.yml file",
+    "Optimize large files for better performance",
+    "Enhance documentation for better clarity and user guidance",
+    "Implement continuous integration to automate testing and deployment",
+    "Refactor code to improve readability and maintainability",
+    "Consider adding more examples to demonstrate library usage",
+    "Evaluate and improve the performance of core functions",
+    "Ensure compatibility with the latest versions of dependencies",
+    "Conduct a security audit to identify and fix vulnerabilities"
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Comprehensive analysis and generation nodes executed successfully",
+      "Successful integration of MCP plugin with healthy service status"
+    ],
+    "failure_reasons": [],
+    "overall_assessment": "excellent",
+    "node_performance": {
+      "download_time": "Efficient download with no delays",
+      "analysis_time": "Completed within expected duration",
+      "generation_time": "Efficient generation with no errors",
+      "test_time": "Original project tests failed, but MCP plugin tests passed"
+    },
+    "resource_usage": {
+      "memory_efficiency": "Memory usage data not available",
+      "cpu_efficiency": "CPU usage data not available",
+      "disk_usage": "Disk usage data not available"
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 75,
+    "architecture_score": 80,
+    "performance_score": 70,
+    "maintainability_score": 75,
+    "security_score": 85,
+    "scalability_score": 80
+  }
+}

GSTools/source/.readthedocs.yml

@@ -0,0 +1,18 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+sphinx:
+  configuration: docs/source/conf.py
+
+formats: [pdf]
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - doc

GSTools/source/.zenodo.json

@@ -0,0 +1,49 @@
+{
+    "license": "LGPL-3.0-or-later",
+    "contributors": [
+        {
+            "type": "Other",
+            "name": "Bane Sullivan"
+        },
+        {
+            "orcid": "0000-0002-2547-8102",
+            "affiliation": "Helmholtz Centre for Environmental Research - UFZ",
+            "type": "ResearchGroup",
+            "name": "Falk He\u00dfe"
+        },
+        {
+            "orcid": "0000-0002-8783-6198",
+            "affiliation": "Hydrogeology Group, Department of Earth Science, Utrecht University, Netherlands",
+            "type": "ResearchGroup",
+            "name": "Alraune Zech"
+        },
+        {
+            "orcid": "0000-0002-7798-7080",
+            "affiliation": "Helmholtz Centre for Environmental Research - UFZ",
+            "type": "Supervisor",
+            "name": "Sabine Attinger"
+        }
+    ],
+    "language": "eng",
+    "keywords": [
+        "geostatistics",
+        "kriging",
+        "random fields",
+        "covariance models",
+        "variogram",
+        "Python",
+        "GeoStat-Framework"
+    ],
+    "creators": [
+        {
+            "orcid": "0000-0001-9060-4008",
+            "affiliation": "Helmholtz Centre for Environmental Research - UFZ",
+            "name": "Sebastian M\u00fcller"
+        },
+        {
+            "orcid": "0000-0001-9362-1372",
+            "affiliation": "Helmholtz Centre for Environmental Research - UFZ",
+            "name": "Lennart Sch\u00fcler"
+        }
+    ]
+}

GSTools/source/AUTHORS.md

@@ -0,0 +1,17 @@
+# Authors
+
+GSTools is available on [GitHub](https://github.com/GeoStat-Framework/GSTools)
+and was created by following people.
+
+
+## Core developers
+
+- Sebastian Müller, GitHub: [@MuellerSeb](https://github.com/MuellerSeb), Email:  <sebastian@geostat-framework.org>
+- Lennart Schüler, GitHub: [@LSchueler](https://github.com/LSchueler), Email:  <lennart@geostat-framework.org>
+
+
+## Contributors (in order of contributions)
+
+- Falk Heße, GitHub: [@fhesze](https://github.com/fhesze), Email: <falk.hesse@ufz.de>
+- Bane Sullivan, GitHub: [@banesullivan](https://github.com/banesullivan)
+- Tobias Glaubach, GitHub: [@TobiasGlaubach](https://github.com/TobiasGlaubach)

GSTools/source/CHANGELOG.md

@@ -0,0 +1,538 @@
+# Changelog
+
+All notable changes to **GSTools** will be documented in this file.
+
+## [Unreleased] - ?
+
+### Changes
+
+- replace pylint, black, and isort with ruff [#391](https://github.com/GeoStat-Framework/GSTools/pull/391)
+
+## [1.7.0] - Morphic Mint - 2025-04
+
+### Enhancements
+
+- new feature: Plurigaussian simulations (PGS) ([#370](https://github.com/GeoStat-Framework/GSTools/pull/370))
+  - they simulate distributions of categorical data, e.g. lithofacies, hydrofacies, soil types, or cementitious materials
+  - they naturally extend truncated Gaussian fields, which are already a part of GSTools through the field transformations
+- new feature: support for Sum-Models ([#364](https://github.com/GeoStat-Framework/GSTools/pull/364))
+  - added `SumModel` class
+    - represents sum of covariance models
+    - behaves just as a normal covariance model with kriging and field generation
+    - covariance models can be added with overloaded `+` operator: `model = m1 + m2`
+    - class is subscriptable to access sub-models by index: `m1 = model[0]`
+    - included models will get a nugget of 0 and the nugget is stored separately in the sum-model
+    - model variance is the sum of the sub-model variances
+    - model length-scale is weighted sum of sub-model len-scales, where the weights are the ratios of the sub-models variance to the sum variance (motivated by the integral scale, which satisfies this relation)
+    - anisotropy and rotation need to be the same for all included sub-models
+    - parameters of the sub-models can be accessed by name with added index suffix: `model[0].nu == model.nu_0`
+    - fitting: if `len_scale` is fixed, none of the `len_scale_<i>` can be fixed since len_scale is calculated from variance ratios
+  - added Nugget class (empty SumModel)
+    - allow len scale of 0 in CovModel to enable a pure nugget model
+    - added `zero_var` and `model` attributes to Generator ABC to shortcut field generation for pure nugget models
+
+### Changes
+
+- outsourced cython code to a separate package [GSTools-Cython](https://github.com/GeoStat-Framework/GSTools-Cython) ([#376](https://github.com/GeoStat-Framework/GSTools/pull/376))
+- removed `var_raw` attribute from CovModel (was rarely used and only relevant for the truncated power law models)
+  - BREAKING CHANGE (but not to many should be affected)
+  - TPLCovModel now has a `intensity` attribute which calculates what `var_raw` was before
+- simplified variogram fitting (`var_raw` was a bad idea in the first place)
+- variogram plotting now handles a len-scale of 0 (to properly plot nugget models)
+- fitting: when sill is given and var and nugget are deselected from fitting, an error is raised if given var+nugget is not equal to sill (before, they were reset under the hood in a strange way)
+
+### Bugfixes
+
+- `pnt_cnt` was not recalculated in `vario_estimate` when a mask was applied, together with a given sample size this resulted in an `IndexError` most of the times ([#378](https://github.com/GeoStat-Framework/GSTools/pull/378))
+
+
+## [1.6.1] - Periodic Peach - 2025-01
+
+see [#375](https://github.com/GeoStat-Framework/GSTools/pull/375)
+
+- added wheels for Python 3.13
+
+### Bugfixes
+- fix readthedocs.com problems ([#375](https://github.com/GeoStat-Framework/GSTools/pull/375))
+- remove deprecated scipy dependency ([#375](https://github.com/GeoStat-Framework/GSTools/pull/375))
+
+
+## [1.6.0] - Periodic Peach - 2024-07
+
+### Enhancements
+- add a new spatial random field generator called `Fourier` ([#302](https://github.com/GeoStat-Framework/GSTools/pull/302))
+  - create periodic spatial random fields with `Fourier`, by setting the period length with the keyword `periodic`
+  - add examples to showcase how to use the new generator
+
+### Bugfixes
+- fix some Cython issues ([#354](https://github.com/GeoStat-Framework/GSTools/pull/354))
+  - update deprecated conditional compilation for OpenMP support
+  - fix changing between Cython and Rust backends
+  - improve documentation regarding parallelization
+- fix deprecated license identifier, now Zenodo releases work again ([#356](https://github.com/GeoStat-Framework/GSTools/pull/356))
+
+### Changes
+- require gstools-core v1.0.0 at least ([#361](https://github.com/GeoStat-Framework/GSTools/pull/361))
+
+
+## [1.5.2] - Nifty Neon - 2024-05
+
+### Enhancements
+
+- added global variable `config.NUM_THREADS` to select number of threads for parallel computation ([#336](https://github.com/GeoStat-Framework/GSTools/pull/336))
+- speed up sampling with emcee by setting `vectorize=True` in `EnsembleSampler` ([#346](https://github.com/GeoStat-Framework/GSTools/pull/346))
+- prepare numpy 2 support ([#340](https://github.com/GeoStat-Framework/GSTools/pull/340))
+  - at least numpy 2.0.0rc1 for building extensions (for Python 3.9 and above)
+  - check multiple numpy and scipy versions in CI
+  - fixed minimal versions for numpy
+  - use `np.asarray` everywhere with `np.atleast_(n)d`
+  - fix long/longlong integer issue in cython on windows by always using 64bit integers
+
+### Bugfixes
+- build docs with latest sphinx version ([#340](https://github.com/GeoStat-Framework/GSTools/pull/340))
+- fixed zero division error in spectral density of Integral model ([#347](https://github.com/GeoStat-Framework/GSTools/pull/347))
+- minor pylint fixes for used-before-assignment issues ([#350](https://github.com/GeoStat-Framework/GSTools/pull/350))
+
+### Changes
+- require pyvista 0.40 at least ([#340](https://github.com/GeoStat-Framework/GSTools/pull/340))
+- require matplotlib 3.7 at least ([#350](https://github.com/GeoStat-Framework/GSTools/pull/350))
+- remove universal2 wheels for macos (we already provide separate intel and arm64 wheels) ([#350](https://github.com/GeoStat-Framework/GSTools/pull/350))
+
+
+## [1.5.1] - Nifty Neon - 2023-11
+
+### Enhancements
+
+see [#317](https://github.com/GeoStat-Framework/GSTools/pull/317)
+
+- added wheels for Python 3.12
+- dropped support for Python 3.7 (EOL)
+- linted Cython files with cython-lint
+- use Cython 3 to build extensions
+
+
+## [1.5.0] - Nifty Neon - 2023-06
+
+### Enhancements
+- added `temporal` flag to `CovModel` to explicitly specify spatio-temporal models [#308](https://github.com/GeoStat-Framework/GSTools/pull/308)
+  - rotation between spatial and temporal dimension will be ignored
+  - added `spatial_dim` to `CovModel` to explicitly set spatial dimension for spatio-temporal models
+    - if not using `spatial_dim`, the provided `dim` needs to include the possible temporal dimension
+    - `spatial_dim` is always one less than `field_dim` for spatio-temporal models
+  - also works with `latlon=True` to have a spatio-temporal model with geographic coordinates
+  - all plotting routines respect this
+  - the `Field` class now has a `temporal` attribute which forwards the model attribute
+  - automatic variogram fitting in kriging classes for `temporal=True` and `latlon=True` will raise an error
+- added `geo_scale` to `CovModel` to have a more consistent way to set the units of the model length scale for geographic coordinates [#308](https://github.com/GeoStat-Framework/GSTools/pull/308)
+  - no need to use `rescale` for this anymore (was rather a hack)
+  - added `gs.KM_SCALE` which is the same as `gs.EARTH_RADIUS` for kilometer scaling
+  - added `gs.DEGREE_SCALE` for great circle distance in degrees
+  - added `gs.RADIAN_SCALE` for great circle distance in radians (default and previous behavior)
+  - yadrenko variogram respects this and assumes the great circle distances is given in the respective unit
+  - `vario_estimate` also has `geo_scale` now to control the units of the bins
+- `vario_estimate` now forwards additional kwargs to `standard_bins` (`bin_no`, `max_dist`) [#308](https://github.com/GeoStat-Framework/GSTools/pull/308)
+- added `low` and `high` arguments to `uniform` transformation [#310](https://github.com/GeoStat-Framework/GSTools/pull/310)
+
+### Changes
+- `CovModel`s expect special arguments by keyword now [#308](https://github.com/GeoStat-Framework/GSTools/pull/308)
+- always use f-strings internally [#283](https://github.com/GeoStat-Framework/GSTools/pull/283)
+- removed `verbose` attribute from `RandMeth` classes [#309](https://github.com/GeoStat-Framework/GSTools/pull/309)
+- all arguments for `RandMeth` classes key-word-only now except `model` [#309](https://github.com/GeoStat-Framework/GSTools/pull/309)
+- rename "package" to "api" in doc structure [#290](https://github.com/GeoStat-Framework/GSTools/pull/290)
+
+### Bugfixes
+- latex equations were not rendered correctly in docs [#290](https://github.com/GeoStat-Framework/GSTools/pull/290)
+
+
+## [1.4.1] - Sassy Sapphire - 2022-11
+
+### Enhancements
+- new (Exponential-) Integral model added [#243](https://github.com/GeoStat-Framework/GSTools/pull/243)
+- added wheels for Python 3.11 [#272](https://github.com/GeoStat-Framework/GSTools/pull/272)
+
+### Changes
+- API documentation is polished and fully auto-generated now [#271](https://github.com/GeoStat-Framework/GSTools/pull/271)
+
+### Bugfixes
+- fixed approximation of `Matern.spectrum` for big `nu` [#243](https://github.com/GeoStat-Framework/GSTools/pull/243)
+- GSTools had wrong version when installed from git archive [#272](https://github.com/GeoStat-Framework/GSTools/pull/272)
+- Field.plot: solve long-standing mpl slider bug [#273](https://github.com/GeoStat-Framework/GSTools/pull/273)
+
+
+## [1.4.0] - Sassy Sapphire - 2022-08
+
+### Enhancements
+- added Youtube tutorial to documentation [#239](https://github.com/GeoStat-Framework/GSTools/pull/239)
+- better support for custom generators [#250](https://github.com/GeoStat-Framework/GSTools/pull/250) [#259](https://github.com/GeoStat-Framework/GSTools/pull/259)
+- add `valid_value_types` class variable to all field classes [#250](https://github.com/GeoStat-Framework/GSTools/pull/250)
+- PyKrige: fix passed variogram in case of latlon models [#254](https://github.com/GeoStat-Framework/GSTools/pull/254)
+- add bounds checks for optional arguments of `CovModel` when resetting by class attribute [#255](https://github.com/GeoStat-Framework/GSTools/pull/255)
+- minor coverage improvements [#255](https://github.com/GeoStat-Framework/GSTools/pull/255)
+- documentation: readability improvements [#257](https://github.com/GeoStat-Framework/GSTools/pull/257)
+
+### Changes
+- drop Python 3.6 support (setuptools>60 needs py>3.7) [#241](https://github.com/GeoStat-Framework/GSTools/pull/241)
+- move `setup.cfg` content to `pyproject.toml` ([PEP 621](https://peps.python.org/pep-0621/)) [#241](https://github.com/GeoStat-Framework/GSTools/pull/241)
+- move to `src/` based package structure (better testing, building and structure) [#241](https://github.com/GeoStat-Framework/GSTools/pull/241)
+- use [extension-helpers](https://pypi.org/project/extension-helpers/) for openmp support in `setup.py` [#241](https://github.com/GeoStat-Framework/GSTools/pull/241)
+- increase minimal version of meshio to v5.1 [#241](https://github.com/GeoStat-Framework/GSTools/pull/241)
+
+### Bugfixes
+- Pyvista v0.32 deprecation warning: use point_data instead of point_arrays [#237](https://github.com/GeoStat-Framework/GSTools/pull/237)
+- remove deprecated scipy (v1.9) method pinv2 [#247](https://github.com/GeoStat-Framework/GSTools/pull/247)
+- change float comparison in tests [#248](https://github.com/GeoStat-Framework/GSTools/pull/248)
+- Cython: solve `-Wsometimes-uninitialized` warning [#255](https://github.com/GeoStat-Framework/GSTools/pull/255)
+
+
+## [1.3.5] - Pure Pink - 2022-01
+
+### Changes
+- remove caps for dependencies [#229](https://github.com/GeoStat-Framework/GSTools/pull/229)
+- build linux wheels with manylinux2014 for all versions ([CIBW v2.3.1](https://github.com/pypa/cibuildwheel/releases/tag/v2.3.1)) [#227](https://github.com/GeoStat-Framework/GSTools/pull/227)
+
+### Bugfixes
+- `Field.mesh` was not compatible with [meshio](https://github.com/nschloe/meshio) v5.1+ [#227](https://github.com/GeoStat-Framework/GSTools/pull/227)
+
+
+## [1.3.4] - Pure Pink - 2021-11
+
+### Enhancements
+- add GStools-Core as optional dependency [#215](https://github.com/GeoStat-Framework/GSTools/pull/215)
+- provide wheels for Python 3.10 [#211](https://github.com/GeoStat-Framework/GSTools/pull/211)
+- provide macOS wheels for Apple Silicon [#211](https://github.com/GeoStat-Framework/GSTools/pull/211)
+
+### Changes
+- remove unnecessary `dim` argument in Cython code [#216](https://github.com/GeoStat-Framework/GSTools/issues/216)
+
+
+## [1.3.3] - Pure Pink - 2021-08
+
+### Enhancements
+See: [#197](https://github.com/GeoStat-Framework/GSTools/issues/197)
+- `gstools.transform`:
+  - add keywords `field`, `store`, `process` and `keep_mean` to all transformations to control storage and respect `normalizer`
+  - added `apply_function` transformation
+  - added `apply` as wrapper for all transformations
+  - added `transform` method to all `Field` (sub)classes as interface to `transform.apply`
+  - added checks for normal fields to work smoothly with recently added `normalizer` submodule
+- `Field`:
+  - allow naming fields when generating and control storage with `store` keyword
+  - all subclasses now have the `post_process` keyword (apply mean, normalizer, trend)
+  - added subscription to access fields by name (`Field["field"]`)
+  - added `set_pos` method to set position tuple
+  - allow reusing present `pos` tuple
+  - added `pos`, `mesh_type`, `field_names`, `field_shape`, `all_fields` properties
+- `CondSRF`:
+  - memory optimization by forwarding `pos` from underlying `krige` instance
+  - only recalculate kriging field if `pos` tuple changed (optimized ensemble generation)
+- performance improvement by using `np.asarray` instead of `np.array` where possible
+- updated examples to use new features
+- added incomplete lower gamma function `inc_gamma_low` (for TPLGaussian spectral density)
+- filter `nan` values from `cond_val` array in all kriging routines [#201](https://github.com/GeoStat-Framework/GSTools/issues/201)
+
+### Bugfixes
+- `inc_gamma` was defined wrong for integer `s < 0`
+
+
+## [1.3.2] - Pure Pink - 2021-07
+
+### Bugfixes
+- `vario_estimate` was altering the input field under certain circumstances [#180](https://github.com/GeoStat-Framework/GSTools/issues/180)
+- `emcee` v3.1 now requires `nsteps` in `run_mcmc()` to be integer (called in `RNG.sample_ln_pdf`) [#184](https://github.com/GeoStat-Framework/GSTools/pull/184)
+
+
+## [1.3.1] - Pure Pink - 2021-06
+
+### Enhancements
+- Standalone use of Field class [#166](https://github.com/GeoStat-Framework/GSTools/issues/166)
+- add social badges in README [#169](https://github.com/GeoStat-Framework/GSTools/issues/169), [#170](https://github.com/GeoStat-Framework/GSTools/issues/170)
+
+### Bugfixes
+- use `oldest-supported-numpy` to build cython extensions [#165](https://github.com/GeoStat-Framework/GSTools/pull/165)
+
+
+## [1.3.0] - Pure Pink - 2021-04
+
+### Topics
+
+#### Geographical Coordinates Support ([#113](https://github.com/GeoStat-Framework/GSTools/issues/113))
+- added boolean init parameter `latlon` to indicate a geographic model. When given, spatial dimension is fixed to `dim=3`, `anis` and `angles` will be ignored, since anisotropy is not well-defined on a sphere.
+- add property `field_dim` to indicate the dimension of the resulting field. Will be 2 if `latlon=True`
+- added yadrenko variogram, covariance and correlation method, since the geographic models are derived from standard models in 3D by plugging in the chordal distance of two points on a sphere derived from there great-circle distance `zeta`:
+  - `vario_yadrenko`: given by `variogram(2 * np.sin(zeta / 2))`
+  - `cov_yadrenko`: given by `covariance(2 * np.sin(zeta / 2))`
+  - `cor_yadrenko`: given by `correlation(2 * np.sin(zeta / 2))`
+- added plotting routines for yadrenko methods described above
+- the `isometrize` and `anisometrize` methods will convert `latlon` tuples (given in degree) to points on the unit-sphere in 3D and vice versa
+- representation of geographical models don't display the `dim`, `anis` and `angles` parameters, but `latlon=True`
+- `fit_variogram` will expect an estimated variogram with great-circle distances given in radians
+- **Variogram estimation**
+  - `latlon` switch implemented in `estimate_vario` routine
+  - will return a variogram estimated by the great-circle distance (haversine formula) given in radians
+- **Field**
+  - added plotting routines for latlon fields
+  - no vector fields possible on latlon fields
+  - corretly handle pos tuple for latlon fields
+
+#### Krige Unification ([#97](https://github.com/GeoStat-Framework/GSTools/issues/97))
+- Swiss Army Knife for kriging: The `Krige` class now provides everything in one place
+- "Kriging the mean" is now possible with the switch `only_mean` in the call routine
+- `Simple`/`Ordinary`/`Universal`/`ExtDrift`/`Detrended` are only shortcuts to `Krige` with limited input parameter list
+- We now use the `covariance` function to build up the kriging matrix (instead of variogram)
+- An `unbiased` switch was added to enable simple kriging (where the unbiased condition is not given)
+- An `exact` switch was added to allow smother results, if a `nugget` is present in the model
+- An `cond_err` parameter was added, where measurement error variances can be given for each conditional point
+- pseudo-inverse matrix is now used to solve the kriging system (can be disabled by the new switch `pseudo_inv`), this is equal to solving the system with least-squares and prevents numerical errors
+- added options `fit_normalizer` and `fit_variogram` to automatically fit normalizer and variogram to given data
+
+#### Directional Variograms and Auto-binning ([#87](https://github.com/GeoStat-Framework/GSTools/issues/87), [#106](https://github.com/GeoStat-Framework/GSTools/issues/106), [#131](https://github.com/GeoStat-Framework/GSTools/issues/131))
+- new routine name `vario_estimate` instead of `vario_estimate_unstructured` (old kept for legacy code) for simplicity
+- new routine name `vario_estimate_axis` instead of `vario_estimate_structured` (old kept for legacy code) for simplicity
+- **vario_estimate**
+  - added simple automatic binning routine to determine bins from given data (one third of box diameter as max bin distance, sturges rule for number of bins)
+  - allow to pass multiple fields for joint variogram estimation (e.g. for daily precipitation) on same mesh
+  - `no_data` option added to allow missing values
+  - **masked fields**
+    - user can now pass a masked array (or a list of masked arrays) to deselect data points.
+    - in addition, a `mask` keyword was added to provide an external mask
+  - **directional variograms**
+    - diretional variograms can now be estimated
+    - either provide a list of direction vectors or angles for directions (spherical coordinates)
+    - can be controlled by given angle tolerance and (optional) bandwidth
+    - prepared for nD
+  - structured fields (pos tuple describes axes) can now be passed to estimate an isotropic or directional variogram
+  - distance calculation in cython routines in now independent of dimension
+- **vario_estimate_axis**
+  - estimation along array axis now possible in arbitrary dimensions
+  - `no_data` option added to allow missing values (sovles [#83](https://github.com/GeoStat-Framework/GSTools/issues/83))
+  - axis can be given by name (`"x"`, `"y"`, `"z"`) or axis number (`0`, `1`, `2`, `3`, ...)
+
+#### Better Variogram fitting ([#78](https://github.com/GeoStat-Framework/GSTools/issues/78), [#145](https://github.com/GeoStat-Framework/GSTools/pull/145))
+- fixing sill possible now
+- `loss` is now selectable for smoother handling of outliers
+- r2 score can now be returned to get an impression of the goodness of fitting
+- weights can be passed
+- instead of deselecting parameters, one can also give fix values for each parameter
+- default init guess for `len_scale` is now mean of given bin-centers
+- default init guess for `var` and `nugget` is now mean of given variogram values
+
+#### CovModel update ([#109](https://github.com/GeoStat-Framework/GSTools/issues/109), [#122](https://github.com/GeoStat-Framework/GSTools/issues/122), [#157](https://github.com/GeoStat-Framework/GSTools/pull/157))
+- add new `rescale` argument and attribute to the `CovModel` class to be able to rescale the `len_scale` (usefull for unit conversion or rescaling `len_scale` to coincide with the `integral_scale` like it's the case with the Gaussian model)
+  See: [#90](https://github.com/GeoStat-Framework/GSTools/issues/90), [GeoStat-Framework/PyKrige#119](https://github.com/GeoStat-Framework/PyKrige/issues/119)
+- added new `len_rescaled` attribute to the `CovModel` class, which is the rescaled `len_scale`: `len_rescaled = len_scale / rescale`
+- new method `default_rescale` to provide default rescale factor (can be overridden)
+- remove `doctest` calls
+- docstring updates in `CovModel` and derived models
+- updated all models to use the `cor` routine and make use of the `rescale` argument (See: [#90](https://github.com/GeoStat-Framework/GSTools/issues/90))
+- TPL models got a separate base class to not repeat code
+- added **new models** (See: [#88](https://github.com/GeoStat-Framework/GSTools/issues/88)):
+  -  `HyperSpherical`: (Replaces the old `Intersection` model) Derived from the intersection of hyper-spheres in arbitrary dimensions. Coincides with the linear model in 1D, the circular model in 2D and the classical spherical model in 3D
+  - `SuperSpherical`: like the HyperSpherical, but the shape parameter derived from dimension can be set by the user. Coincides with the HyperSpherical model by default
+  - `JBessel`: a hole model valid in all dimensions. The shape parameter controls the dimension it was derived from. For `nu=0.5` this model coincides with the well known `wave` hole model.
+  - `TPLSimple`: a simple truncated power law controlled by a shape parameter `nu`. Coincides with the truncated linear model for `nu=1`
+  - `Cubic`: to be compatible with scikit-gstat in the future
+- all arguments are now stored as float internally ([#157](https://github.com/GeoStat-Framework/GSTools/pull/157))
+- string representation of the `CovModel` class is now using a float precision (`CovModel._prec=3`) to truncate longish output
+- string representation of the `CovModel` class now only shows `anis` and `angles` if model is anisotropic resp. rotated
+- dimension validity check: raise a warning, if given model is not valid in the desired dimension (See: [#86](https://github.com/GeoStat-Framework/GSTools/issues/86))
+
+#### Normalizer, Trend and Mean ([#124](https://github.com/GeoStat-Framework/GSTools/issues/124))
+
+- new `normalize` submodule containing power-transforms for data to gain normality
+- Base-Class: `Normalizer` providing basic functionality including maximum likelihood fitting
+- added: `LogNormal`, `BoxCox`, `BoxCoxShift`, `YeoJohnson`, `Modulus` and `Manly`
+- normalizer, trend and mean can be passed to SRF, Krige and variogram estimation routines
+  - A trend can be a callable function, that represents a trend in input data. For example a linear decrease of temperature with height.
+  - The normalizer will be applied after the data was detrended, i.e. the trend was substracted from the data, in order to gain normality.
+  - The mean is now interpreted as the mean of the normalized data. The user could also provide a callable mean, but it is mostly meant to be constant.
+
+#### Arbitrary dimensions ([#112](https://github.com/GeoStat-Framework/GSTools/issues/112))
+- allow arbitrary dimensions in all routines (CovModel, Krige, SRF, variogram)
+- anisotropy and rotation following a generalization of tait-bryan angles
+- `CovModel` provides `isometrize` and `anisometrize` routines to convert points
+
+#### New Class for Conditioned Random Fields ([#130](https://github.com/GeoStat-Framework/GSTools/issues/130))
+- **THIS BREAKS BACKWARD COMPATIBILITY**
+- `CondSRF` replaces the conditioning feature of the SRF class, which was cumbersome and limited to Ordinary and Simple kriging
+- `CondSRF` behaves similar to the `SRF` class, but instead of a covariance model, it takes a kriging class as input. With this kriging class, all conditioning related settings are defined.
+
+### Enhancements
+- Python 3.9 Support [#107](https://github.com/GeoStat-Framework/GSTools/issues/107)
+- add routines to format struct. pos tuple by given `dim` or `shape`
+- add routine to format struct. pos tuple by given `shape` (variogram helper)
+- remove `field.tools` subpackage
+- support `meshio>=4.0` and add as dependency
+- PyVista mesh support [#59](https://github.com/GeoStat-Framework/GSTools/issues/59)
+- added `EARTH_RADIUS` as constant providing earths radius in km (can be used to rescale models)
+- add routines `latlon2pos` and `pos2latlon` to convert lat-lon coordinates to points on unit-sphere and vice versa
+- a lot of new examples and tutorials
+- `RandMeth` class got a switch to select the sampling strategy
+- plotter for n-D fields added [#141](https://github.com/GeoStat-Framework/GSTools/issues/141)
+- antialias for contour plots of 2D fields [#141](https://github.com/GeoStat-Framework/GSTools/issues/141)
+- building from source is now configured with `pyproject.toml` to care about build dependencies, see [#154](https://github.com/GeoStat-Framework/GSTools/issues/154)
+
+### Changes
+- drop support for Python 3.5 [#146](https://github.com/GeoStat-Framework/GSTools/pull/146)
+- added a finit limit for shape-parameters in some `CovModel`s [#147](https://github.com/GeoStat-Framework/GSTools/pull/147)
+- drop usage of `pos2xyz` and `xyz2pos`
+- remove structured option from generators (structured pos need to be converted first)
+- explicitly assert dim=2,3 when generating vector fields
+- simplify `pre_pos` routine to save pos tuple and reformat it an unstructured tuple
+- simplify field shaping
+- simplify plotting routines
+- only the `"unstructured"` keyword is recognized everywhere, everything else is interpreted as `"structured"` (e.g. `"rectilinear"`)
+- use GitHub-Actions instead of TravisCI
+- parallel build now controlled by env-var `GSTOOLS_BUILD_PARALLEL=1`, see [#154](https://github.com/GeoStat-Framework/GSTools/issues/154)
+- install extra target for `[dev]` dropped, can be reproduced by `pip install gstools[test, doc]`, see [#154](https://github.com/GeoStat-Framework/GSTools/issues/154)
+
+### Bugfixes
+- typo in keyword argument for vario_estimate_structured [#80](https://github.com/GeoStat-Framework/GSTools/issues/80)
+- isotropic rotation of SRF was not possible [#100](https://github.com/GeoStat-Framework/GSTools/issues/100)
+- `CovModel.opt_arg` now sorted [#103](https://github.com/GeoStat-Framework/GSTools/issues/103)
+- `CovModel.fit`: check if weights are given as a string (numpy comparison error) [#111](https://github.com/GeoStat-Framework/GSTools/issues/111)
+- several pylint fixes ([#159](https://github.com/GeoStat-Framework/GSTools/pull/159))
+
+
+## [1.2.1] - Volatile Violet - 2020-04-14
+
+### Bugfixes
+- `ModuleNotFoundError` is not present in py35
+- Fixing Cressie-Bug #76
+- Adding analytical formula for integral scales of rational and stable model
+- remove prange from IncomprRandMeth summators to prevent errors on Win and macOS
+
+
+## [1.2.0] - Volatile Violet - 2020-03-20
+
+### Enhancements
+- different variogram estimator functions can now be used #51
+- the TPLGaussian and TPLExponential now have analytical spectra #67
+- added property `is_isotropic` to `CovModel` #67
+- reworked the whole krige sub-module to provide multiple kriging methods #67
+  - Simple
+  - Ordinary
+  - Universal
+  - External Drift Kriging
+  - Detrended Kriging
+- a new transformation function for discrete fields has been added #70
+- reworked tutorial section in the documentation #63
+- pyvista interface #29
+
+### Changes
+- Python versions 2.7 and 3.4 are no longer supported #40 #43
+- `CovModel`: in 3D the input of anisotropy is now treated slightly different: #67
+  - single given anisotropy value [e] is converted to [1, e] (it was [e, e] before)
+  - two given length-scales [l_1, l_2] are converted to [l_1, l_2, l_2] (it was [l_1, l_2, l_1] before)
+
+### Bugfixes
+- a race condition in the structured variogram estimation has been fixed #51
+
+
+## [1.1.1] - Reverberating Red - 2019-11-08
+
+### Enhancements
+- added a changelog. See: [commit fbea883](https://github.com/GeoStat-Framework/GSTools/commit/fbea88300d0862393e52f4b7c3d2b15c2039498b)
+
+### Changes
+- deprecation warnings are now printed if Python versions 2.7 or 3.4 are used #40 #41
+
+### Bugfixes
+- define spectral_density instead of spectrum in covariance models since Cov-base derives spectrum. See: [commit 00f2747](https://github.com/GeoStat-Framework/GSTools/commit/00f2747fd0503ff8806f2eebfba36acff813416b)
+- better boundaries for `CovModel` parameters. See: https://github.com/GeoStat-Framework/GSTools/issues/37
+
+
+## [1.1.0] - Reverberating Red - 2019-10-01
+
+### Enhancements
+- by using Cython for all the heavy computations, we could achieve quite some speed ups and reduce the memory consumption significantly #16
+- parallel computation in Cython is now supported with the help of OpenMP and the performance increase is nearly linear with increasing cores #16
+- new submodule `krige` providing simple (known mean) and ordinary (estimated mean) kriging working analogous to the srf class
+- interface to pykrige to use the gstools `CovModel` with the pykrige routines (https://github.com/bsmurphy/PyKrige/issues/124)
+- the srf class now provides a `plot` and a `vtk_export` routine
+- incompressible flow fields can now be generated #14
+- new submodule providing several field transformations like: Zinn&Harvey, log-normal, bimodal, ... #13
+- Python 3.4 and 3.7 wheel support #19
+- field can now be generated directly on meshes from [meshio](https://github.com/nschloe/meshio) and [ogs5py](https://github.com/GeoStat-Framework/ogs5py), see: [commit f4a3439](https://github.com/GeoStat-Framework/GSTools/commit/f4a3439400b81d8d9db81a5f7fbf6435f603cf05)
+- the srf and kriging classes now store the last `pos`, `mesh_type` and `field` values to keep them accessible, see: [commit 29f7f1b](https://github.com/GeoStat-Framework/GSTools/commit/29f7f1b029866379ce881f44765f72534d757fae)
+- tutorials on all important features of GSTools have been written for you guys #20
+- a new interface to pyvista is provided to export fields to python vtk representation, which can be used for plotting, exploring and exporting fields #29
+
+### Changes
+- the license was changed from GPL to LGPL in order to promote the use of this library #25
+- the rotation angles are now interpreted in positive direction (counter clock wise)
+- the `force_moments` keyword was removed from the SRF call method, it is now in provided as a field transformation #13
+- drop support of python implementations of the variogram estimators #18
+- the `variogram_normed` method was removed from the `CovModel` class due to redundance [commit 25b1647](https://github.com/GeoStat-Framework/GSTools/commit/25b164722ac6744ebc7e03f3c0bf1c30be1eba89)
+- the position vector of 1D fields does not have to be provided in a list-like object with length 1 [commit a6f5be8](https://github.com/GeoStat-Framework/GSTools/commit/a6f5be8bfd2db1f002e7889ecb8e9a037ea08886)
+
+### Bugfixes
+- several minor bugfixes
+
+
+## [1.0.1] - Bouncy Blue - 2019-01-18
+
+### Bugfixes
+- fixed Numpy and Cython version during build process
+
+
+## [1.0.0] - Bouncy Blue - 2019-01-16
+
+### Enhancements
+- added a new covariance class, which allows the easy usage of arbitrary covariance models
+- added many predefined covariance models, including truncated power law models
+- added [tutorials](https://geostat-framework.readthedocs.io/projects/gstools/en/latest/tutorials.html) and examples, showing and explaining the main features of GSTools
+- variogram models can be fitted to data
+- prebuilt binaries for many Linux distributions, Mac OS and Windows, making the installation, especially of the Cython code, much easier
+- the generated fields can now easily be exported to vtk files
+- variance scaling is supported for coarser grids
+- added pure Python versions of the variogram estimators, in case somebody has problems compiling Cython code
+- the [documentation](https://geostat-framework.readthedocs.io/projects/gstools/en/latest/) is now a lot cleaner and easier to use
+- the code is a lot cleaner and more consistent now
+- unit tests are now automatically tested when new code is pushed
+- test coverage of code is shown
+- GeoStat Framework now has a website, visit us: https://geostat-framework.github.io/
+
+### Changes
+- release is not downwards compatible with release v0.4.0
+- SRF creation has been adapted for the `CovModel`
+- a tuple `pos` is now used instead of `x`, `y`, and `z` for the axes
+- renamed `estimate_unstructured` and `estimate_structured` to `vario_estimate_unstructured` and `vario_estimate_structured` for less ambiguity
+
+### Bugfixes
+- several minor bugfixes
+
+
+## [0.4.0] - Glorious Green - 2018-07-17
+
+### Bugfixes
+- import of cython functions put into a try-block
+
+
+## [0.3.6] - Original Orange - 2018-07-17
+
+First release of GSTools.
+
+
+[Unreleased]: https://github.com/GeoStat-Framework/gstools/compare/v1.7.0...HEAD
+[1.7.0]: https://github.com/GeoStat-Framework/gstools/compare/v1.6.1...v1.7.0
+[1.6.1]: https://github.com/GeoStat-Framework/gstools/compare/v1.6.0...v1.6.1
+[1.6.0]: https://github.com/GeoStat-Framework/gstools/compare/v1.5.2...v1.6.0
+[1.5.2]: https://github.com/GeoStat-Framework/gstools/compare/v1.5.1...v1.5.2
+[1.5.1]: https://github.com/GeoStat-Framework/gstools/compare/v1.5.0...v1.5.1
+[1.5.0]: https://github.com/GeoStat-Framework/gstools/compare/v1.4.1...v1.5.0
+[1.4.1]: https://github.com/GeoStat-Framework/gstools/compare/v1.4.0...v1.4.1
+[1.4.0]: https://github.com/GeoStat-Framework/gstools/compare/v1.3.5...v1.4.0
+[1.3.5]: https://github.com/GeoStat-Framework/gstools/compare/v1.3.4...v1.3.5
+[1.3.4]: https://github.com/GeoStat-Framework/gstools/compare/v1.3.3...v1.3.4
+[1.3.3]: https://github.com/GeoStat-Framework/gstools/compare/v1.3.2...v1.3.3
+[1.3.2]: https://github.com/GeoStat-Framework/gstools/compare/v1.3.1...v1.3.2
+[1.3.1]: https://github.com/GeoStat-Framework/gstools/compare/v1.3.0...v1.3.1
+[1.3.0]: https://github.com/GeoStat-Framework/gstools/compare/v1.2.1...v1.3.0
+[1.2.1]: https://github.com/GeoStat-Framework/gstools/compare/v1.2.0...v1.2.1
+[1.2.0]: https://github.com/GeoStat-Framework/gstools/compare/v1.1.1...v1.2.0
+[1.1.1]: https://github.com/GeoStat-Framework/gstools/compare/v1.1.0...v1.1.1
+[1.1.0]: https://github.com/GeoStat-Framework/gstools/compare/v1.0.1...v1.1.0
+[1.0.1]: https://github.com/GeoStat-Framework/gstools/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/GeoStat-Framework/gstools/compare/0.4.0...v1.0.0
+[0.4.0]: https://github.com/GeoStat-Framework/gstools/compare/0.3.6...0.4.0
+[0.3.6]: https://github.com/GeoStat-Framework/gstools/releases/tag/0.3.6

GSTools/source/CITATION.bib

@@ -0,0 +1,11 @@
+@Article{gmd-15-3161-2022,
+AUTHOR = {M\"uller, S. and Sch\"uler, L. and Zech, A. and He{\ss}e, F.},
+TITLE = {\texttt{GSTools} v1.3: a toolbox for geostatistical modelling in Python},
+JOURNAL = {Geoscientific Model Development},
+VOLUME = {15},
+YEAR = {2022},
+NUMBER = {7},
+PAGES = {3161--3182},
+URL = {https://gmd.copernicus.org/articles/15/3161/2022/},
+DOI = {10.5194/gmd-15-3161-2022}
+}

GSTools/source/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# How to Contribute to GSTools
+
+We are happy about all contributions! :thumbsup:
+
+
+## Did you find a bug?
+
+- Ensure that the bug was not already reported under
+[GitHub issues](https://github.com/GeoStat-Framework/GSTools/issues)
+- If the bug wasn't already reported, open a
+[new issue](https://github.com/GeoStat-Framework/GSTools/issues) with a clear
+description of the problem and if possible with a
+[minimal working example](https://en.wikipedia.org/wiki/Minimal_working_example).
+- please add the version number to the issue:
+
+```python
+import gstools
+print(gstools.__version__)
+```
+
+
+## Do you have suggestions for new features?
+
+Open a [new issue](https://github.com/GeoStat-Framework/GSTools/issues)
+with your idea or suggestion and we'd love to discuss about it.
+
+
+## Do you want to enhance GSTools or fix something?
+
+- Fork the repo on [GitHub](https://github.com/GeoStat-Framework/GSTools)
+- Add yourself to AUTHORS.md (if you want to).
+- We use [Ruff](https://github.com/psf/black) to check and format the code.
+  Please use the scripts `ruff check src/gstools` and
+  `ruff format --diff src/gstools/` after you have written your code.
+- Add some tests if possible.
+- Add an example showing your new feature in one of the examples sub-folders if possible.
+  Follow this [Sphinx-Gallary guide](https://sphinx-gallery.github.io/stable/syntax.html#embed-rst-in-your-example-python-files).
+- Push to your fork and submit a pull request.

GSTools/source/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

GSTools/source/README.md

@@ -0,0 +1,443 @@
+# Welcome to GSTools
+[![GMD](https://img.shields.io/badge/GMD-10.5194%2Fgmd--15--3161--2022-orange)](https://doi.org/10.5194/gmd-15-3161-2022)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1313628.svg)](https://doi.org/10.5281/zenodo.1313628)
+[![PyPI version](https://badge.fury.io/py/gstools.svg)](https://badge.fury.io/py/gstools)
+[![Conda Version](https://img.shields.io/conda/vn/conda-forge/gstools.svg)](https://anaconda.org/conda-forge/gstools)
+[![Build Status](https://github.com/GeoStat-Framework/GSTools/workflows/Continuous%20Integration/badge.svg?branch=main)](https://github.com/GeoStat-Framework/GSTools/actions)
+[![Coverage Status](https://coveralls.io/repos/github/GeoStat-Framework/GSTools/badge.svg?branch=main)](https://coveralls.io/github/GeoStat-Framework/GSTools?branch=main)
+[![Documentation Status](https://readthedocs.org/projects/gstools/badge/?version=latest)](https://geostat-framework.readthedocs.io/projects/gstools/en/stable/?badge=stable)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
+
+<p align="center">
+<img src="https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/gstools.png" alt="GSTools-LOGO" width="251px"/>
+</p>
+
+<p align="center"><b>Get in Touch!</b></p>
+<p align="center">
+<a href="https://github.com/GeoStat-Framework/GSTools/discussions"><img src="https://img.shields.io/badge/GitHub-Discussions-f6f8fa?logo=github&style=flat" alt="GH-Discussions"/></a>
+<a href="mailto:info@geostat-framework.org"><img src="https://img.shields.io/badge/Email-GeoStat--Framework-468a88?style=flat&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbDpzcGFjZT0icHJlc2VydmUiIHdpZHRoPSI1MDAiIGhlaWdodD0iNTAwIj48cGF0aCBkPSJNNDQ4IDg4SDUyYy0yNyAwLTQ5IDIyLTQ5IDQ5djIyNmMwIDI3IDIyIDQ5IDQ5IDQ5aDM5NmMyNyAwIDQ5LTIyIDQ5LTQ5VjEzN2MwLTI3LTIyLTQ5LTQ5LTQ5em0xNiA0OXYyMjZsLTIgNy0xMTUtMTE2IDExNy0xMTd6TTM2IDM2M1YxMzdsMTE3IDExN0wzOCAzNzBsLTItN3ptMjE5LTYzYy0zIDMtNyAzLTEwIDBMNjYgMTIxaDM2OHptLTc5LTIzIDQ2IDQ2YTM5IDM5IDAgMCAwIDU2IDBsNDYtNDYgMTAxIDEwMkg3NXoiIHN0eWxlPSJmaWxsOiNmNWY1ZjU7ZmlsbC1vcGFjaXR5OjEiLz48L3N2Zz4=" alt="Email"/></a>
+</p>
+
+<p align="center"><b>Youtube Tutorial on GSTools</b><br></p>
+
+<p align="center">
+<a href="http://www.youtube.com/watch?feature=player_embedded&v=qZBJ-AZXq6Q" target="_blank">
+<img src="http://img.youtube.com/vi/qZBJ-AZXq6Q/0.jpg" alt="GSTools Transform 22 tutorial" width="480" height="360" border="0" />
+</a>
+</p>
+
+## Purpose
+
+<img align="right" width="450" src="https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/demonstrator.png" alt="">
+
+GSTools provides geostatistical tools for various purposes:
+- random field generation, including periodic boundaries
+- simple, ordinary, universal and external drift kriging
+- conditioned field generation
+- incompressible random vector field generation
+- (automated) variogram estimation and fitting
+- directional variogram estimation and modelling
+- data normalization and transformation
+- many readily provided and even user-defined covariance models
+- metric spatio-temporal modelling
+- plurigaussian field simulations (PGS)
+- plotting and exporting routines
+
+
+## Installation
+
+
+### conda
+
+GSTools can be installed via [conda][conda_link] on Linux, Mac, and Windows.
+Install the package by typing the following command in a command terminal:
+
+    conda install gstools
+
+In case conda forge is not set up for your system yet, see the easy to follow
+instructions on [conda forge][conda_forge_link]. Using conda, the parallelized
+version of GSTools should be installed.
+
+
+### pip
+
+GSTools can be installed via [pip][pip_link] on Linux, Mac, and Windows.
+On Windows you can install [WinPython][winpy_link] to get Python and pip
+running. Install the package by typing the following command in a command terminal:
+
+    pip install gstools
+
+To install the latest development version via pip, see the
+[documentation][doc_install_link].
+One thing to point out is that this way, the non-parallel version of GSTools
+is installed. In case you want the parallel version, follow these easy
+[steps][doc_install_link].
+
+
+## Citation
+
+If you are using GSTools in your publication please cite our paper:
+
+> Müller, S., Schüler, L., Zech, A., and Heße, F.:
+> GSTools v1.3: a toolbox for geostatistical modelling in Python,
+> Geosci. Model Dev., 15, 3161–3182, https://doi.org/10.5194/gmd-15-3161-2022, 2022.
+
+You can cite the Zenodo code publication of GSTools by:
+
+> Sebastian Müller & Lennart Schüler. GeoStat-Framework/GSTools. Zenodo. https://doi.org/10.5281/zenodo.1313628
+
+If you want to cite a specific version, have a look at the [Zenodo site](https://doi.org/10.5281/zenodo.1313628).
+
+
+## Documentation for GSTools
+
+You can find the documentation under [geostat-framework.readthedocs.io][doc_link].
+
+
+### Tutorials and Examples
+
+The documentation also includes some [tutorials][tut_link], showing the most important use cases of GSTools, which are
+
+- [Random Field Generation][tut1_link]
+- [The Covariance Model][tut2_link]
+- [Variogram Estimation][tut3_link]
+- [Random Vector Field Generation][tut4_link]
+- [Kriging][tut5_link]
+- [Conditioned random field generation][tut6_link]
+- [Field transformations][tut7_link]
+- [Geographic Coordinates][tut8_link]
+- [Spatio-Temporal Modelling][tut9_link]
+- [Normalizing Data][tut10_link]
+- [Plurigaussian Field Generation (PGS)][tut11_link]
+- [Miscellaneous examples][tut0_link]
+
+The associated python scripts are provided in the `examples` folder.
+
+
+## Spatial Random Field Generation
+
+The core of this library is the generation of spatial random fields. These fields are generated using the randomisation method, described by [Heße et al. 2014][rand_link].
+
+[rand_link]: https://doi.org/10.1016/j.envsoft.2014.01.013
+
+
+### Examples
+
+#### Gaussian Covariance Model
+
+This is an example of how to generate a 2 dimensional spatial random field with a gaussian covariance model.
+
+```python
+import gstools as gs
+# structured field with a size 100x100 and a grid-size of 1x1
+x = y = range(100)
+model = gs.Gaussian(dim=2, var=1, len_scale=10)
+srf = gs.SRF(model)
+srf((x, y), mesh_type='structured')
+srf.plot()
+```
+<p align="center">
+<img src="https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/gau_field.png" alt="Random field" width="600px"/>
+</p>
+
+GSTools also provides support for [geographic coordinates](https://en.wikipedia.org/wiki/Geographic_coordinate_system).
+This works perfectly well with [cartopy](https://scitools.org.uk/cartopy/docs/latest/index.html).
+
+```python
+import matplotlib.pyplot as plt
+import cartopy.crs as ccrs
+import gstools as gs
+# define a structured field by latitude and longitude
+lat = lon = range(-80, 81)
+model = gs.Gaussian(latlon=True, len_scale=777, geo_scale=gs.KM_SCALE)
+srf = gs.SRF(model, seed=12345)
+field = srf.structured((lat, lon))
+# Orthographic plotting with cartopy
+ax = plt.subplot(projection=ccrs.Orthographic(-45, 45))
+cont = ax.contourf(lon, lat, field, transform=ccrs.PlateCarree())
+ax.coastlines()
+ax.set_global()
+plt.colorbar(cont)
+```
+
+<p align="center">
+<img src="https://github.com/GeoStat-Framework/GeoStat-Framework.github.io/raw/master/img/GS_globe.png" alt="lat-lon random field" width="600px"/>
+</p>
+
+A similar example but for a three dimensional field is exported to a [VTK](https://vtk.org/) file, which can be visualized with [ParaView](https://www.paraview.org/) or [PyVista](https://docs.pyvista.org) in Python:
+
+```python
+import gstools as gs
+# structured field with a size 100x100x100 and a grid-size of 1x1x1
+x = y = z = range(100)
+model = gs.Gaussian(dim=3, len_scale=[16, 8, 4], angles=(0.8, 0.4, 0.2))
+srf = gs.SRF(model)
+srf((x, y, z), mesh_type='structured')
+srf.vtk_export('3d_field') # Save to a VTK file for ParaView
+
+mesh = srf.to_pyvista() # Create a PyVista mesh for plotting in Python
+mesh.contour(isosurfaces=8).plot()
+```
+
+<p align="center">
+<img src="https://github.com/GeoStat-Framework/GeoStat-Framework.github.io/raw/master/img/GS_pyvista.png" alt="3d Random field" width="600px"/>
+</p>
+
+
+## Estimating and Fitting Variograms
+
+The spatial structure of a field can be analyzed with the variogram, which contains the same information as the covariance function.
+
+All covariance models can be used to fit given variogram data by a simple interface.
+
+### Example
+
+This is an example of how to estimate the variogram of a 2 dimensional unstructured field and estimate the parameters of the covariance
+model again.
+
+```python
+import numpy as np
+import gstools as gs
+# generate a synthetic field with an exponential model
+x = np.random.RandomState(19970221).rand(1000) * 100.
+y = np.random.RandomState(20011012).rand(1000) * 100.
+model = gs.Exponential(dim=2, var=2, len_scale=8)
+srf = gs.SRF(model, mean=0, seed=19970221)
+field = srf((x, y))
+# estimate the variogram of the field
+bin_center, gamma = gs.vario_estimate((x, y), field)
+# fit the variogram with a stable model. (no nugget fitted)
+fit_model = gs.Stable(dim=2)
+fit_model.fit_variogram(bin_center, gamma, nugget=False)
+# output
+ax = fit_model.plot(x_max=max(bin_center))
+ax.scatter(bin_center, gamma)
+print(fit_model)
+```
+
+Which gives:
+
+```python
+Stable(dim=2, var=1.85, len_scale=7.42, nugget=0.0, anis=[1.0], angles=[0.0], alpha=1.09)
+```
+
+<p align="center">
+<img src="https://github.com/GeoStat-Framework/GeoStat-Framework.github.io/raw/master/img/GS_vario_est.png" alt="Variogram" width="600px"/>
+</p>
+
+
+## Kriging and Conditioned Random Fields
+
+An important part of geostatistics is Kriging and conditioning spatial random
+fields to measurements. With conditioned random fields, an ensemble of field realizations with their variability depending on the proximity of the measurements can be generated.
+
+### Example
+For better visualization, we will condition a 1d field to a few "measurements", generate 100 realizations and plot them:
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+import gstools as gs
+
+# conditions
+cond_pos = [0.3, 1.9, 1.1, 3.3, 4.7]
+cond_val = [0.47, 0.56, 0.74, 1.47, 1.74]
+
+# conditioned spatial random field class
+model = gs.Gaussian(dim=1, var=0.5, len_scale=2)
+krige = gs.krige.Ordinary(model, cond_pos, cond_val)
+cond_srf = gs.CondSRF(krige)
+# same output positions for all ensemble members
+grid_pos = np.linspace(0.0, 15.0, 151)
+cond_srf.set_pos(grid_pos)
+
+# seeded ensemble generation
+seed = gs.random.MasterRNG(20170519)
+for i in range(100):
+    field = cond_srf(seed=seed(), store=f"field_{i}")
+    plt.plot(grid_pos, field, color="k", alpha=0.1)
+plt.scatter(cond_pos, cond_val, color="k")
+plt.show()
+```
+
+<p align="center">
+<img src="https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/cond_ens.png" alt="Conditioned" width="600px"/>
+</p>
+
+## User Defined Covariance Models
+
+One of the core-features of GSTools is the powerful
+[CovModel][cov_link]
+class, which allows to easy define covariance models by the user.
+
+### Example
+
+Here we re-implement the Gaussian covariance model by defining just a
+[correlation][cor_link] function, which takes a non-dimensional distance ``h = r/l``:
+
+```python
+import numpy as np
+import gstools as gs
+# use CovModel as the base-class
+class Gau(gs.CovModel):
+    def cor(self, h):
+        return np.exp(-h**2)
+```
+
+And that's it! With ``Gau`` you now have a fully working covariance model,
+which you could use for field generation or variogram fitting as shown above.
+
+Have a look at the [documentation ][doc_link] for further information on incorporating
+optional parameters and optimizations.
+
+
+## Incompressible Vector Field Generation
+
+Using the original [Kraichnan method][kraichnan_link], incompressible random
+spatial vector fields can be generated.
+
+
+### Example
+
+```python
+import numpy as np
+import gstools as gs
+x = np.arange(100)
+y = np.arange(100)
+model = gs.Gaussian(dim=2, var=1, len_scale=10)
+srf = gs.SRF(model, generator='VectorField', seed=19841203)
+srf((x, y), mesh_type='structured')
+srf.plot()
+```
+
+yielding
+
+<p align="center">
+<img src="https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/vec_srf_tut_gau.png" alt="vector field" width="600px"/>
+</p>
+
+
+[kraichnan_link]: https://doi.org/10.1063/1.1692799
+
+
+## Plurigaussian Field Simulation (PGS)
+
+With PGS, more complex categorical (or discrete) fields can be created.
+
+
+### Example
+
+```python
+import gstools as gs
+import numpy as np
+import matplotlib.pyplot as plt
+
+N = [180, 140]
+
+x, y = range(N[0]), range(N[1])
+
+# we need 2 SRFs
+model = gs.Gaussian(dim=2, var=1, len_scale=5)
+srf = gs.SRF(model)
+field1 = srf.structured([x, y], seed=20170519)
+field2 = srf.structured([x, y], seed=19970221)
+
+# with `lithotypes`, we prescribe the categorical data and its relations
+# here, we use 2 categories separated by a rectangle.
+rect = [40, 32]
+lithotypes = np.zeros(N)
+lithotypes[
+    N[0] // 2 - rect[0] // 2 : N[0] // 2 + rect[0] // 2,
+    N[1] // 2 - rect[1] // 2 : N[1] // 2 + rect[1] // 2,
+] = 1
+
+pgs = gs.PGS(2, [field1, field2])
+P = pgs(lithotypes)
+
+fig, axs = plt.subplots(1, 2)
+axs[0].imshow(lithotypes, cmap="copper")
+axs[1].imshow(P, cmap="copper")
+plt.show()
+```
+
+<p align="center">
+<img src="https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/2d_pgs.png" alt="PGS" width="600px"/>
+</p>
+
+
+## VTK/PyVista Export
+
+After you have created a field, you may want to save it to file, so we provide
+a handy [VTK][vtk_link] export routine using the `.vtk_export()` or you could
+create a VTK/PyVista dataset for use in Python with to `.to_pyvista()` method:
+
+```python
+import gstools as gs
+x = y = range(100)
+model = gs.Gaussian(dim=2, var=1, len_scale=10)
+srf = gs.SRF(model)
+srf((x, y), mesh_type='structured')
+srf.vtk_export("field") # Saves to a VTK file
+mesh = srf.to_pyvista() # Create a VTK/PyVista dataset in memory
+mesh.plot()
+```
+
+Which gives a RectilinearGrid VTK file ``field.vtr`` or creates a PyVista mesh
+in memory for immediate 3D plotting in Python.
+
+<p align="center">
+<img src="https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/pyvista_export.png" alt="pyvista export" width="600px"/>
+</p>
+
+
+## Requirements:
+
+- [NumPy >= 1.20.0](https://www.numpy.org)
+- [SciPy >= 1.1.0](https://www.scipy.org/scipylib)
+- [hankel >= 1.0.0](https://github.com/steven-murray/hankel)
+- [emcee >= 3.0.0](https://github.com/dfm/emcee)
+- [pyevtk >= 1.1.1](https://github.com/pyscience-projects/pyevtk)
+- [meshio >= 5.1.0](https://github.com/nschloe/meshio)
+
+### Optional
+
+- [GSTools-Core >= 0.2.0](https://github.com/GeoStat-Framework/GSTools-Core)
+- [matplotlib](https://matplotlib.org)
+- [pyvista](https://docs.pyvista.org/)
+
+
+## Contact
+
+You can contact us via <info@geostat-framework.org>.
+
+
+## License
+
+[LGPLv3][license_link] © 2018-2025
+
+[pip_link]: https://pypi.org/project/gstools
+[conda_link]: https://docs.conda.io/en/latest/miniconda.html
+[conda_forge_link]: https://github.com/conda-forge/gstools-feedstock#installing-gstools
+[conda_pip]: https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-pkgs.html#installing-non-conda-packages
+[pipiflag]: https://pip-python3.readthedocs.io/en/latest/reference/pip_install.html?highlight=i#cmdoption-i
+[winpy_link]: https://winpython.github.io/
+[license_link]: https://github.com/GeoStat-Framework/GSTools/blob/main/LICENSE
+[cov_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/generated/gstools.covmodel.CovModel.html#gstools.covmodel.CovModel
+[stable_link]: https://en.wikipedia.org/wiki/Stable_distribution
+[doc_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/
+[doc_install_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/#pip
+[tut_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/tutorials.html
+[tut1_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/01_random_field/index.html
+[tut2_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/02_cov_model/index.html
+[tut3_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/03_variogram/index.html
+[tut4_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/04_vector_field/index.html
+[tut5_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/05_kriging/index.html
+[tut6_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/06_conditioned_fields/index.html
+[tut7_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/07_transformations/index.html
+[tut8_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/08_geo_coordinates/index.html
+[tut9_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/09_spatio_temporal/index.html
+[tut10_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/10_normalizer/index.html
+[tut11_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/11_plurigaussian/index.html
+[tut0_link]: https://geostat-framework.readthedocs.io/projects/gstools/en/stable/examples/00_misc/index.html
+[cor_link]: https://en.wikipedia.org/wiki/Autocovariance#Normalization
+[vtk_link]: https://www.vtk.org/

GSTools/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+GSTools Project Package Initialization File
+"""

GSTools/source/docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = python3 -msphinx
+SPHINXPROJ    = GSTools
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

GSTools/source/docs/source/_static/custom.css

@@ -0,0 +1,3 @@
+dl.py.property {
+    display: block !important;
+}

GSTools/source/docs/source/_templates/autosummary/class.rst

@@ -0,0 +1,13 @@
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+.. autoclass:: {{ objname }}
+   :members:
+   :undoc-members:
+   :inherited-members:
+   :show-inheritance:
+
+.. raw:: latex
+
+    \clearpage

GSTools/source/docs/source/_templates/autosummary/module.rst

@@ -0,0 +1,9 @@
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ fullname }}
+
+.. automodule:: {{ fullname }}
+
+.. raw:: latex
+
+    \clearpage

GSTools/source/docs/source/_templates/layout.html

@@ -0,0 +1,27 @@
+{% extends "!layout.html" %}
+  {% block menu %}
+    <p class="link caption"><span class="link caption-text">Documentation</span></p>
+    {{ super() }}
+    <br />
+    <p class="link caption"><span class="link caption-text">GSTools Links</span></p>
+    <ul>
+      <Li><a href="https://github.com/GeoStat-Framework/GSTools">GSTools GitHub</a></Li>
+      <Li><a href="https://zenodo.org/badge/latestdoi/117534635">GSTools Zenodo DOI</a></Li>
+      <Li><a href="https://pypi.org/project/gstools/">GSTools PyPI</a></Li>
+    </ul>
+    <br />
+    <p class="link caption"><span class="link caption-text">GeoStat Framework</span></p>
+    <ul>
+      <Li><a href="https://geostat-framework.org">GeoStat Website</a></Li>
+      <Li><a href="https://github.com/GeoStat-Framework">GeoStat Github</a></Li>
+      <Li><a href="https://github.com/GeoStat-Examples">GeoStat Examples</a></Li>
+      <Li><a href="https://geostat-framework.readthedocs.io">GeoStat ReadTheDocs</a></Li>
+      <Li><a href="https://pypi.org/user/geostatframework/">GeoStat PyPI</a></Li>
+    </ul>
+    <br />
+    <br />
+    <ul>
+      <Li><a href="{{ pathto('genindex') }}">Index</a></Li>
+      <Li><a href="{{ pathto(master_doc) }}">Sitemap</a></Li>
+    </ul>
+    {% endblock %}

GSTools/source/docs/source/api.rst

@@ -0,0 +1,9 @@
+===========
+GSTools API
+===========
+
+.. automodule:: gstools
+
+.. raw:: latex
+
+    \clearpage

GSTools/source/docs/source/authors.rst

@@ -0,0 +1,2 @@
+.. include:: ../../AUTHORS.md
+   :parser: myst_parser.docutils_

GSTools/source/docs/source/changelog.rst

@@ -0,0 +1,2 @@
+.. include:: ../../CHANGELOG.md
+   :parser: myst_parser.docutils_

GSTools/source/docs/source/conf.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+#
+# GSTools documentation build configuration file, created by
+# sphinx-quickstart on Fri Jan  5 14:20:43 2018.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# NOTE:
+# pip install sphinx_rtd_theme
+# is needed in order to build the documentation
+# import os
+# import sys
+import datetime
+import warnings
+
+warnings.filterwarnings(
+    "ignore",
+    category=UserWarning,
+    message="Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.",
+)
+
+# local module should not be added to sys path if it's installed on RTFD
+# see: https://stackoverflow.com/a/31882049/6696397
+# sys.path.insert(0, os.path.abspath("../../"))
+from gstools import __version__ as ver
+
+
+def skip(app, what, name, obj, skip, options):
+    if name in ["__call__"]:
+        return False
+    return skip
+
+
+def setup(app):
+    app.connect("autodoc-skip-member", skip)
+
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.doctest",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.coverage",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.ifconfig",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.napoleon",  # parameters look better than with numpydoc only
+    "numpydoc",
+    "sphinx_gallery.gen_gallery",
+    "myst_parser",
+    "sphinxcontrib.youtube",
+]
+
+# autosummaries from source-files
+autosummary_generate = True
+# dont show __init__ docstring
+autoclass_content = "class"
+# sort class members
+autodoc_member_order = "groupwise"
+# autodoc_member_order = 'bysource'
+
+# Notes in boxes
+napoleon_use_admonition_for_notes = True
+# Attributes like parameters
+napoleon_use_ivar = True
+# keep "Other Parameters" section
+# https://github.com/sphinx-doc/sphinx/issues/10330
+napoleon_use_param = False
+# this is a nice class-doc layout
+numpydoc_show_class_members = True
+# class members have no separate file, so they are not in a toctree
+numpydoc_class_members_toctree = False
+# for the covmodels alot of classmembers show up...
+# maybe switch off with:    :no-inherited-members:
+numpydoc_show_inherited_class_members = True
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+source_suffix = {
+    ".rst": "restructuredtext",
+    ".md": "markdown",
+}
+# source_suffix = [".rst", ".md"]
+# source_suffix = ".rst"
+
+# The master toctree document.
+# --> this is the sitemap (or content-list in latex -> needs a heading)
+# for html: the quickstart (in index.rst)
+# gets the "index.html" and is therefore opened first
+master_doc = "contents"
+
+# General information about the project.
+curr_year = datetime.datetime.now().year
+project = "GSTools"
+copyright = f"2018 - {curr_year}, Sebastian Müller, Lennart Schüler"
+author = "Sebastian Müller, Lennart Schüler"
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = ver
+# The full version, including alpha/beta/rc tags.
+release = ver
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = "en"
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = []
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = "sphinx"
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = "sphinx_rtd_theme"
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+html_theme_options = {
+    #    'canonical_url': '',
+    #    'analytics_id': '',
+    "logo_only": False,
+    "version_selector": True,
+    "prev_next_buttons_location": "top",
+    #    'style_external_links': False,
+    #    'vcs_pageview_mode': '',
+    # Toc options
+    "collapse_navigation": False,
+    "sticky_navigation": True,
+    "navigation_depth": 6,
+    "includehidden": True,
+    "titles_only": False,
+}
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+
+# These paths are either relative to html_static_path
+# or fully qualified paths (eg. https://...)
+html_css_files = ["custom.css"]
+
+# Custom sidebar templates, must be a dictionary that maps document names
+# to template names.
+#
+# This is required for the alabaster theme
+# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
+html_sidebars = {
+    "**": [
+        "relations.html",  # needs 'show_related': True theme option to display
+        "searchbox.html",
+    ]
+}
+
+
+# -- Options for HTMLHelp output ------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = "GSToolsdoc"
+# logos for the page
+html_logo = "pics/gstools_150.png"
+html_favicon = "pics/gstools.ico"
+
+# -- Options for LaTeX output ---------------------------------------------
+# latex_engine = 'lualatex'
+# logo too big
+latex_logo = "pics/gstools_150.png"
+
+# latex_show_urls = 'footnote'
+# http://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-latex-output
+latex_elements = {
+    "preamble": r"""
+\setcounter{secnumdepth}{1}
+\setcounter{tocdepth}{2}
+\pagestyle{fancy}
+""",
+    "pointsize": "10pt",
+    "papersize": "a4paper",
+    "fncychap": "\\usepackage[Glenn]{fncychap}",
+    # 'inputenc': r'\usepackage[utf8]{inputenc}',
+}
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (
+        master_doc,
+        "GSTools.tex",
+        "GSTools Documentation",
+        "Sebastian Müller, Lennart Schüler",
+        "manual",
+    )
+]
+# latex_use_parts = True
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [(master_doc, "GSTools", "GSTools Documentation", [author], 1)]
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (
+        master_doc,
+        "GSTools",
+        "GSTools Documentation",
+        author,
+        "GSTools",
+        "Geo-statistical toolbox.",
+        "Miscellaneous",
+    )
+]
+
+suppress_warnings = [
+    "image.nonlocal_uri",
+    #    'app.add_directive',  # this evtl. suppresses the numpydoc induced warning
+]
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {
+    "Python": ("https://docs.python.org/", None),
+    "NumPy": ("https://numpy.org/doc/stable/", None),
+    "SciPy": ("https://docs.scipy.org/doc/scipy/", None),
+    "matplotlib": ("https://matplotlib.org/stable/", None),
+    "hankel": ("https://hankel.readthedocs.io/en/latest/", None),
+    "emcee": ("https://emcee.readthedocs.io/en/latest/", None),
+}
+
+# -- Sphinx Gallery Options
+from sphinx_gallery.sorting import FileNameSortKey
+
+# Use pyvista's image scraper for example gallery
+# import pyvista
+# https://github.com/tkoyama010/pyvista-doc-translations/blob/85c835a3ada3a2adefac06ba70e15a101ffa9162/conf.py#L21
+# https://github.com/simpeg/discretize/blob/f414dd7ee7c5ba9a141cb2c37d4b71fdc531eae8/docs/conf.py#L334
+# Make sure off screen is set to true when building locally
+# pyvista.OFF_SCREEN = True
+# # necessary when building the sphinx gallery
+# pyvista.BUILDING_GALLERY = True
+# # Optional - set parameters like theme or window size
+# pyvista.set_plot_theme("document")
+
+sphinx_gallery_conf = {
+    # "image_scrapers": ("pyvista", "matplotlib"),
+    "remove_config_comments": True,
+    # only show "print" output as output
+    "capture_repr": (),
+    # path to your examples scripts
+    "examples_dirs": [
+        "../../examples/00_misc/",
+        "../../examples/01_random_field/",
+        "../../examples/02_cov_model/",
+        "../../examples/03_variogram/",
+        "../../examples/04_vector_field/",
+        "../../examples/05_kriging/",
+        "../../examples/06_conditioned_fields/",
+        "../../examples/07_transformations/",
+        "../../examples/08_geo_coordinates/",
+        "../../examples/09_spatio_temporal/",
+        "../../examples/10_normalizer/",
+        "../../examples/11_plurigaussian/",
+        "../../examples/12_sum_model/",
+    ],
+    # path where to save gallery generated examples
+    "gallery_dirs": [
+        "examples/00_misc/",
+        "examples/01_random_field/",
+        "examples/02_cov_model/",
+        "examples/03_variogram/",
+        "examples/04_vector_field/",
+        "examples/05_kriging/",
+        "examples/06_conditioned_fields/",
+        "examples/07_transformations/",
+        "examples/08_geo_coordinates/",
+        "examples/09_spatio_temporal/",
+        "examples/10_normalizer/",
+        "examples/11_plurigaussian/",
+        "examples/12_sum_model/",
+    ],
+    # Pattern to search for example files
+    "filename_pattern": r"\.py",
+    # Remove the "Download all examples" button from the top level gallery
+    "download_all_examples": False,
+    # Sort gallery example by file name instead of number of lines (default)
+    "within_subsection_order": FileNameSortKey,
+    # directory where function granular galleries are stored
+    "backreferences_dir": "examples/backreferences",
+    # Modules for which function level galleries are created.  In
+    "doc_module": "gstools",
+    # "first_notebook_cell": (
+    #     "%matplotlib inline\n"
+    #     "from pyvista import set_plot_theme\n"
+    #     "set_plot_theme('document')"
+    # ),
+    "matplotlib_animations": True,
+}

GSTools/source/docs/source/contents.rst

@@ -0,0 +1,13 @@
+========
+Contents
+========
+
+.. toctree::
+   :includehidden:
+   :maxdepth: 3
+
+   index
+   tutorials
+   api
+   authors
+   changelog

GSTools/source/docs/source/index.rst

@@ -0,0 +1,504 @@
+==================
+GSTools Quickstart
+==================
+
+.. image:: https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/gstools.png
+   :width: 150px
+   :align: center
+
+.. only:: html
+
+   **Get in Touch!**
+
+   |GH-Discussions| |Email|
+
+   **Youtube Tutorial on GSTools**
+
+   .. youtube:: qZBJ-AZXq6Q
+      :width: 100%
+
+   |
+
+Purpose
+=======
+
+GSTools provides geostatistical tools for various purposes:
+
+- random field generation, including periodic boundaries
+- simple, ordinary, universal and external drift kriging
+- conditioned field generation
+- incompressible random vector field generation
+- (automated) variogram estimation and fitting
+- directional variogram estimation and modelling
+- data normalization and transformation
+- many readily provided and even user-defined covariance models
+- metric spatio-temporal modelling
+- plurigaussian field simulations (PGS)
+- plotting and exporting routines
+
+
+Installation
+============
+
+conda
+-----
+
+GSTools can be installed via
+`conda <https://docs.conda.io/en/latest/miniconda.html>`_ on Linux, Mac, and
+Windows.
+Install the package by typing the following command in a command terminal:
+
+.. code-block:: none
+
+    conda install gstools
+
+In case conda forge is not set up for your system yet, see the easy to follow
+instructions on `conda forge <https://github.com/conda-forge/gstools-feedstock#installing-gstools>`_.
+Using conda, the parallelized version of GSTools should be installed.
+
+
+pip
+---
+
+GSTools can be installed via `pip <https://pypi.org/project/gstools/>`_
+on Linux, Mac, and Windows.
+On Windows you can install `WinPython <https://winpython.github.io/>`_ to get
+Python and pip running.
+Install the package by typing the following into command in a command terminal:
+
+.. code-block:: none
+
+    pip install gstools
+
+To get the latest development version you can install it directly from GitHub:
+
+.. code-block:: none
+
+    pip install git+git://github.com/GeoStat-Framework/GSTools.git@main
+
+If something went wrong during installation, try the :code:`-I` `flag from pip <https://pip-python3.readthedocs.io/en/latest/reference/pip_install.html?highlight=i#cmdoption-i>`_.
+
+**Speeding up GSTools by parallelization**
+
+We provide two possibilities to run GSTools in parallel, often causing a
+massive improvement in runtime. In either case, the number of parallel
+threads can be set with the global variable `config.NUM_THREADS`. If not set,
+all cores are used.
+When using conda, the parallel version of GSTools is installed per default.
+
+***Parallelizing Cython***
+
+For parallel support, the `GSTools-Cython <https://github.com/GeoStat-Framework/GSTools-Cython>`_
+backend needs to be compiled from source the following way:
+
+.. code-block:: none
+
+    export GSTOOLS_BUILD_PARALLEL=1
+    pip install --no-binary=gstools-cython gstools
+
+You have to provide a C compiler and OpenMP to compile GSTools-Cython with parallel support.
+The feature is controlled by the environment variable
+``GSTOOLS_BUILD_PARALLEL``, that can be ``0`` or ``1`` (interpreted as ``0`` if not present).
+Note, that the ``--no-binary=gstools-cython`` option forces pip to not use a wheel
+for the GSTools-Cython backend.
+
+For the development version, you can do almost the same:
+
+.. code-block:: none
+
+    export GSTOOLS_BUILD_PARALLEL=1
+    pip install git+git://github.com/GeoStat-Framework/GSTools-Cython.git@main
+    pip install git+git://github.com/GeoStat-Framework/GSTools.git@main
+
+
+***Using GSTools-Core for parallelization and even more speed***
+
+You can install the optional dependency `GSTools-Core <https://github.com/GeoStat-Framework/GSTools-Core>`_,
+which is a re-implementation of GSTools-Cython:
+
+.. code-block:: none
+
+    pip install gstools[rust]
+
+or by manually installing the package
+
+.. code-block:: none
+
+    pip install gstools-core
+
+The new package uses the language Rust and it should be safer and faster (in some cases by orders of magnitude).
+Once the package GSTools-Core is available on your machine, it will be used by default.
+In case you want to switch back to the Cython implementation, you can set
+:code:`gstools.config.USE_GSTOOLS_CORE=False` in your code. This also works at runtime.
+
+GSTools-Core will automatically run in parallel, without having to provide OpenMP or a local C compiler.
+
+
+Citation
+========
+
+If you are using GSTools in your publication please cite our paper:
+
+    Müller, S., Schüler, L., Zech, A., and Heße, F.: GSTools v1.3: a toolbox for geostatistical modelling in Python, Geosci. Model Dev., 15, 3161–3182, https://doi.org/10.5194/gmd-15-3161-2022, 2022.
+
+You can cite the Zenodo code publication of GSTools by:
+
+    Sebastian Müller & Lennart Schüler. GeoStat-Framework/GSTools. Zenodo. https://doi.org/10.5281/zenodo.1313628
+
+If you want to cite a specific version, have a look at the `Zenodo site <https://doi.org/10.5281/zenodo.1313628>`__.
+
+
+Tutorials and Examples
+======================
+
+The documentation also includes some `tutorials <tutorials.html>`__,
+showing the most important use cases of GSTools, which are
+
+- `Random Field Generation <examples/01_random_field/index.html>`__
+- `The Covariance Model <examples/02_cov_model/index.html>`__
+- `Variogram Estimation <examples/03_variogram/index.html>`__
+- `Random Vector Field Generation <examples/04_vector_field/index.html>`__
+- `Kriging <examples/05_kriging/index.html>`__
+- `Conditioned random field generation <examples/06_conditioned_fields/index.html>`__
+- `Field transformations <examples/07_transformations/index.html>`__
+- `Geographic Coordinates <examples/08_geo_coordinates/index.html>`__
+- `Spatio-Temporal Modelling <examples/09_spatio_temporal/index.html>`__
+- `Normalizing Data <examples/10_normalizer/index.html>`__
+- `Plurigaussian Field Generation (PGS) <examples/11_plurigaussian/index.html>`__
+- `Miscellaneous examples <examples/00_misc/index.html>`__
+
+
+Spatial Random Field Generation
+===============================
+
+The core of this library is the generation of spatial random fields.
+These fields are generated using the randomisation method, described by
+`Heße et al. 2014 <https://doi.org/10.1016/j.envsoft.2014.01.013>`_.
+
+
+Examples
+--------
+
+Gaussian Covariance Model
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This is an example of how to generate a 2 dimensional spatial random field (:any:`SRF`)
+with a :any:`Gaussian` covariance model.
+
+.. code-block:: python
+
+    import gstools as gs
+    # structured field with a size 100x100 and a grid-size of 1x1
+    x = y = range(100)
+    model = gs.Gaussian(dim=2, var=1, len_scale=10)
+    srf = gs.SRF(model)
+    srf((x, y), mesh_type='structured')
+    srf.plot()
+
+.. image:: https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/gau_field.png
+   :width: 400px
+   :align: center
+
+GSTools also provides support for `geographic coordinates <https://en.wikipedia.org/wiki/Geographic_coordinate_system>`_.
+This works perfectly well with `cartopy <https://scitools.org.uk/cartopy/docs/latest/index.html>`_.
+
+.. code-block:: python
+
+    import matplotlib.pyplot as plt
+    import cartopy.crs as ccrs
+    import gstools as gs
+    # define a structured field by latitude and longitude
+    lat = lon = range(-80, 81)
+    model = gs.Gaussian(latlon=True, len_scale=777, geo_scale=gs.KM_SCALE)
+    srf = gs.SRF(model, seed=12345)
+    field = srf.structured((lat, lon))
+    # Orthographic plotting with cartopy
+    ax = plt.subplot(projection=ccrs.Orthographic(-45, 45))
+    cont = ax.contourf(lon, lat, field, transform=ccrs.PlateCarree())
+    ax.coastlines()
+    ax.set_global()
+    plt.colorbar(cont)
+
+.. image:: https://github.com/GeoStat-Framework/GeoStat-Framework.github.io/raw/master/img/GS_globe.png
+   :width: 400px
+   :align: center
+
+A similar example but for a three dimensional field is exported to a
+`VTK <https://vtk.org/>`__ file, which can be visualized with
+`ParaView <https://www.paraview.org/>`_ or
+`PyVista <https://docs.pyvista.org>`__ in Python:
+
+.. code-block:: python
+
+    import gstools as gs
+    # structured field with a size 100x100x100 and a grid-size of 1x1x1
+    x = y = z = range(100)
+    model = gs.Gaussian(dim=3, len_scale=[16, 8, 4], angles=(0.8, 0.4, 0.2))
+    srf = gs.SRF(model)
+    srf((x, y, z), mesh_type='structured')
+    srf.vtk_export('3d_field') # Save to a VTK file for ParaView
+
+    mesh = srf.to_pyvista() # Create a PyVista mesh for plotting in Python
+    mesh.contour(isosurfaces=8).plot()
+
+.. image:: https://github.com/GeoStat-Framework/GeoStat-Framework.github.io/raw/master/img/GS_pyvista.png
+   :width: 400px
+   :align: center
+
+
+Estimating and fitting variograms
+=================================
+
+The spatial structure of a field can be analyzed with the variogram, which contains the same information as the covariance function.
+
+All covariance models can be used to fit given variogram data by a simple interface.
+
+
+Examples
+--------
+
+This is an example of how to estimate the variogram of a 2 dimensional unstructured field and estimate the parameters of the covariance
+model again.
+
+.. code-block:: python
+
+    import numpy as np
+    import gstools as gs
+    # generate a synthetic field with an exponential model
+    x = np.random.RandomState(19970221).rand(1000) * 100.
+    y = np.random.RandomState(20011012).rand(1000) * 100.
+    model = gs.Exponential(dim=2, var=2, len_scale=8)
+    srf = gs.SRF(model, mean=0, seed=19970221)
+    field = srf((x, y))
+    # estimate the variogram of the field
+    bin_center, gamma = gs.vario_estimate((x, y), field)
+    # fit the variogram with a stable model. (no nugget fitted)
+    fit_model = gs.Stable(dim=2)
+    fit_model.fit_variogram(bin_center, gamma, nugget=False)
+    # output
+    ax = fit_model.plot(x_max=max(bin_center))
+    ax.scatter(bin_center, gamma)
+    print(fit_model)
+
+Which gives:
+
+.. code-block:: python
+
+    Stable(dim=2, var=1.85, len_scale=7.42, nugget=0.0, anis=[1.0], angles=[0.0], alpha=1.09)
+
+.. image:: https://raw.githubusercontent.com/GeoStat-Framework/GeoStat-Framework.github.io/master/img/GS_vario_est.png
+   :width: 400px
+   :align: center
+
+
+Kriging and Conditioned Random Fields
+=====================================
+
+An important part of geostatistics is Kriging and conditioning spatial random
+fields to measurements. With conditioned random fields, an ensemble of field realizations
+with their variability depending on the proximity of the measurements can be generated.
+
+
+Example
+-------
+
+For better visualization, we will condition a 1d field to a few "measurements",
+generate 100 realizations and plot them:
+
+.. code-block:: python
+
+    import numpy as np
+    import matplotlib.pyplot as plt
+    import gstools as gs
+
+    # conditions
+    cond_pos = [0.3, 1.9, 1.1, 3.3, 4.7]
+    cond_val = [0.47, 0.56, 0.74, 1.47, 1.74]
+
+    # conditioned spatial random field class
+    model = gs.Gaussian(dim=1, var=0.5, len_scale=2)
+    krige = gs.krige.Ordinary(model, cond_pos, cond_val)
+    cond_srf = gs.CondSRF(krige)
+    # same output positions for all ensemble members
+    grid_pos = np.linspace(0.0, 15.0, 151)
+    cond_srf.set_pos(grid_pos)
+
+    # seeded ensemble generation
+    seed = gs.random.MasterRNG(20170519)
+    for i in range(100):
+        field = cond_srf(seed=seed(), store=f"field_{i}")
+        plt.plot(grid_pos, field, color="k", alpha=0.1)
+    plt.scatter(cond_pos, cond_val, color="k")
+    plt.show()
+
+.. image:: https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/cond_ens.png
+   :width: 600px
+   :align: center
+
+
+User defined covariance models
+==============================
+
+One of the core-features of GSTools is the powerful
+:any:`CovModel`
+class, which allows to easy define covariance models by the user.
+
+
+Example
+-------
+
+Here we re-implement the Gaussian covariance model by defining just the
+`correlation <https://en.wikipedia.org/wiki/Autocovariance#Normalization>`_ function,
+which takes a non-dimensional distance :class:`h = r/l`
+
+.. code-block:: python
+
+    import numpy as np
+    import gstools as gs
+    # use CovModel as the base-class
+    class Gau(gs.CovModel):
+        def cor(self, h):
+            return np.exp(-h**2)
+
+And that's it! With :class:`Gau` you now have a fully working covariance model,
+which you could use for field generation or variogram fitting as shown above.
+
+
+Incompressible Vector Field Generation
+======================================
+
+Using the original `Kraichnan method <https://doi.org/10.1063/1.1692799>`_, incompressible random
+spatial vector fields can be generated.
+
+
+Example
+-------
+
+.. code-block:: python
+
+   import numpy as np
+   import gstools as gs
+   x = np.arange(100)
+   y = np.arange(100)
+   model = gs.Gaussian(dim=2, var=1, len_scale=10)
+   srf = gs.SRF(model, generator='VectorField', seed=19841203)
+   srf((x, y), mesh_type='structured')
+   srf.plot()
+
+yielding
+
+.. image:: https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/vec_srf_tut_gau.png
+   :width: 600px
+   :align: center
+
+
+Plurigaussian Field Simulation (PGS)
+====================================
+
+With PGS, more complex categorical (or discrete) fields can be created.
+
+
+Example
+-------
+
+.. code-block:: python
+
+   import gstools as gs
+   import numpy as np
+   import matplotlib.pyplot as plt
+
+   N = [180, 140]
+
+   x, y = range(N[0]), range(N[1])
+
+   # we need 2 SRFs
+   model = gs.Gaussian(dim=2, var=1, len_scale=5)
+   srf = gs.SRF(model)
+   field1 = srf.structured([x, y], seed=20170519)
+   field2 = srf.structured([x, y], seed=19970221)
+
+   # with `lithotypes`, we prescribe the categorical data and its relations
+   # here, we use 2 categories separated by a rectangle.
+   rect = [40, 32]
+   lithotypes = np.zeros(N)
+   lithotypes[
+       N[0] // 2 - rect[0] // 2 : N[0] // 2 + rect[0] // 2,
+       N[1] // 2 - rect[1] // 2 : N[1] // 2 + rect[1] // 2,
+   ] = 1
+
+   pgs = gs.PGS(2, [field1, field2])
+   P = pgs(lithotypes)
+
+   fig, axs = plt.subplots(1, 2)
+   axs[0].imshow(lithotypes, cmap="copper")
+   axs[1].imshow(P, cmap="copper")
+   plt.show()
+
+.. image:: https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/2d_pgs.png
+   :width: 600px
+   :align: center
+
+
+VTK/PyVista Export
+==================
+
+After you have created a field, you may want to save it to file, so we provide
+a handy `VTK <https://www.vtk.org/>`_ export routine using the :class:`.vtk_export()` or you could
+create a VTK/PyVista dataset for use in Python with to :class:`.to_pyvista()` method:
+
+.. code-block:: python
+
+    import gstools as gs
+    x = y = range(100)
+    model = gs.Gaussian(dim=2, var=1, len_scale=10)
+    srf = gs.SRF(model)
+    srf((x, y), mesh_type='structured')
+    srf.vtk_export("field") # Saves to a VTK file
+    mesh = srf.to_pyvista() # Create a VTK/PyVista dataset in memory
+    mesh.plot()
+
+Which gives a RectilinearGrid VTK file :file:`field.vtr` or creates a PyVista mesh
+in memory for immediate 3D plotting in Python.
+
+.. image:: https://raw.githubusercontent.com/GeoStat-Framework/GSTools/main/docs/source/pics/pyvista_export.png
+   :width: 600px
+   :align: center
+
+
+Requirements
+============
+
+- `NumPy >= 1.20.0 <http://www.numpy.org>`_
+- `SciPy >= 1.1.0 <http://www.scipy.org>`_
+- `hankel >= 1.0.0 <https://github.com/steven-murray/hankel>`_
+- `emcee >= 3.0.0 <https://github.com/dfm/emcee>`_
+- `pyevtk >= 1.1.1 <https://github.com/pyscience-projects/pyevtk>`_
+- `meshio >= 5.1.0 <https://github.com/nschloe/meshio>`_
+
+
+Optional
+--------
+
+- `GSTools-Core >= 0.2.0 <https://github.com/GeoStat-Framework/GSTools-Core>`_
+- `matplotlib <https://matplotlib.org>`_
+- `pyvista <https://docs.pyvista.org>`_
+
+
+Contact
+-------
+
+You can contact us via `info@geostat-framework.org <mailto:info@geostat-framework.org>`_.
+
+
+License
+=======
+
+`LGPLv3 <https://github.com/GeoStat-Framework/GSTools/blob/main/LICENSE>`_
+
+
+.. |GH-Discussions| image:: https://img.shields.io/badge/GitHub-Discussions-f6f8fa?logo=github&style=flat
+    :alt: GH-Discussions
+    :target: https://github.com/GeoStat-Framework/GSTools/discussions
+.. |Email| image:: https://img.shields.io/badge/Email-GeoStat--Framework-468a88?style=flat&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbDpzcGFjZT0icHJlc2VydmUiIHdpZHRoPSI1MDAiIGhlaWdodD0iNTAwIj48cGF0aCBkPSJNNDQ4IDg4SDUyYy0yNyAwLTQ5IDIyLTQ5IDQ5djIyNmMwIDI3IDIyIDQ5IDQ5IDQ5aDM5NmMyNyAwIDQ5LTIyIDQ5LTQ5VjEzN2MwLTI3LTIyLTQ5LTQ5LTQ5em0xNiA0OXYyMjZsLTIgNy0xMTUtMTE2IDExNy0xMTd6TTM2IDM2M1YxMzdsMTE3IDExN0wzOCAzNzBsLTItN3ptMjE5LTYzYy0zIDMtNyAzLTEwIDBMNjYgMTIxaDM2OHptLTc5LTIzIDQ2IDQ2YTM5IDM5IDAgMCAwIDU2IDBsNDYtNDYgMTAxIDEwMkg3NXoiIHN0eWxlPSJmaWxsOiNmNWY1ZjU7ZmlsbC1vcGFjaXR5OjEiLz48L3N2Zz4=
+    :alt: Email
+    :target: mailto:info@geostat-framework.org