def createGrid(grid, dim, deg=1, addTruncatedBorder=False):
# create new grid
gridType = grid.getType()
deg = max(deg, grid.getDegree())
# print( gridType, deg )
if deg > 1 and gridType in [GridType_Linear]:
return Grid.createPolyGrid(dim, deg)
if deg > 1 and gridType in [
GridType_LinearBoundary, GridType_LinearL0Boundary
]:
return Grid.createPolyBoundaryGrid(dim, deg)
elif deg > 1 and gridType in [GridType_LinearClenshawCurtis]:
return Grid.createPolyClenshawCurtisGrid(dim, deg)
elif deg > 1 and gridType in [GridType_LinearClenshawCurtisBoundary]:
return Grid.createPolyClenshawCurtisBoundaryGrid(dim, deg)
elif deg > 1 and gridType in [GridType_ModLinear]:
return Grid.createModPolyGrid(dim, deg)
elif deg > 1 and gridType in [GridType_ModLinearClenshawCurtis]:
return Grid.createModPolyClenshawCurtisGrid(dim, deg)
else:
gridConfig = RegularGridConfiguration()
gridConfig.type_ = gridType
gridConfig.dim_ = dim
gridConfig.maxDegree_ = deg
return Grid.createGrid(gridConfig)
def _model_to_settings(X, in_grid_config, in_regularization_config,
in_solver_config, in_final_solver_config,
in_adaptivity_config):
grid_config = RegularGridConfiguration()
grid_config.dim_ = X.shape[1]
grid_config.level_ = in_grid_config.level
grid_config.type_ = in_grid_config.type #6 = ModLinear
grid_config.t_ = in_grid_config.T
adaptivity_config = AdpativityConfiguration()
adaptivity_config.numRefinements_ = in_adaptivity_config.num_refinements
if adaptivity_config.numRefinements_ == 0:
adaptivity_config.noPoints_ = 0
adaptivity_config.percent_ = 0
adaptivity_config.threshold_ = 0
else:
adaptivity_config.noPoints_ = in_adaptivity_config.no_points
adaptivity_config.percent_ = in_adaptivity_config.percent
adaptivity_config.threshold_ = in_adaptivity_config.treshold
solver_config = SLESolverConfiguration()
solver_config.type_ = in_solver_config.type
solver_config.maxIterations_ = in_solver_config.max_iterations
solver_config.eps_ = in_solver_config.epsilon
solver_config.threshold_ = in_solver_config.threshold
final_solver_config = SLESolverConfiguration()
final_solver_config.type_ = in_final_solver_config.type
final_solver_config.maxIterations_ = in_final_solver_config.max_iterations
final_solver_config.eps_ = in_final_solver_config.epsilon
final_solver_config.threshold_ = in_solver_config.threshold
regularization_config = RegularizationConfiguration()
regularization_config.exponentBase_ = in_regularization_config.exponent_base
regularization_config.regType_ = in_regularization_config.type
regularization_config.lambda_ = in_regularization_config.lambda_reg
regularization_config.l1Ratio_ = in_regularization_config.l1_ratio
return grid_config, adaptivity_config, solver_config, final_solver_config, regularization_config
def createGrid(self):
"""
Creates the specified grid
"""
grid = None
if self.__file is not None and os.path.exists(self.__file):
gridFormatter = GridFormatter()
grid = gridFormatter.deserializeFromFile(self.__file)
else:
gridConfig = RegularGridConfiguration()
gridConfig.dim_ = self.__dim
if (self.__dim is None or self.level is None) and self.__grid is None:
raise AttributeError("Not all attributes assigned to create\
grid")
if self.__boundaryLevel is not None:
gridConfig.boundaryLevel_ = self.__boundaryLevel
gridConfig.maxDegree_ = self.__deg
if self.__gridType not in [GridType_Linear,
GridType_LinearBoundary,
GridType_ModLinear,
GridType_LinearClenshawCurtis,
GridType_LinearClenshawCurtisBoundary,
GridType_ModLinearClenshawCurtis,
GridType_Poly,
GridType_PolyBoundary,
GridType_ModPoly,
GridType_PolyClenshawCurtis,
GridType_PolyClenshawCurtisBoundary,
GridType_ModPolyClenshawCurtis,
GridType_Bspline,
GridType_ModBspline,
GridType_BsplineBoundary,
GridType_BsplineClenshawCurtis,
GridType_ModBsplineClenshawCurtis]:
print( "Warning: grid type not fully supported" )
gridConfig.type_ = self.__gridType
# generate the grid
grid = Grid.createGrid(gridConfig)
if self.level is not None:
generator = grid.getGenerator()
if not self.__full:
generator.regular(self.level)
else:
generator.full(self.level)
# if there is a grid specified, add all the missing points
if self.__grid is not None:
gs = grid.getStorage()
copygs = self.__grid.getStorage()
# insert grid points
for i in range(copygs.getSize()):
gp = copygs.getPoint(i)
# insert grid point
if not gs.isContaining(gp):
gs.insert(HashGridPoint(gp))
if self.__boundaryLevel == 1:
insertTruncatedBorder(grid, gp)
gs.recalcLeafProperty()
return grid
GridType_ModPolyClenshawCurtis, GridType_Poly
from pysgpp._pysgpp_swig import createOperationEvalNaive
from pysgpp.extensions.datadriven.uq.operations.sparse_grid import hierarchize
bs = [1, 2, 5, 10, 20, 50, 100, 500]
def g(x, a):
return (np.abs(4 * x - 2) + a) / (a + 1)
def f(xs, **kws):
return np.prod([g(x, b) for x, b in zip(xs, bs)])
gridConfig = RegularGridConfiguration()
gridConfig.type_ = GridType_Poly
gridConfig.maxDegree_ = 2
gridConfig.boundaryLevel_ = 0
gridConfig.dim_ = len(bs)
grids = []
for i in range(10):
# compute a few hundred interpolations
grid = Grid.createGrid(gridConfig)
gridStorage = grid.getStorage()
grid.getGenerator().regular(3)
nodalValues = np.ndarray(gridStorage.getSize())
p = DataVector(gridStorage.getDimension())
for i in range(gridStorage.getSize()):
from pysgpp import createOperationMakePositive, \
MakePositiveCandidateSearchAlgorithm_Intersections, \
MakePositiveInterpolationAlgorithm_SetToZero, \
MakePositiveInterpolationAlgorithm_InterpolateExp, \
MakePositiveInterpolationAlgorithm_InterpolateBoundaries1d, SizeList, \
HashGridPoint, MakePositiveCandidateSearchAlgorithm_HybridFullIntersections, \
GridType_Linear, GridType_Poly, RegularGridConfiguration
from pysgpp.extensions.datadriven.uq.operations.sparse_grid import checkPositivity
from pysgpp.extensions.datadriven.uq.plot.plot3d import plotSG3d, plotDensity3d
from pysgpp.pysgpp_swig import GridType_PolyBoundary, \
MakePositiveCandidateSearchAlgorithm_FullGrid, GridType_LinearClenshawCurtis, \
MakePositiveCandidateSearchAlgorithm_IntersectionsJoin
from pysgpp.extensions.datadriven.uq.dists.Normal import Normal
# parameters
gridConfig = RegularGridConfiguration()
# gridConfig.type_ = GridType_Linear
gridConfig.type_ = GridType_Linear
gridConfig.boundaryLevel_ = 0
# issues with: d = 5, l = 3, ref = 4
numDims = 6
level = 4
refnums = 0
consistentGrid = False
# candidateSearchAlgorithm = MakePositiveCandidateSearchAlgorithm_FullGrid
# candidateSearchAlgorithm = MakePositiveCandidateSearchAlgorithm_Intersections
candidateSearchAlgorithm = MakePositiveCandidateSearchAlgorithm_IntersectionsJoin
# candidateSearchAlgorithm = MakePositiveCandidateSearchAlgorithm_HybridFullIntersections
# interpolationAlgorithm = MakePositiveInterpolationAlgorithm_InterpolateBoundaries1d
interpolationAlgorithm = MakePositiveInterpolationAlgorithm_SetToZero
plot = True