Пример #1
0
class V_TV():
    """ Definite Vectorial Total Variation regularization from Total Variation class """
    def __init__(self, Vm, parameters=[]):
        """ Vm = FunctionSpace for the parameters m1, and m2 """
        self.parameters = {}
        self.parameters['k'] = 1.0
        self.parameters['eps'] = 1e-2
        self.parameters['amg'] = 'default'
        self.parameters['nb_param'] = 2
        self.parameters['use_i'] = False
        self.parameters['print'] = False
        self.parameters.update(parameters)

        n = self.parameters['nb_param']
        use_i = self.parameters['use_i']
        assert not ((not use_i) * (n > 2))

        if not use_i:
            VmVm = createMixedFS(Vm, Vm)
        else:
            if self.parameters['print']:
                print '[V_TV] Using createMixedFSi'
            Vms = []
            for ii in range(n):
                Vms.append(Vm)
            VmVm = createMixedFSi(Vms)
        self.parameters['Vm'] = VmVm

        self.regTV = TV(self.parameters)

        if not use_i:
            self.m1, self.m2 = Function(Vm), Function(Vm)
            self.m = Function(VmVm)

    def isTV(self):
        return True

    def isPD(self):
        return False

    def costab(self, m1, m2):
        assign(self.m.sub(0), m1)
        assign(self.m.sub(1), m2)
        return self.regTV.cost(self.m)

    def costabvect(self, m1, m2):
        setfct(self.m1, m1)
        setfct(self.m2, m2)
        return self.costab(self.m1, self.m2)

    def costabvecti(self, m):
        return self.regTV.cost(m)

    def gradab(self, m1, m2):
        assign(self.m.sub(0), m1)
        assign(self.m.sub(1), m2)
        return self.regTV.grad(self.m)

    def gradabvect(self, m1, m2):
        setfct(self.m1, m1)
        setfct(self.m2, m2)
        return self.gradab(self.m1, self.m2)

    def gradabvecti(self, m):
        return self.regTV.grad(m)

    def assemble_hessianab(self, m1, m2):
        setfct(self.m1, m1)
        setfct(self.m2, m2)
        assign(self.m.sub(0), self.m1)
        assign(self.m.sub(1), self.m2)
        self.regTV.assemble_hessian(self.m)

    def assemble_hessianabi(self, m):
        self.regTV.assemble_hessian(m)

    def hessianab(self, m1h, m2h):
        """ m1h, m2h = Vector(V) """
        setfct(self.m1, m1h)
        setfct(self.m2, m2h)
        assign(self.m.sub(0), self.m1)
        assign(self.m.sub(1), self.m2)
        return self.regTV.hessian(self.m.vector())

    def hessianabi(self, mh):
        return self.regTV.hessian(mh)

    def getprecond(self):
        return self.regTV.getprecond()