def __init__(self, target_eigenvalue, init_state_vect, dgl_coefficients, domain):
if not all([isinstance(state, (int, float, long)) for state in init_state_vect]) \
and len(init_state_vect) == 4 and isinstance(init_state_vect, (list, tuple)):
raise TypeError
if not len(dgl_coefficients) == 3 and isinstance(dgl_coefficients, (list, tuple)) \
and all([callable(coef) or isinstance(coef, (int, float, long)) for coef in dgl_coefficients]):
raise TypeError
if not isinstance(domain, (np.ndarray, list)) \
or not all([isinstance(num, (int, long, float)) for num in domain]):
raise TypeError
if isinstance(target_eigenvalue, complex):
self._eig_val_real = target_eigenvalue.real
self._eig_val_imag = target_eigenvalue.imag
elif isinstance(target_eigenvalue, (int, long, float)):
self._eig_val_real = target_eigenvalue
self._eig_val_imag = 0.
else:
raise TypeError
self._init_state_vect = init_state_vect
self._a2, self._a1, self._a0 = [ut._convert_to_function(coef) for coef in dgl_coefficients]
self._domain = domain
state_vect = self._transform_eigenfunction()
self._transf_eig_func_real, self._transf_d_eig_func_real = state_vect[0:2]
self._transf_eig_func_imag, self._transf_d_eig_func_imag = state_vect[2:4]
Function.__init__(self, self._phi, nonzero=(domain[0], domain[-1]), derivative_handles=[self._d_phi])
def transform2intermediate(param, d_end=None):
"""
Transformation which eliminate the advection term 'a1 x(z,t)' from the
reaction-advection-diffusion equation
d/dt x(z,t) = a2 x''(z,t) + a1(z) x'(z,t) + a0(z) x(z,t)
with robin
x'(0,t) = alpha x(0,t), x'(l,t) = -beta x(l,t)
or dirichlet
x(0,t) = 0, x(l,t) = 0
or mixed boundary condition.
"""
if not isinstance(param, (tuple, list)) or not len(param) == 5:
raise TypeError("pyinduct.utils.transform_2_intermediate(): argument param must from type tuple or list")
a2, a1, a0, alpha, beta = param
if callable(a1) or callable(a0):
if not len(a1._derivative_handles) >= 1:
raise TypeError
a0_z = ut._convert_to_function(a0)
a0_n = lambda z: a0_z(z) - a1(z)**2/4/a2 - a1.derive(1)(z)/2
else:
a0_n = a0 - a1**2/4/a2
if alpha is None:
alpha_n = None
elif callable(a1):
alpha_n = a1(0) / 2. / a2 + alpha
else:
alpha_n = a1 / 2. / a2 + alpha
if beta is None:
beta_n = None
elif callable(a1):
beta_n = -a1(d_end) / 2. / a2 + beta
else:
beta_n = -a1 / 2. / a2 + beta
a2_n = a2
a1_n = 0
return a2_n, a1_n, a0_n, alpha_n, beta_n
