def plotDebugIntersections(self, newGrid, overlappingGridPoints): # ----------------------------------------------------------------- # plot result gs = newGrid.getStorage() for n, ((i, j), (gpi, gpj)) in enumerate(overlappingGridPoints.items()): fig = plt.figure() for k in range(gs.getSize()): gp = gs.getPoint(k) x, y = gp.getStandardCoordinate(0), gp.getStandardCoordinate(1) if alpha[k] < 0.0: plt.plot(x, y, "v ", color="red") else: plt.plot(x, y, "^ ", color="white") # annotate the plt.annotate( str(i), (gpi.getStandardCoordinate(0), gpi.getStandardCoordinate(1))) plt.annotate( str(j), (gpj.getStandardCoordinate(0), gpj.getStandardCoordinate(1))) # draw support # get level index for gp, col in ((gpi, "b"), (gpj, "r")): l0, i0, l1, i1 = gp.getLevel(0), gp.getIndex(0), gp.getLevel( 1), gp.getIndex(1) xlim0, xlim1 = getBoundsOfSupport(l0, i0), getBoundsOfSupport( l1, i1) diff0, diff1 = xlim0[1] - xlim0[0], xlim1[1] - xlim1[0] currentAxis = plt.gca() currentAxis.add_patch( Rectangle((xlim0[0], xlim1[0]), diff0, diff1, facecolor=col, alpha=0.5)) xlim = self.computeBoundsOfOverlappingPatch(gpi, gpj) currentAxis = plt.gca() currentAxis.add_patch( Rectangle((xlim[0, 0], xlim[1, 0]), np.diff(xlim[0, :2]), np.diff(xlim[1, :2]), facecolor="gray", alpha=0.9)) gp = self.findIntersection(gpi, gpj) plt.plot(gp.getStandardCoordinate(0), gp.getStandardCoordinate(1), "o ", color="black") plt.title("%i/%i" % (n + 1, len(overlappingGridPoints))) plt.xlim(0, 1) plt.ylim(0, 1) plt.show() plt.close(fig)
def findIntersectionsOfOverlappingSuppportsForOneGridPoint( self, i, gpi, gpsj, overlap, grid, alpha): numDims = gpi.getDimension() gs = grid.getStorage() gpintersection = HashGridPoint(self.numDims) # find all possible intersections of grid points comparisonCosts = fullGridCosts = 0 for j, gpj in list(gpsj.items()): comparisonCosts += 1 idim = 0 ranges = [] while idim < numDims: # get level index lid, iid = gpi.getLevel(idim), gpi.getIndex(idim) ljd, ijd = gpj.getLevel(idim), gpj.getIndex(idim) # check if they have overlapping support xlowi, xhighi = getBoundsOfSupport(lid, iid) xlowj, xhighj = getBoundsOfSupport(ljd, ijd) xlow = max(xlowi, xlowj) xhigh = min(xhighi, xhighj) # different level but not ancestors if xlow >= xhigh: break else: ranges.append([xlow, xhigh]) idim += 1 # check whether the supports are overlapping # in all dimensions if idim == numDims: ancestors_gpj = [(0, gpj)] + getHierarchicalAncestors( grid, gpj) for _, ancestor_gpj in ancestors_gpj: fullGridCosts += 1 level, index = self.findIntersection(gpi, ancestor_gpj) gpintersection = HashGridPoint(self.numDims) for idim in range(self.numDims): gpintersection.set(idim, level[idim], index[idim]) if not gs.isContaining(gpintersection): if self.plot and self.numDims == 2: self.plotDebug(grid, alpha, {1: gpintersection}, gpi, gpj, overlap) overlap[level, index] = gpintersection return comparisonCosts, fullGridCosts
def computeBilinearFormEntry(self, gs, gpi, basisi, gpj, basisj, d): # if not, compute it val = 1 err = 0. # run over all dimensions d = 0 while d < gpi.getDimension() and abs(val) > 1e-15: # 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) xlowj, xhighj = getBoundsOfSupport(gs, 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 def f(p): return basisi.eval(lid, iid, p) * \ basisj.eval(ljd, ijd, p) s, err1d = quad(f, xlow, xhigh, epsabs=1e-8) # ---------------------------------------------------- val *= s err += err1d d += 1 return val, err
def computeTrilinearFormEntry(self, gs, gpk, basisk, gpi, basisi, gpj, basisj, d): val = 1 err = 0. # get level index lkd, ikd = gpk.getLevel(d), gpk.getIndex(d) 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 all # three basis functions xlowk, xhighk = getBoundsOfSupport(gs, lkd, ikd, self._gridType) xlowi, xhighi = getBoundsOfSupport(gs, lid, iid, self._gridType) xlowj, xhighj = getBoundsOfSupport(gs, ljd, ijd, self._gridType) # compute overlapping support xlow = max(xlowk, xlowi, xlowj) xhigh = min(xhighk, xhighi, xhighj) # check if the overlapping support is larger than 0 if xlow >= xhigh: val = err = 0 else: # ---------------------------------------------------- # use gauss-legendre-quadrature def f(p): return basisk.eval(lkd, ikd, p) * \ basisi.eval(lid, iid, p) * \ basisj.eval(ljd, ijd, p) if lid >= ljd and lid >= lkd: xcenter = gs.getCoordinate(gpi, d) elif ljd >= lid and ljd >= lkd: xcenter = gs.getCoordinate(gpj, d) else: xcenter = gs.getCoordinate(gpk, d) deg = 2 if self._gridType in polyGridTypes: deg = lid + ljd + lkd sleft, err1dleft = self.quad(f, xlow, xcenter, deg=deg) sright, err1dright = self.quad(f, xcenter, xhigh, deg=deg) # # ----------------------------------------- # # plot the basis # import matplotlib.pyplot as plt # import numpy as np # x = np.linspace(xlow, xhigh, 100) # b0 = [basisk.eval(lkd, ikd, xi) for xi in np.linspace(xlowk, xhighk, 100)] # b1 = [basisi.eval(lid, iid, xi) for xi in np.linspace(xlowi, xhighi, 100)] # b2 = [basisj.eval(ljd, ijd, xi) for xi in np.linspace(xlowj, xhighj, 100)] # # pdf = [self._U[d].pdf(self._T[d].unitToProbabilistic(xi)) # # for xi in x] # res = [f(xi) for xi in x] # numpy_quad = scipy.integrate.quad(f, xlow, xcenter)[0] + \ # scipy.integrate.quad(f, xcenter, xhigh)[0] # # fig = plt.figure() # plt.plot(x, b0, label="basis 0") # 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.title("[%g, %g] -> (%i, %i), (%i, %i), (%i, %i), %g = %g" % (xlow, xhigh, lkd, ikd, lid, iid, ljd, ijd, sleft + sright, numpy_quad)) # plt.legend() # plt.xlim(0, 1) # plt.show() # # fig.savefig("/home/franzefn/Desktop/tmp/trilinear/no_key_%i.png" % np.random.randint(10000)) # # ---------------------------------------------------- val = sleft + sright err = err1dleft + err1dright return val, err
def computeBilinearFormEntry(self, gs, gpi, basisi, gpj, basisj, d): # if not, compute it ans = 1 err = 0. # interpolating 1d sparse grid ngrid = Grid.createPolyBoundaryGrid(1, 2) ngrid.getGenerator().regular(2) ngs = ngrid.getStorage() nodalValues = DataVector(ngs.getSize()) for d in range(gpi.getDimension()): # 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) xlowj, xhighj = getBoundsOfSupport(gs, ljd, ijd) xlow = max(xlowi, xlowj) xhigh = min(xhighi, xhighj) # same level, different index if lid == ljd and iid != ijd and lid > 0: return 0., 0. # the support does not overlap elif lid != ljd and xlow >= xhigh: return 0., 0. else: # ---------------------------------------------------- # do the 1d interpolation ... # define transformation function T = LinearTransformation(xlow, xhigh) for k in range(ngs.getSize()): x = ngs.getCoordinate(ngs.getPoint(k), 0) x = T.unitToProbabilistic(x) nodalValues[k] = basisi.eval(lid, iid, x) * \ basisj.eval(ljd, ijd, x) # ... by hierarchization v = hierarchize(ngrid, nodalValues) # discretize the following function def f(x, y): xp = T.unitToProbabilistic(x) return float(y * self._U[d].pdf(xp)) # sparse grid quadrature g, w, err1d = discretize(ngrid, v, f, refnums=0, level=5, useDiscreteL2Error=False) s = T.vol() * doQuadrature(g, w) # fig = plt.figure() # plotSG1d(ngrid, v) # x = np.linspace(xlow, ub, 100) # plt.plot(np.linspace(0, 1, 100), U[d].pdf(x)) # fig.show() # fig = plt.figure() # plotSG1d(g, w) # x = np.linspace(0, 1, 100) # plt.plot(x, # [evalSGFunction(ngrid, v, DataVector([xi])) * U[d].pdf(T.unitToProbabilistic(xi)) for xi in x]) # fig.show() # plt.show() # compute the integral of it # ---------------------------------------------------- ans *= s err += err1d[1] return ans, err
def computeTrilinearFormEntry(self, gpk, basisk, gpi, basisi, gpj, basisj, d): val = 1 err = 0. # get level index lkd, ikd = gpk.getLevel(d), gpk.getIndex(d) 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 all # three basis functions xlowk, xhighk = getBoundsOfSupport(lkd, ikd) xlowi, xhighi = getBoundsOfSupport(lid, iid) xlowj, xhighj = getBoundsOfSupport(ljd, ijd) # compute overlapping support xlow = max(xlowk, xlowi, xlowj) xhigh = min(xhighk, xhighi, xhighj) # check if the overlapping support is larger than 0 if xlow >= xhigh: val = err = 0 else: # ---------------------------------------------------- # use gauss-legendre-quadrature def f(p): return basisk.eval(lkd, ikd, p) * \ basisi.eval(lid, iid, p) * \ basisj.eval(ljd, ijd, p) 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 matplotlib.pyplot as plt # import numpy as np # x = np.linspace(xlow, xhigh, 100) # b0 = [basisk.eval(lkd, ikd, xi) for xi in np.linspace(xlowk, xhighk, 100)] # b1 = [basisi.eval(lid, iid, xi) for xi in np.linspace(xlowi, xhighi, 100)] # b2 = [basisj.eval(ljd, ijd, xi) for xi in np.linspace(xlowj, xhighj, 100)] # # pdf = [self._U[d].pdf(self._T[d].unitToProbabilistic(xi)) # # for xi in x] # res = [f(xi) for xi in x] # # fig = plt.figure() # plt.plot(x, b0, label="basis 0") # 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.title("[%g, %g] -> (%i, %i), (%i, %i), (%i, %i), %g" % (xlow, xhigh, lkd, ikd, lid, iid, ljd, ijd, sleft + sright)) # plt.legend() # plt.xlim(0, 1) # plt.show() # # fig.savefig("/home/franzefn/Desktop/tmp/trilinear/no_key_%i.png" % np.random.randint(10000)) # # ---------------------------------------------------- val = val * (sleft + sright) err += val * (err1dleft + err1dright) return val, err