def __init__(self, f, s, a=0, b=1, d=1): self.d = d super(self.__class__, self).__init__(f, s, a, b) from error_functionals import TwoNormOrth self.errorClass = TwoNormOrth(self.f)
class Greedy(Algo): def __init__(self, f, s, a=0, b=1, d=1): self.d = d super(self.__class__, self).__init__(f, s, a, b) from error_functionals import TwoNormOrth self.errorClass = TwoNormOrth(self.f) def current_dof(self): return self.d * len(self.tree.leaves()) def needsSubdivide(self, leaf): return True def value(self, node, d=False): if d == False: d = self.d v = node.value(), node.extra_info() if v[0] > -1.0: return v return self.errorClass.error(node.boundary(), d) def error(self, node, d=False): return self.value(node, d)
def __init__(self, f, s, a=0, b=1): self.f = f self.s = s self.tree = t(-1, a, b) self.tree_hp = Tree_1D_hp(-1, a, b) self.error_list = [] self.dof_list = [] from error_functionals import TwoNormOrth self.errorClass = TwoNormOrth(self.f)
class Binev2013(Binev): def __init__(self, f, s, a=0, b=1): self.f = f self.s = s self.tree = t(-1, a, b) self.tree_hp = Tree_1D_hp(-1, a, b) self.error_list = [] self.dof_list = [] from error_functionals import TwoNormOrth self.errorClass = TwoNormOrth(self.f) def plot(self): l = self.tree_hp.leaves() dof = 0 for leaf in l: dof = dof + leaf._p print leaf._p, leaf.boundary(), leaf.error() print dof, self.tree_hp.sum_of_leaves() plotfunc(self.f, *self.tree.boundary()) plottree(self.tree_hp) plt.show() TreeGrapher([self.tree_hp], "tree_hp.pdf", unique=False, debug=True).graph() TreeGrapher([self.tree], "tree.pdf", unique=False, debug=True).graph() def iteration(self): sorter = self.s() T = deepcopy(self.tree) for n in self.tree.leaves(): self.__etilde(n, self.__etilde_h(n)) b = T.branches() for n in b: p = self._p(n) e_p, info = self._e_p(n) E_hp = self._E_hp(n, T) if e_p < E_hp: n.error(e_p) n.extra_info(dict(n.extra_info().items() + info.items())) n.trim() for l in self.tree.node(*n.boundary()).leaves(): self.__etilde(l, self.__etilde(l) * e_p / E_hp) self.tree_hp = self._T_hp(T) sorter.add(self.tree.leaves()) bests = sorter.find() return bests # halfway Binev 2013 page 15 def _p(self, node): n = self.tree.node(*node.boundary()) return len(n.leaves()) def _T_hp(self, tree): if not tree.root().hasSameBoundary(self.tree.root()): raise StandardError("Illegal operation! Roots do not coincide") return False T_hp = deepcopy(tree) T_hp.transformTo(Tree_1D_hp) for l in tree.leaves(): T_hp.node(*l.boundary()).p(self._p(l)) T_hp.node(*l.boundary()).error(l.error()) return T_hp # TODO: improve this # TODO: definition of node is shadowed by local var? is this even the correct definition? def _E_hp(self, node, T): leaves = self.tree.leaves() for node in T.leaves(): isleaf = False for leaf in leaves: if np.allclose(node.boundary(), leaf.boundary()): isleaf = True break if not isleaf and node in leaves: leaves.remove(node) # leaves is now sanitized s = 0.0 for n in leaves: e, i = self._e_p(n) s = s + e return s def _e_p(self, node): p = self._p(node) e, info = self.errorClass.error(node.boundary(), p) return e, info def __etilde_h(self, node): e1 = self.error(node, 1) if not node.hasParent(): return e1 # see Binev 2013 page 15 return 1 / (1 / e1 + 1 / self.__etilde_h(node.getParent())) def __etilde(self, node, val=False): if val != False: node.value(val) return node.extra_info_index("etilde", val) def value(self, node, d=False): if d != False: raise TypeError("Argument invalid!") return False return self.__etilde(node), {} def current_dof(self): return sum([l._p for l in self.tree_hp.leaves()]) def current_error(self): return self.tree_hp.sum_of_leaves() def needsSubdivide(self, leaf): return True