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