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
