Numerical library for nonlinear diffusion problems based on the Boltzmann transformation.
Project description
Fronts is a Python numerical library for nonlinear diffusion problems based on the Boltzmann transformation.
Python 3.8.3 (default, May 15 2020, 14:39:37) >>> import fronts >>> θ = fronts.solve(D="exp(7*θ)/2", i=0, b=1) # i: initial value, b: boundary value >>> θ(r=10, t=3) 0.9169685387070694 >>> θ.d_dr(10,3) # ∂θ/∂r 0.01108790437249313 >>> print("Welcome to the Fronts project page.")
Overview
With Fronts, you can effortlessly find solutions to many problems of nonlinear diffusion along a semiinfinite axis r, i.e.:
where D is a known positive function and θ is an unkown function of r and t.
Fronts includes functionality to solve problems with a Dirichlet boundary condition (start with fronts.solve()
), as well as some radial problems with a fixedflowrate boundary condition (with fronts.solve_flowrate()
). In every case, D can be any function defined by the user or obtained from the fronts.D
module.
It works by transforming the above nonlinear partial differential equation (PDE) into a more manageable (but still nonlinear) ordinary differential equation (ODE), using a technique known as the Boltzmann transformation, which it then solves with a combination of highorder numerical ODE integration (provided by the SciPy library) and specialized logic.
For this class of problems, you will find that Fronts can be easier to use, faster, and more robust than the classical numerical PDE solvers you would otherwise have to use. Moreover, the solutions found by Fronts are such that their partial derivatives and flux fields are also available in continuous form. Finally, a considerable effort has been made to have Fronts "just work" in practice, with no adjustment of numerical parameters required (in fact, the functions mentioned so far do not even require a starting mesh).
Fronts can also help you solve the inverse problem of finding D when θ is given. Every feature of Fronts is covered in the documentation, and the project includes many example cases (though you may start with the Usage section below).
Fronts is open source and works great with the tools of the SciPy ecosystem.
Why Fronts?
Problems compatible with Fronts appear in many areas of physics. For instance, if we take θ as the water content or saturation and D as the moisture diffusivity, the above equation translates into what is known as the moisture diffusivity equation, which is a special case of the Richards equation that describes capillary flow in porous media. For this application, Fronts even includes implementations of the commonly used models: fronts.D.brooks_and_corey()
and fronts.D.van_genuchten()
.
Of particular interest to the creators of Fronts is the fact that it can be used to model the configuration known as "lateral flow" in the field of paperbased microfluidics. The name "Fronts" is a reference to the wetting fronts that appear under these conditions, the study of which motivated the creation of this software.
Other problems of this class appear in the study of the diffusion of solutions in polymer matrices as well as diffusion problems in solids (e.g. annealing problems in metallurgy).
As mentioned before, if your problem is supported, you can expect Fronts to be easier to use, faster, and more robust than other tools. Try it out!
Installation
Fronts runs on Python 3.5 and later, as well as the older Python 2.7. If you can choose, Python 3 is recommended.
Install Fronts with pip by running this command in a terminal:
$ pip3 install fronts
This will download and install the most recent version of Fronts available on PyPI. To install on Python 2.7, replace pip3
with pip
.
Optional: Matplotlib
Running the bundled examples requires the visualization library Matplotlib. This library is not installed automatically with Fronts, so if you don't already have it, you may want to install it manually by running:
$ pip3 install matplotlib
Optionally, Fronts can be installed in a virtual environment, or the user
option can be added to the previous commands to install the packages for the current user only (which does not require system administrator privileges).
Usage
Let's say we want to solve the following initialboundary value problem:
Find c such that:
With Fronts, all it takes is a call to fronts.solve()
. The function requires the diffusivity function D
, which we pass as an expression so that solve()
can get the derivatives it needs by itself (alternatively, in this case we could also have used fronts.D.power_law()
to obtain D
). Besides D
, we only need to pass the initial and boundary values as i
and b
. The Python code is:
import fronts c = fronts.solve(D="c**4", i=0.1, b=1)
The call to solve()
finishes within a fraction of a second. c
is assigned a Solution
object, which can be called directly but also has some interesting methods such as d_dr()
, d_dt()
and flux()
.
We can now plot the solution for arbitrary r and t. For example, with r between 0 and 10 and t=60:
import numpy as np import matplotlib.pyplot as plt r = np.linspace(0, 10, 200) plt.plot(r, c(r, t=60)) plt.xlabel("r") plt.ylabel("c") plt.show()
The plot looks like this:
Finally, let us plot the flux at t=60:
plt.plot(r, c.flux(r, t=60)) plt.xlabel("r") plt.ylabel("flux") plt.show()
Project links
Authors
 Gabriel S. Gerlero @gerlero
 Pablo A. Kler @pabloakler
 Claudio L. A. Berli
Fronts was conceived and is developed by members of the Santa Fe Microfluidics Group (GSaM) at the Research Center for Computational Methods (CIMEC, UNLCONICET) and the Institute of Technological Development for the Chemical Industry (INTEC, UNLCONICET) in Santa Fe, Argentina.
License
Fronts is opensource software available under the BSD 3clause license.
Project details
Release history Release notifications  RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Filename, size  File type  Python version  Upload date  Hashes 

Filename, size fronts0.9.10.tar.gz (560.0 kB)  File type Source  Python version None  Upload date  Hashes View 
Filename, size fronts0.9.10py2.py3noneany.whl (29.8 kB)  File type Wheel  Python version py2.py3  Upload date  Hashes View 
Hashes for fronts0.9.10py2.py3noneany.whl
Algorithm  Hash digest  

SHA256  5678d2296b35e2f8c751e486df9bbd55e5a7bc6ac0f7370452559ee7a841829a 

MD5  b713ef0bc7b6d1cb12d1e1cb79c30fe3 

BLAKE2256  54701b73d732dc30bb162a7279f9a6c973b261843ade21ad5bcc0b3130c6d7fd 