def discretize(grid, alpha, f, epsilon=0., refnums=0, pointsNum=10, level=0, deg=1, useDiscreteL2Error=True): """ discretize f with a sparse grid @param grid: Grid @param alpha: surplus vector @param f: function @param epsilon: float, error tolerance @param refnums: int, number of refinment steps @param pointsNum: int, number of points to be refined per step @param level: int, initial grid level @param deg: int, degree of lagrange basis """ # copy grid jgrid = copyGrid(grid, level=level, deg=deg) jgs = jgrid.getStorage() jgn = jgrid.createGridGenerator() basis_alpha = DataVector(alpha) # compute joined sg function jalpha = computeCoefficients(jgrid, grid, alpha, f) # compute errors maxdrift = None accMiseL2 = None l2error_grid = alpha.l2Norm() if useDiscreteL2Error: maxdrift, accMiseL2 = computeErrors(jgrid, jalpha, grid, alpha, f) else: accMiseL2 = l2error_grid # print "iteration 0/%i (%i, %i, %g): %g, %g, %s" % \ # (refnums, jgs.size(), len(jalpha), # epsilon, accMiseL2, l2error_grid, maxdrift) ref = 0 errs = [jgs.size(), accMiseL2, l2error_grid, maxdrift] bestGrid, bestAlpha, bestL2Error = copyGrid(jgrid), DataVector( jalpha), accMiseL2 # repeat refinement as long as there are iterations and the # minimum error epsilon is reached while ref < refnums and bestL2Error > epsilon: oldgrid = copyGrid(jgrid) rp = jgn.getNumberOfRefinablePoints( ) # max(1, min(pointsNum, jgn.getNumberOfRefinablePoints())) jgn.refine(SurplusRefinementFunctor(jalpha, rp, epsilon)) # if grid point has been added in the last iteration step if len(basis_alpha) == jgs.size(): break # extend alpha vector... basis_alpha.resizeZero(jgs.size()) # ------------------------------ # compute joined sg function jalpha = computeCoefficients(jgrid, grid, basis_alpha, f) # compute useDiscreteL2Error l2error_grid = estimateL2error(oldgrid, jgrid, jalpha) # do Monte Carlo integration for obtaining the accMiseL2 if useDiscreteL2Error: maxdrift, accMiseL2 = computeErrors(jgrid, jalpha, grid, alpha, f) # ------------------------------ print "iteration %i/%i (%i, %i, %i, %i, %g): %g, %g, %s -> current best %g" % \ (ref + 1, refnums, jgs.size(), len(jalpha), bestGrid.getSize(), len(bestAlpha), epsilon, accMiseL2, l2error_grid, maxdrift, bestL2Error) # check whether the new grid is better than the current best one # using the discrete l2 error. If no MC integration is done, # use the l2 error approximation via the sparse grid surpluses if (not useDiscreteL2Error and l2error_grid < bestL2Error) or \ (useDiscreteL2Error and accMiseL2 < bestL2Error): bestGrid = copyGrid(jgrid) bestAlpha = DataVector(jalpha) if useDiscreteL2Error: bestL2Error = accMiseL2 else: bestL2Error = l2error_grid errs = [jgs.size(), accMiseL2, l2error_grid, maxdrift] ref += 1 return bestGrid, bestAlpha, errs
def discretize(grid, alpha, f, epsilon=0., refnums=0, pointsNum=10, level=0, deg=1, useDiscreteL2Error=True): """ discretize f with a sparse grid @param grid: Grid @param alpha: surplus vector @param f: function @param epsilon: float, error tolerance @param refnums: int, number of refinment steps @param pointsNum: int, number of points to be refined per step @param level: int, initial grid level @param deg: int, degree of lagrange basis """ # copy grid jgrid = copyGrid(grid, level=level, deg=deg) jgs = jgrid.getStorage() jgn = jgrid.createGridGenerator() basis_alpha = DataVector(alpha) # compute joined sg function jalpha = computeCoefficients(jgrid, grid, alpha, f) # compute errors maxdrift = None accMiseL2 = None l2error_grid = alpha.l2Norm() if useDiscreteL2Error: maxdrift, accMiseL2 = computeErrors(jgrid, jalpha, grid, alpha, f) else: accMiseL2 = l2error_grid # print "iteration 0/%i (%i, %i, %g): %g, %g, %s" % \ # (refnums, jgs.size(), len(jalpha), # epsilon, accMiseL2, l2error_grid, maxdrift) ref = 0 errs = [jgs.size(), accMiseL2, l2error_grid, maxdrift] bestGrid, bestAlpha, bestL2Error = copyGrid(jgrid), DataVector(jalpha), accMiseL2 # repeat refinement as long as there are iterations and the # minimum error epsilon is reached while ref < refnums and bestL2Error > epsilon: oldgrid = copyGrid(jgrid) rp = jgn.getNumberOfRefinablePoints() # max(1, min(pointsNum, jgn.getNumberOfRefinablePoints())) jgn.refine(SurplusRefinementFunctor(jalpha, rp, epsilon)) # if grid point has been added in the last iteration step if len(basis_alpha) == jgs.size(): break # extend alpha vector... basis_alpha.resizeZero(jgs.size()) # ------------------------------ # compute joined sg function jalpha = computeCoefficients(jgrid, grid, basis_alpha, f) # compute useDiscreteL2Error l2error_grid = estimateL2error(oldgrid, jgrid, jalpha) # do Monte Carlo integration for obtaining the accMiseL2 if useDiscreteL2Error: maxdrift, accMiseL2 = computeErrors(jgrid, jalpha, grid, alpha, f) # ------------------------------ print "iteration %i/%i (%i, %i, %i, %i, %g): %g, %g, %s -> current best %g" % \ (ref + 1, refnums, jgs.size(), len(jalpha), bestGrid.getSize(), len(bestAlpha), epsilon, accMiseL2, l2error_grid, maxdrift, bestL2Error) # check whether the new grid is better than the current best one # using the discrete l2 error. If no MC integration is done, # use the l2 error approximation via the sparse grid surpluses if (not useDiscreteL2Error and l2error_grid < bestL2Error) or \ (useDiscreteL2Error and accMiseL2 < bestL2Error): bestGrid = copyGrid(jgrid) bestAlpha = DataVector(jalpha) if useDiscreteL2Error: bestL2Error = accMiseL2 else: bestL2Error = l2error_grid errs = [jgs.size(), accMiseL2, l2error_grid, maxdrift] ref += 1 return bestGrid, bestAlpha, errs
def makePositive(self, alpha): """ insert recursively all grid points such that the function is positive defined. Interpolate the function values for the new grid points using the registered algorithm. @param alpha: DataVector hierarchical coefficients """ # make sure that the function is positive at every existing grid point grid = self.grid alpha = self.makeCurrentGridPositive(grid, alpha) # start adding points newGridPoints = [] iteration = 1 while True: # copy the old grid newGrid = copyGrid(grid) # add all those grid points which have an ancestor with negative # coefficient if self.verbose: print "-" * 60 print "%i:" % iteration print "adding full grid points" addedGridPoints = self.addFullGridPoints(newGrid, alpha) if len(addedGridPoints) == 0: newAlpha = alpha break if self.verbose: print "learning the new density" newGridPoints += addedGridPoints # set the function value at the new grid points to zero newNodalValues = dehierarchize(grid, alpha) newNodalValues.resizeZero(newGrid.getSize()) newAlpha = DataVector(alpha) newAlpha.resizeZero(newGrid.getSize()) # compute now the hierarchical coefficients for the newly # added points newAlpha = self.algorithm.computeHierarchicalCoefficients(newGrid, newAlpha, addedGridPoints) # the function does not have to be positive now -> check it again if self.verbose: print "force function to be positive" # check manually if all nodal points are positive newNodalValues = dehierarchize(newGrid, newAlpha) # collect all negative function values forceToBePositive = [] newGs = newGrid.getStorage() for i in xrange(newGs.size()): gp = newGs.get(i) if newNodalValues[newGs.seq(gp)] < 0.: forceToBePositive.append(gp) if len(forceToBePositive) > 0: # if not, interpolate the function values for the negative # grid points if self.verbose: warnings.warn("manually forcing the the function to be positive") newAlpha = self.makeCurrentGridPositive(newGrid, newAlpha) # newAlpha = SetGridPointsToZero().computeHierarchicalCoefficients(grid, newAlpha, forceToBePositive) # newAlpha = InterpolateParents().computeHierarchicalCoefficients(grid, newAlpha, forceToBePositive) if newGrid.getSize() == grid.getSize(): break if self.verbose: fig = plt.figure() plotSG2d(newGrid, newAlpha) plt.title("iteration = %i" % iteration) fig.show() print "%i + %i = %i for discretization" % (grid.getSize(), newGrid.getSize() - grid.getSize(), newGrid.getSize(),) iteration += 1 grid, alpha = newGrid, newAlpha # coarsening: remove all new grid points with negative surplus coarsedGrid, coarsedAlpha, _ = self.coarsening(newGrid, newAlpha, newGridPoints) if self.verbose: print "%i - %i = %i grid size after coarsening" % (newGrid.getSize(), newGrid.getSize() - coarsedGrid.getSize(), coarsedGrid.getSize(),) # scale the result such that the integral over it is one # c = createOperationQuadrature(coarsedGrid).doQuadrature(coarsedAlpha) # coarsedAlpha.mult(1. / c) # security check for positiveness checkPositivity(coarsedGrid, coarsedAlpha) return coarsedGrid, coarsedAlpha