def computeMean(self, grid, alpha, newGridPoints): gs = grid.getStorage() opEval = createOperationEval(grid) newGs = grid.getStorage() newNodalValues = dehierarchize(grid, alpha) p = DataVector(gs.dim()) for newGp in newGridPoints: # run over all grid points of current level newGp.getCoords(p) pp = DataVector(p) i = newGs.seq(newGp) newNodalValues[i] = 0. for d in xrange(gs.dim()): # get current index index = newGp.getIndex(d) level = newGp.getLevel(d) # bounds xlow, xhigh = getBoundsOfSupport(level, index) # compute function values at bounds pp[d] = xlow fxlow = opEval.eval(alpha, pp) pp[d] = xhigh fxhigh = opEval.eval(alpha, pp) # interpolate linearly a = (fxhigh - fxlow) / (xlow - xhigh) newNodalValues[i] += a * (p[d] - xlow) + fxhigh # reset pp and set sumWeights pp[d] = p[d] newNodalValues[i] /= gs.dim() return newNodalValues
def computeMean(self, grid, alpha, newGridPoints): gs = grid.getStorage() opEval = createOperationEval(grid) newGs = grid.getStorage() newNodalValues = dehierarchize(grid, alpha) p = DataVector(gs.dim()) for newGp in newGridPoints: # run over all grid points of current level newGp.getCoords(p) pp = DataVector(p) i = newGs.seq(newGp) newNodalValues[i] = 0. for d in xrange(gs.dim()): # get current index index = newGp.getIndex(d) level = newGp.getLevel(d) # bounds xlow, xhigh = getBoundsOfSupport(level, index) # compute function values at bounds pp[d] = xlow fxlow = opEval.eval(alpha, pp) pp[d] = xhigh fxhigh = opEval.eval(alpha, pp) # interpolate linearly a = (fxhigh - fxlow) / (xlow - xhigh) newNodalValues[i] += a * (p[d] - xlow) + fxhigh # reset pp and set sumWeights pp[d] = p[d] newNodalValues[i] /= gs.dim() return newNodalValues
def computeLinearFormEntry(self, gs, gp, basis, d): val = 1 err = 0. # get level index lid, iid = gp.getLevel(d), gp.getIndex(d) # compute left and right boundary of the support of both # basis functions xlow, xhigh = getBoundsOfSupport(gs, lid, iid, self._gridType) xcenter = gs.getCoordinate(gp, d) # ---------------------------------------------------- # use gauss-legendre-quadrature bounds = self._U[d].getBounds() if self._U is None or (isinstance(self._U[d], Uniform) and \ np.abs(bounds[0]) < 1e-14 and \ np.abs(bounds[1] - 1.0) < 1e-14): def f(p): return basis.eval(lid, iid, p) else: def f(p): q = self._T[d].unitToProbabilistic(p) return basis.eval(lid, iid, p) * self._U[d].pdf(q) # compute the piecewise continuous parts separately deg = gp.getLevel(d) + 2 sleft, err1dleft = self.quad(f, xlow, xcenter, deg=deg) sright, err1dright = self.quad(f, xcenter, xhigh, deg=deg) # # ----------------------------------------- # # plot the basis # import numpy as np # import matplotlib.pyplot as plt # x = np.linspace(0, 1, 100) # pdf = [self._U[d].pdf(xi) for xi in x] # plt.plot(x, pdf) # x = np.linspace(xlow, xhigh, 100) # b1 = [basis.eval(lid, iid, xi) for xi in x] # res = [f(xi) for xi in x] # # plt.plot(x, b1) # plt.plot(x, res) # plt.xlim(0, 1) # plt.title("(%i, %i), %g" % (lid, iid, s)) # plt.show() # # ---------------------------------------------------- val = val * (sleft + sright) err += val * (err1dleft + err1dright) return val, err
def computeLinearFormEntry(self, gp, basis, d): val = 1 err = 0. # get level index lid, iid = gp.getLevel(d), gp.getIndex(d) # compute left and right boundary of the support of both # basis functions xlow, xhigh = getBoundsOfSupport(lid, iid) # ---------------------------------------------------- # use gauss-legendre-quadrature if self._U is None: def f(p): return basis.eval(lid, iid, p) else: def f(p): q = self._T[d].unitToProbabilistic(p) return basis.eval(lid, iid, p) * self._U[d].pdf(q) # compute the piecewise continuous parts separately sleft, err1dleft = self.quad(f, xlow, (xlow + xhigh) / 2, deg=gp.getLevel(d) + 2) sright, err1dright = self.quad(f, (xlow + xhigh) / 2, xhigh, deg=gp.getLevel(d) + 2) # # ----------------------------------------- # # plot the basis # import numpy as np # import matplotlib.pyplot as plt # x = np.linspace(0, 1, 100) # pdf = [self._U[d].pdf(xi) for xi in x] # plt.plot(x, pdf) # x = np.linspace(xlow, xhigh, 100) # b1 = [basis.eval(lid, iid, xi) for xi in x] # res = [f(xi) for xi in x] # # plt.plot(x, b1) # plt.plot(x, res) # plt.xlim(0, 1) # plt.title("(%i, %i), %g" % (lid, iid, s)) # plt.show() # # ---------------------------------------------------- val = val * (sleft + sright) err += val * (err1dleft + err1dright) return val, err
def computeLinearFormEntry(self, gp, basis, d): val = 1 err = 0. # get level index lid, iid = gp.getLevel(d), gp.getIndex(d) # compute left and right boundary of the support of both # basis functions xlow, xhigh = getBoundsOfSupport(lid, iid) # ---------------------------------------------------- # use gauss-legendre-quadrature if self._U is None: def f(p): return basis.eval(lid, iid, p) else: def f(p): q = self._T[d].unitToProbabilistic(p) return basis.eval(lid, iid, p) * self._U[d].pdf(q) # compute the piecewise continuous parts separately sleft, err1dleft = self.quad(f, xlow, (xlow + xhigh) / 2, deg=gp.getLevel(d) + 2) sright, err1dright = self.quad(f, (xlow + xhigh) / 2, xhigh, deg=gp.getLevel(d) + 2) # # ----------------------------------------- # # plot the basis # import numpy as np # import matplotlib.pyplot as plt # x = np.linspace(0, 1, 100) # pdf = [self._U[d].pdf(xi) for xi in x] # plt.plot(x, pdf) # x = np.linspace(xlow, xhigh, 100) # b1 = [basis.eval(lid, iid, xi) for xi in x] # res = [f(xi) for xi in x] # # plt.plot(x, b1) # plt.plot(x, res) # plt.xlim(0, 1) # plt.title("(%i, %i), %g" % (lid, iid, s)) # plt.show() # # ---------------------------------------------------- val = val * (sleft + sright) err += val * (err1dleft + err1dright) return val, err
def computeBilinearFormEntry(self, gs, gpi, basisi, gpj, basisj, d): val = 1 err = 0. # get level index lid, iid = gpi.getLevel(d), gpi.getIndex(d) ljd, ijd = gpj.getLevel(d), gpj.getIndex(d) # compute left and right boundary of the support of both # basis functions xlowi, xhighi = getBoundsOfSupport(gs, lid, iid, self._gridType) xlowj, xhighj = getBoundsOfSupport(gs, ljd, ijd, self._gridType) xlow = max(xlowi, xlowj) xhigh = min(xhighi, xhighj) # same level, different index if self._gridType not in bsplineGridTypes and lid == ljd and iid != ijd and lid > 0: val = err = 0 # the support does not overlap elif self._gridType not in bsplineGridTypes and lid != ljd and xlow >= xhigh: val = err = 0 else: # ---------------------------------------------------- # use scipy for integration bounds = self._U[d].getBounds() if self._U is None or (isinstance(self._U[d], Uniform) and \ np.abs(bounds[0]) < 1e-14 and \ np.abs(bounds[1] - 1.0) < 1e-14): def f(p): return basisi.eval(lid, iid, p) * \ basisj.eval(ljd, ijd, p) else: def f(p): q = self._T[d].unitToProbabilistic(p) return basisi.eval(lid, iid, p) * \ basisj.eval(ljd, ijd, p) * \ self._U[d].pdf(q) # compute the piecewise continuous parts separately if lid > ljd: xcenter = gs.getCoordinate(gpi, d) else: xcenter = gs.getCoordinate(gpj, d) deg = 2 * (lid + 1) + 1 sleft, err1dleft = self.quad(f, xlow, xcenter, deg=deg) sright, err1dright = self.quad(f, xcenter, xhigh, deg=deg) val = val * (sleft + sright) err += val * (err1dleft + err1dright) # # ----------------------------------------- # # plot the basis # import numpy as np # import matplotlib.pyplot as plt # x = np.linspace(0, 1, 100) # b1 = [basisi.eval(lid, iid, xi) for xi in x] # b2 = [basisj.eval(ljd, ijd, xi) for xi in x] # pdf = [self._U[d].pdf(self._T[d].unitToProbabilistic(xi)) # for xi in x] # res = [f(xi) for xi in x] # # plt.plot(x, b1, label="basis 1") # plt.plot(x, b2, label="basis 2") # plt.plot(x, pdf, label="pdf") # plt.plot(x, res, label="product") # plt.scatter(xcenter, 0.0) # plt.xlim(0, 1) # plt.title("[%i, %i] -> (%i, %i), (%i, %i), %g" % (xlow, xhigh, lid, iid, ljd, ijd, val)) # plt.legend() # plt.show() # # ---------------------------------------------------- return val, err
def computeBilinearFormEntry(self, gpi, basisi, gpj, basisj, d): val = 1 err = 0. # get level index lid, iid = gpi.getLevel(d), gpi.getIndex(d) ljd, ijd = gpj.getLevel(d), gpj.getIndex(d) # compute left and right boundary of the support of both # basis functions xlowi, xhighi = getBoundsOfSupport(lid, iid) xlowj, xhighj = getBoundsOfSupport(ljd, ijd) xlow = max(xlowi, xlowj) xhigh = min(xhighi, xhighj) # same level, different index if lid == ljd and iid != ijd and lid > 0: val = err = 0 # the support does not overlap elif lid != ljd and xlow >= xhigh: val = err = 0 else: # ---------------------------------------------------- # use scipy for integration if self._U is None: def f(p): return basisi.eval(lid, iid, p) * \ basisj.eval(ljd, ijd, p) else: def f(p): q = self._T[d].unitToProbabilistic(p) return basisi.eval(lid, iid, p) * \ basisj.eval(ljd, ijd, p) * \ self._U[d].pdf(q) # compute the piecewise continuous parts separately sleft, err1dleft = self.quad(f, xlow, (xlow + xhigh) / 2, deg=2 * (gpi.getLevel(d) + 1) + 1) sright, err1dright = self.quad(f, (xlow + xhigh) / 2, xhigh, deg=2 * (gpi.getLevel(d) + 1) + 1) # # ----------------------------------------- # # plot the basis # import numpy as np # import matplotlib.pyplot as plt # x = np.linspace(0, 1, 100) # b1 = [basisi.eval(lid, iid, xi) for xi in x] # b2 = [basisj.eval(ljd, ijd, xi) for xi in x] # pdf = [self._U[d].pdf(self._T[d].unitToProbabilistic(xi)) # for xi in x] # res = [f(xi) for xi in x] # # plt.plot(x, b1, label="basis 1") # plt.plot(x, b2, label="basis 2") # plt.plot(x, pdf, label="pdf") # plt.plot(x, res, label="product") # plt.xlim(0, 1) # plt.title("[%i, %i] -> (%i, %i), (%i, %i), %g" % (xlow, xhigh, lid, iid, ljd, ijd, s)) # plt.legend() # plt.show() # # ---------------------------------------------------- val = val * (sleft + sright) err += val * (err1dleft + err1dright) return val, err