uit-cosmo / blobmodel Goto Github PK

View Code? Open in Web Editor NEW

5.0 1.0 2.0 51.01 MB

Model of propagating blobs in 1D and 2D

Home Page: https://blobmodel.readthedocs.io

License: MIT License

Python 100.00%

fusion modelling-tool stochastic-process turbulence plasma python science

blobmodel's Introduction

blobmodel

This package provides realizations of advecting and dissipating blobs in up to two dimensions.

All blob parameters can be choosen freely, and multiple blob shapes are implemented. Originally, the model is developed for studying the scrape-off layer of fusion experiments, but it can be applicable to many 1d or 2d systems. See the blobmodel documentation for further details.

Examples for one and two dimensions are shown below:

1D	2D

Installation

The package is published to PyPI and can be installed with

pip install blobmodel

If you want the development version you must first clone the repo to your local machine, then install the project in development mode:

git clone https://github.com/uit-cosmo/blobmodel.git
cd blobmodel
python -m pip install -e .

Usage

Create a grid on which the blobs are discretized using the Model class. The make_realization() method computes the output as an xarray dataset which can also be written out as a netcdf file if the argument file_name is specified. A simple example is shown below:

from blobmodel import Model, show_model

bm = Model(Nx=200, Ny=100, Lx=10, Ly=10, dt=0.1, T=20, blob_shape='gauss',num_blobs=100)

ds = bm.make_realization(file_name="example.nc")

The data can be shown as an animation using the show_model function:

show_model(ds)

You can specify the blob parameters with a BlobFactory class. The DefaultBlobFactory class has some of the most common distribution functions implemented. An example would look like this:

from blobmodel import Model, DefaultBlobFactory

# use DefaultBlobFactory to define distribution functions of random variables
bf = DefaultBlobFactory(A_dist="exp", wx_dist="uniform", vx_dist="deg", vy_dist="normal")

# pass on bf when creating the Model
tmp = Model(
    Nx=100,
    Ny=1,
    Lx=10,
    Ly=0,
    dt=1,
    T=1000,
    blob_shape="exp",
    t_drain=2,
    periodic_y=False,
    num_blobs=10000,
    blob_factory=bf,
)

Alternatively, you can specify all blob parameters exactly as you want by writing your own class which inherits from BlobFactory. See examples/custom_blobfactory.py as an example or take a look at the blobmodel documentation.

Contributing

Feel free to raise issues about anything. Contributions through pull requests are also very welcome. Please take a look at our Contributor guide for further details.

blobmodel's People

Contributors

Stargazers

Watchers

Forkers

gregordecristoforo ema109

blobmodel's Issues

Normalize pulse shapes so that integral is 1 (except of dipole)

Blob throws TypeError

I think the following code should run

`
blob_sp = Blob(
blob_id=0,
blob_shape=BlobShapeImpl("gauss"),
amplitude=1,
width_prop=1,
width_perp=1,
velocity_x=1,
velocity_y=1,
pos_x=0,
pos_y=6,
t_init=0,
t_drain=10**100)

x = 0
y = 0
times = np.arange(1, 5, 0.01)

mesh_x, mesh_y, mesh_t = np.meshgrid(x, y, times)
blob_values = blob_sp.discretize_blob(
x=mesh_x, y=mesh_y, t=mesh_t, periodic_y=True, Ly=10)
`

However, it Throws TypeError. It can be fixed by adding .astype(float) on the drain function of Blob, but I am not sure why it throws here and not in the regular use case.

Add user defined geometry.

I have a use case where I want to have closely spaced probes, but I don't want these to cover all the domain, as that would slow down the simulation drastically. Therefore, I propose adding the possibility of user defined grids. As it is now, the only possible grid will cover the simulation domain uniformly, the change will allow the user to specify any grid (in my use case, that would be a grid containing a few close points, and otherwise empty).

Allow for different pulse shapes in the perp and parallel direction.

The pulse shape should be the product of a perp pulse shape and a parallel pulse shape. These should be set independently. The respective width random variables should also be independent.

Some reqs missing

When cloning and pip installing the requirements I get the following missing modules for examples/analyse_output.py.

ModuleNotFoundError: No module named 'netCDF4'
ModuleNotFoundError: No module named 'scipy'

Not sure if this is expected

add type hints

@gregordecristoforo implement type hints

GPU implementation of integrate()

@sajidah-ahmed Since you have experience with cupy you could write a GPU implementation for Model.make_signal()

tilted blobs

Implement tilted blob propagation so that blob front is perpendicular to the propagation direction.

Maybe specify v_total and angle for each blob instead of v_x and v_y

Add doc generation checks

Once the docs are merged to main we should check for every PR whether the docs are passing.

Fix failing mypy checks

as of Sep. 19 the mypy checks in the CI are suddenly failing

seed blobs at x < 0

Seed blobs at negative x so that discontinuities can be neglected.

add potential as variable

Add potential as variable to the model so that consistent density n and potential phi can be written out.

Can be used for ExB velocity estimations

Add dipole pulse shape to documentation

error as parameter for speedup

make error as input parameter for speedup option instead of truncation_Lx

Encapsulate geometry

This is just a design issue.
Grid initialization and possibly also boundary conditions should be relegated to its own class. This will improve encapsulation and flexibility. This is in line with the single-responsibility principle https://en.wikipedia.org/wiki/Single-responsibility_principle

Helper classes should also be implemented to preserved ease of use: default simulations can now be implemented in three lines of user code and should still be so after the refactor.

Model fails for periodicity == True and blob._vy == 0

Write random blob parameters to log file

Use python logging https://docs.python.org/3/howto/logging.html to write out blob parameters to log file

Encapsulate stochasticity

This is just a design issue.
Stochasticity -all random variables- should be relegated to its own class. This will improve encapsulation and flexibility. This is in line with the single-responsibility principle https://en.wikipedia.org/wiki/Single-responsibility_principle