Is there a method to extract the components of the gradient when constructing a PDE?

[lcx366]

Is there a method for this package to extract the components of the gradient when constructing equations with PDE class, such as eq = PDE({'u':"-gradient_x(u))"})? I did not find a direct way to implement it in the document. Can you add a similar function?

[david-zwicker]

There currently is no direct method to access vector (or tensor) components. However, the master branch now has code which allows you to use a user-defined function. You could thus achieve what you want using

eq = PDE({"u": "-get_x(gradient(u))"}, user_funcs={"get_x": lambda arr: arr[0]})

Here, get_x is a simple function that extracts the first component of a vector. This is also illustrated in a new example. This variant has the disadvantage that first the full gradient is calculated and then only the first component is used.

Alternatively, you may also register your own operator that only evaluates the x-derivative:

import functools
from pde.grids.operators.cartesian import _make_derivative

make_gradient_x = functools.partial(_make_derivative, axis=0)
pde.CartesianGrid.register_operator('gradient_x', make_gradient_x)

If you do this, your original idea should work.

[Divyoj-Singh]

Can we do the same for custom pde class also ??
if I register my own operator using functools, I am not able to use it in the pde class method,

import numba as nb
import numpy as np
import pde
import math as math
from pde import FieldCollection, PDEBase, PlotTracker, ScalarField, UnitGrid
import functools
from pde.grids.operators.cartesian import _make_derivative
from pde.grids.cartesian import CartesianGridBase

make_gradient_z = functools.partial(_make_derivative, axis=2)
CartesianGridBase.register_operator('gradient_z', make_gradient_z)

class polarityPDE(PDEBase):
    def __init__(self, bc=["periodic","periodic",'periodic']):
    self.bc = bc  # boundary condition
        
    def get_initial_state(self, grid):
        """ preparing initial state """
        a = ScalarField(grid, 0.01, label="Field $a$")
        return a
    def evolution_rate(self, state, t=0):
        """ python implementation of the PDE """
        a=state
        rhs = state.copy()
        gradient_a= a.gradient_z(bc="periodic")
        diffusion_a= gradient_a.gradient_z(bc="periodic")
        rhs = diffusion_a
        return rhs

T = 500.0;
L=2;

grid = pde.CartesianGrid([[0,L], [0, L],[0,2*math.pi]], [30, 30, 50],[True,True,True])  # generate grid
eq = polarityPDE()
state = eq.get_initial_state(grid)
# simulate the pde
sol = eq.solve(state, t_range=T)

When I tried this, I get the following error:
'ScalarField' object has no attribute 'gradient_z'

[david-zwicker]

This is not supported yet, but I'm happy to look at pull requests in this direction.