""" Define Poisson problem """

from dolfin import *
from ..tools import AdaptableLinearProblem, LinearPDE, poisson_indicator
from .params_physical import *

parameters["allow_extrapolation"] = True
parameters["refinement_algorithm"] = "plaza_with_parent_facets"

__all__ = ["PoissonProblem", "Poisson", "PoissonProblemAxisym", "PoissonProblemPureNeumannAxisym"]

class PoissonProblem(AdaptableLinearProblem):
    k = 1
    
    method = dict(
        reuse = True,
        iterative = True,
        lusolver = ("superlu_dist" if has_lu_solver_method("superlu_dist") else "default"),
        luparams = dict(
            symmetric = True,
            same_nonzero_pattern = True,
            reuse_factorization = True,),
        ks = "cg",
        kp = "amg",
        kparams = dict(
            maximum_iterations = 200,
            monitor_convergence = False,
            relative_tolerance = 1e-4,
            error_on_nonconvergence = False,
            preconditioner = dict(
                ilu = dict(fill_level = 1)))
    )

    @staticmethod
    def space(mesh):
        return FunctionSpace(mesh, 'CG', PoissonProblem.k)

    @staticmethod
    def forms(V, geo, f):
        u = TrialFunction(V)
        v = TestFunction(V)
        dx = geo.dx()
        grad = geo.physics.grad
        lscale = geo.physics.lscale
        
        eps = geo.pwconst('permittivity')           
        a = inner(eps*grad(u), grad(v))*dx
        L = f*v*dx + geo.linearRHS(v, "volcharge") + lscale*geo.NeumannRHS(v, "surfcharge")
        
        return (a, L)
    
    def __init__(self, geo, phys=None, bcs=None, f=None, u=None):
        mesh = geo.mesh
        V = self.space(mesh)
        C0 = Constant(0.0)
        
        if f is None:
            f = C0
        if u is None:
            u = Function(V)
        if bcs is None:
            try:
                if phys.bV is None:
                    bcs = [geo.BC(V, C0, "ground")]
                else:
                    bcs = [geo.BC(V, phys.bV, "bV"),
                           geo.BC(V, C0, "ground")]
            except:
                warning("No boundary conditions have been assigned to %s" %type(self).__name__)

        a, L = self.forms(V, geo, f)

        AdaptableLinearProblem.__init__(self, a, L, u, bcs, geo.boundaries)

        
class PoissonProblemPureNeumannAxisym(PoissonProblem):
    
    method = PoissonProblem.method
    method["ks"] = "bicgstab"
    
    @staticmethod
    def space(mesh):
        V = FunctionSpace(mesh, "CG", PoissonProblemPureNeumannAxisym.k)
        R = FunctionSpace(mesh, "R", 0)
        return V * R
    
    @staticmethod
    def forms(V, geo, f):
        (u,b) = TrialFunctions(V)
        (v,c) = TestFunctions(V)
        dx = geo.dx()
        grad = geo.physics.grad
        lscale = geo.physics.lscale
        
        r = Expression("2*pi*x[0]")
        eps = geo.pwconst('permittivity')           
        a = inner(eps*grad(u), grad(v))*r*dx + (b*v + c*u)*r*dx
        
        L = f*v*r*dx + geo.linearRHS(v*r, "volcharge")
        L = L + lscale*geo.NeumannRHS(v*r, "surfcharge")
        
        return (a, L)
        
class PoissonProblemAxisym(PoissonProblem):
    
    @staticmethod
    def forms(V, geo, f):
        u = TrialFunction(V)
        v = TestFunction(V)
        dx = geo.dx()
        grad = geo.physics.grad
        lscale = geo.physics.lscale
        
        r = Expression("2*pi*x[0]")
        eps = geo.pwconst('permittivity')           
        a = inner(eps*grad(u), grad(v))*r*dx
        
        L = f*v*r*dx + geo.linearRHS(v*r, "volcharge")
        L = L + lscale*geo.NeumannRHS(v*r, "surfcharge")
        
        return (a, L)
        
        
class Poisson(LinearPDE):
    def __init__(self, geo, **params):
        LinearPDE.__init__(self, geo, PoissonProblem, **params)
    def estimate(self):
        return poisson_indicator(self.geo, self.functions.values()[0])