def checkRemovePoints(self):
'''
tests removePointsByHierarchicalCoefficient()
'''
grid = TasmanianSG.makeLocalPolynomialGrid(2, 1, 1)
aPoints = grid.getNeededPoints()
grid.loadNeededValues(np.exp(-aPoints[:,0]**2 -0.5*aPoints[:,1]**2).reshape((grid.getNumNeeded(), 1)))
reduced = TasmanianSG.TasmanianSparseGrid()
reduced.copyGrid(grid)
reduced.removePointsByHierarchicalCoefficient(0.6)
self.assertEqual(reduced.getNumPoints(), 3, "failed to remove points with threshold 0.6")
np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0], [-1.0, 0.0], [1.0, 0.0]]), 14, "failed reduce 1", True)
reduced.copyGrid(grid)
reduced.removePointsByHierarchicalCoefficient(0.7)
self.assertEqual(reduced.getNumPoints(), 1, "failed to remove points with threshold 0.7")
np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0]]), 14, "failed reduce 2", True)
reduced.copyGrid(grid)
reduced.removePointsByHierarchicalCoefficient(0.0, iNumKeep = 3)
self.assertEqual(reduced.getNumPoints(), 3, "failed to remove points down to 3")
np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0], [-1.0, 0.0], [1.0, 0.0]]), 14, "failed reduce 3", True)
reduced.copyGrid(grid)
reduced.removePointsByHierarchicalCoefficient(0.0, iNumKeep = 1)
self.assertEqual(reduced.getNumPoints(), 1, "failed to remove points down to 1")
np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0]]), 14, "failed reduce 4", True)
reduced.copyGrid(grid)
reduced.removePointsByHierarchicalCoefficient(0.0, aScaleCorrection = np.array([[1.0], [1.0], [1.0], [0.1], [0.1]]), iNumKeep = 3)
self.assertEqual(reduced.getNumPoints(), 3, "failed to remove corrected points")
np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0], [0.0, -1.0], [0.0, 1.0]]), 14, "failed reduce 5", True)
def main():
#valList = []
start_time = time.clock()
output = dict()
output[0] = []
for shock in range(5):
paramL['curr_theta'] = paramL['theta_list'][shock]
valnew = TasmanianSG.TasmanianSparseGrid()
valnew = interpol.sparse_grid(paramL)
valold = TasmanianSG.TasmanianSparseGrid()
valold = valnew
output[0].append(valold)
valnew.write("valnew_1." + str(paramL['numstart']) +
".s{}".format(shock) +
".txt") #write file to disk for restart
for i in range(paramL['numstart'] + 1, paramL['numits'] + 1):
output[i] = list()
for shock in range(5):
paramL['curr_theta'] = paramL['theta_list'][shock]
valnew = TasmanianSG.TasmanianSparseGrid()
valnew = interpol_iter.sparse_grid_iter(paramL,
list(output[i - 1]))
valold = TasmanianSG.TasmanianSparseGrid()
valold = valnew
output[i].append(valold)
valnew.write("valnew_1." + str(i) + ".s{}".format(shock) + ".txt")
avg_err = post.ls_error(paramL)
end_time = time.clock() - start_time
print('END')
print(end_time)
return output
def checkPathsVersions(self):
'''
Check different ways to specify the library path and check the
version number.
'''
if (tdata.bEnableSyncTests):
grid = TasmanianSG.TasmanianSparseGrid(tdata.sLibPath)
sVersion = grid.getVersion()
self.assertEqual(sVersion, TasmanianSG.__version__, "version mismatch")
pLibTSG = cdll.LoadLibrary(tdata.sLibPath)
grid = TasmanianSG.TasmanianSparseGrid(pLibTSG)
sVersion = grid.getVersion()
self.assertEqual(sVersion, TasmanianSG.__version__, "version mismatch")
grid = TasmanianSG.TasmanianSparseGrid()
sVersion = grid.getVersion()
self.assertEqual(sVersion, TasmanianSG.__version__, "version mismatch")
sLicense = grid.getLicense()
self.assertEqual(sLicense, TasmanianSG.__license__, "license mismatch")
iVM = int(sVersion.split('.')[0])
iVm = int(sVersion.split('.')[1])
self.assertEqual(iVM, grid.getVersionMajor(), "version major mismatch")
self.assertEqual(iVm, grid.getVersionMinor(), "version minor mismatch")
def checkFileIO(self):
'''
Read/Write regular refinement.
'''
grid = TasmanianSG.TasmanianSparseGrid()
sRefinementIOGrids = [
"grid.makeGlobalGrid(2, 1, 2, 'level', 'clenshaw-curtis')",
"grid.makeSequenceGrid(2, 1, 2, 'level', 'rleja')"
]
for sTest in sRefinementIOGrids:
exec(sTest)
ttc.loadExpN2(grid)
grid.setAnisotropicRefinement('iptotal', 20, 0)
self.assertTrue(grid.getNumNeeded() > 0, 'did not refine')
gridB = TasmanianSG.TasmanianSparseGrid()
gridB.copyGrid(grid)
ttc.compareGrids(grid, gridB)
grid.write("refTestFlename.grid", bUseBinaryFormat=True)
gridB.makeLocalPolynomialGrid(1, 1, 0, 1)
gridB.read("refTestFlename.grid")
ttc.compareGrids(grid, gridB)
grid.write("refTestFlename.grid", bUseBinaryFormat=False)
gridB.makeLocalPolynomialGrid(1, 1, 0, 1)
gridB.read("refTestFlename.grid")
ttc.compareGrids(grid, gridB)
def ls_error(n_agents, t1, t2, num_points):
file=open('errors.txt', 'w')
np.random.seed(0)
unif=np.random.rand(num_points, n_agents)
k_sample=k_bar+(unif)*(k_up-k_bar)
to_print=np.empty((1,3))
for i in range(t1, t2):
sum_diffs=0
diff = 0
v_prev=TasmanianSG.TasmanianSparseGrid()
v_next=TasmanianSG.TasmanianSparseGrid()
v_prev.read("valnew_1." + str(i) + ".txt")
v_next.read("valnew_1." + str(i+1) + ".txt")
diff=v_next.evaluateBatch(k_sample) - v_prev.evaluateBatch(k_sample)
max_abs_diff=np.amax(np.fabs(diff))
average = np.average(np.fabs(diff))
to_print[0,0]=i+1
to_print[0,1]=max_abs_diff
to_print[0,2]= average
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
return
def main():
start_time = time.clock()
paramL['curr_theta'] = paramL['theta_list'][rank]
valnew = TasmanianSG.TasmanianSparseGrid()
valnew = interpol.sparse_grid(paramL)
valold = TasmanianSG.TasmanianSparseGrid()
valold = valnew
valnew.write("valnew_1." + str(paramL['numstart']) + ".s{}".format(rank) +
".txt") #write file to disk for restart
comm.barrier()
for i in range(paramL['numstart'] + 1, paramL['numits'] + 1):
print('Size: ', size, ' rank ', rank)
paramL['curr_theta'] = paramL['theta_list'][rank]
valnew = TasmanianSG.TasmanianSparseGrid()
output = get_iteration_list(i - 1)
valnew = interpol_iter.sparse_grid_iter(paramL, list(output))
valold = TasmanianSG.TasmanianSparseGrid()
valold = valnew
valnew.write("valnew_1." + str(i) + ".s{}".format(rank) + ".txt")
comm.barrier()
end_time = time.clock() - start_time
print('END')
if rank == 0:
avg_err = post.ls_error(paramL)
print(end_time)
def sparse_grid_iter(n_agents, iDepth, iG, Lvalold):
grid = TasmanianSG.TasmanianSparseGrid()
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, iOut])
file = open("comparison1.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, Lvalold,
phi[iG])[0]
grid.loadNeededPoints(aVals) # Get interpolant at sparse grid
#refinement level
for iK in range(refinement_level):
grid.setSurplusRefinement(fTol, 1,
"fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
#grid.plotPoints2D()
print("Number of Points", grid.getNumPoints())
aVals = np.empty([aPoints.shape[0], iOut])
for iI in range(aPoints.shape[0]):
# Solve the value function problem for all grid points
aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, Lvalold,
phi[iG])[0]
# Update interpolant
grid.loadNeededPoints(aVals)
#print(" {0:9d} {1:9d} {2:1.2e}".format(iK+1, grid.getNumPoints()))
grid2 = TasmanianSG.TasmanianSparseGrid()
grid2.makeLocalPolynomialGrid(iDim, iOut, refinement_level + iDepth,
which_basis, "localp")
print("Max Number of Points", grid2.getNumPoints())
#f=open("grid_iter.txt", 'w')
#np.savetxt(f, aPoints, fmt='% 2.16f')
#f.close()
return grid
#======================================================================
def checkConstruction(self):
'''
Test read/write when using construction.
'''
for sFormat in [False, True]: # test binary and ascii format
gridA = TasmanianSG.TasmanianSparseGrid()
gridB = TasmanianSG.TasmanianSparseGrid()
gridA.makeGlobalGrid(3, 2, 2, "level", "clenshaw-curtis")
gridB.makeGlobalGrid(3, 2, 2, "level", "clenshaw-curtis")
gridA.beginConstruction()
gridB.beginConstruction()
gridB.write("testSave", bUseBinaryFormat=sFormat)
gridB.makeSequenceGrid(1, 1, 0, "level", "rleja") # clean the grid
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
for t in range(5): # use 5 iterations
aPointsA = gridA.getCandidateConstructionPoints("level", 0)
aPointsB = gridB.getCandidateConstructionPoints("level", 0)
np.testing.assert_almost_equal(aPointsA, aPointsB, decimal=11)
iNumPoints = int(aPointsA.shape[0] / 2)
if (iNumPoints > 32): iNumPoints = 32
# use the first samples (up to 32) and shuffle the order
# add one of the samples further in the list
liSamples = list(range(iNumPoints + 1))
shuffle(liSamples)
liSamples = map(
lambda i: i
if i < iNumPoints else iNumPoints + 1, liSamples)
for iI in liSamples: # compute and load the samples
aPoint = aPointsA[iI, :]
aValue = np.array([
np.exp(aPoint[0] + aPoint[1]),
1.0 / ((aPoint[0] - 1.3) * (aPoint[1] - 1.6) *
(aPoint[2] - 2.0))
])
gridA.loadConstructedPoint(aPoint, aValue)
gridB.loadConstructedPoint(aPoint, aValue)
# using straight construction or read/write should produce the same result
gridB.write("testSave", bUseBinaryFormat=sFormat)
gridB.makeSequenceGrid(1, 1, 0, "level", "rleja")
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridA.finishConstruction()
gridB.finishConstruction()
gridB.write("testSave", bUseBinaryFormat=sFormat)
gridB.makeSequenceGrid(1, 1, 0, "level", "rleja")
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
def checkGlobalGridCustom(self):
'''
Test makeGlobalGridCustom(), which creates a grid from a CustomTabulated instance.
'''
gridA = TasmanianSG.makeGlobalGrid(1, 1, 3, "level", "custom-tabulated", [], 0.0, 0.0, tdata.sGaussPattersonTableFile)
ct = TasmanianSG.makeCustomTabulatedFromFile(tdata.sGaussPattersonTableFile)
gridB = TasmanianSG.makeGlobalGridCustom(1, 1, 3, "level", ct)
ttc.compareGrids(gridA, gridB)
gridA = TasmanianSG.makeGlobalGrid(2, 1, 3, "level", "custom-tabulated", [], 0.0, 0.0, tdata.sGaussPattersonTableFile)
gridB = TasmanianSG.makeGlobalGridCustom(2, 1, 3, "level", ct)
ttc.compareGrids(gridA, gridB)
def checkReadWriteMisc(self):
'''
Test reading and writing of domain transforms and testing all rules.
'''
lGrids = ['gridA.makeGlobalGrid(3, 2, 4, "level", "clenshaw-curtis"); gridA.setDomainTransform(aTransform); gridA.setConformalTransformASIN(np.array([3,4,5]))',
'gridA.makeGlobalGrid(3, 2, 4, "level", "gauss-legendre"); gridA.setConformalTransformASIN(np.array([3,5,1]))',
'gridA.makeSequenceGrid(2, 2, 5, "level", "leja"); gridA.setConformalTransformASIN(np.array([0,4]))',
'gridA.makeLocalPolynomialGrid(3, 1, 4, 2, "localp"); gridA.setDomainTransform(aTransform); gridA.setConformalTransformASIN(np.array([5,3,0]))',
'gridA.getNumPoints()']
aTransform = np.array([[0.0,1.0],[0.0,1.0],[-2.0,-1.0]])
for sGrid in lGrids:
gridA = TasmanianSG.TasmanianSparseGrid()
gridB = TasmanianSG.TasmanianSparseGrid()
exec(sGrid)
gridA.write("testSave", bUseBinaryFormat = False)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridA.write("testSave", bUseBinaryFormat = True)
gridB.makeLocalPolynomialGrid(1, 1, 0)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridB.makeSequenceGrid(1, 1, 0, "level", "leja");
gridB.makeLocalPolynomialGrid(1, 1, 0)
gridB.copyGrid(gridA)
ttc.compareGrids(gridA, gridB)
# Make a grid with every possible rule (catches false-positive and memory crashes)
for sType in TasmanianSG.lsTsgGlobalTypes:
for sRule in TasmanianSG.lsTsgGlobalRules:
if ("custom-tabulated" in sRule):
gridA.makeGlobalGrid(2, 0, 2, sType, sRule, sCustomFilename = tdata.sGaussPattersonTableFile)
else:
gridA.makeGlobalGrid(2, 0, 2, sType, sRule)
gridA.write("testSave", bUseBinaryFormat = False)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridB.makeGlobalGrid(1, 0, 0, "level", "clenshaw-curtis")
gridA.write("testSave", bUseBinaryFormat = True)
gridB.read("testSave")
for sType in TasmanianSG.lsTsgGlobalTypes:
for sRule in TasmanianSG.lsTsgSequenceRules:
gridA.makeSequenceGrid(2, 1, 3, sType, sRule)
gridA.write("testSave", bUseBinaryFormat = False)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridB.makeGlobalGrid(1, 0, 0, "level", "clenshaw-curtis")
gridA.write("testSave", bUseBinaryFormat = True)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
def sparse_grid_iter(n_agents, iDepth, valold, itheta):
grid = TasmanianSG.TasmanianSparseGrid()
k_range=np.array([k_bar, k_up])
ranges=np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i]=k_range
iDim=n_agents
iOut=1
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints=grid.getPoints()
iNumP1=aPoints.shape[0]
aVals=np.empty([iNumP1, 1])
for iI in range(iNumP1):
aVals[iI]=solveriter.iterate(aPoints[iI], n_agents, valold, itheta)[0]
v=aVals[iI]*np.ones((1,1))
file=open("comparison1.txt", 'w')
grid.loadNeededPoints(aVals)
for iK in range(refinement_level):
grid.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(iNumP1):
aVals[iI]=solveriter.iterate(aPoints[iI], n_agents, valold, itheta)[0]
v=aVals[iI]*np.ones((1,1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid.loadNeededPoints(aVals)
f2=open("Adaptive_sparse_grid.txt", 'a')
np.savetxt(f2, aPoints, fmt='% 2.16f')
f2.close()
grid2 = TasmanianSG.TasmanianSparseGrid()
grid2.makeLocalPolynomialGrid(iDim, iOut, refinement_level+iDepth, which_basis, "localp")
a = grid2.getNumPoints()
f=open("grid_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid(n_agents, iDepth):
grid = TasmanianSG.TasmanianSparseGrid(
) #grid. calls all the tasmanian stuff!
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
file = open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[0]
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid.loadNeededPoints(aVals)
f = open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def checkMeta(self):
'''
Check if the CMake options are propagated to the C++ library and the
correct acceleration options are passed between C++ and Python.
'''
grid = TasmanianSG.TasmanianSparseGrid()
if (tdata.bEnableSyncTests):
self.assertTrue(
(grid.isAccelerationAvailable("cpu-blas") == tdata.bHasBlas),
"failed to match blas")
self.assertTrue((grid.isAccelerationAvailable("gpu-cublas")
== tdata.bHasCuBlas), "failed to match cublas")
self.assertTrue(
(grid.isAccelerationAvailable("gpu-cuda") == tdata.bHasCuda),
"failed to match cuda")
self.assertTrue((grid.isAccelerationAvailable("gpu-default")
== (tdata.bHasCuBlas or tdata.bHasCuda)),
"failed to match cuda")
# acceleration meta-data
lsAvailableAcc = []
if (tdata.bHasBlas): lsAvailableAcc.append("cpu-blas")
if (tdata.bHasCuBlas): lsAvailableAcc.append("gpu-cublas")
if (tdata.bHasCuda): lsAvailableAcc.append("gpu-cuda")
grid.makeLocalPolynomialGrid(2, 1, 2, 1, 'semi-localp')
for accel in lsAvailableAcc:
grid.enableAcceleration(accel)
sA = grid.getAccelerationType()
bTest = ((accel not in sA) or (sA not in accel))
self.assertFalse(bTest, "set/get Acceleration")
def checkPolynomialSpace(self):
'''
Construct grids with specific parameters and check the polynomial
space against known (pen-and-paper) exact spaces.
'''
grid = TasmanianSG.TasmanianSparseGrid()
aA = np.array([[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2], [3, 0], [4, 0]])
grid.makeGlobalGrid(2, 1, 2, 'level', 'clenshaw-curtis')
aP = grid.getGlobalPolynomialSpace(True)
np.testing.assert_equal(aP, aA, "poly space mismatch", True)
aA = np.array([[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [2, 0], [2, 1], [2, 2], [2, 3], [3, 0], [3, 1], [3, 2], [3, 3], [4, 0], [4, 1], [5, 0], [5, 1]])
grid.makeGlobalGrid(2, 1, 2, 'level', 'clenshaw-curtis')
aP = grid.getGlobalPolynomialSpace(False)
np.testing.assert_equal(aP, aA, "poly space mismatch", True)
aA = np.array([[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [2, 0]])
grid.makeSequenceGrid(2, 1, 2, 'level', 'rleja')
aP = grid.getGlobalPolynomialSpace(True)
np.testing.assert_equal(aP, aA, "poly space mismatch", True)
grid.makeSequenceGrid(2, 1, 2, 'level', 'rleja')
aP = grid.getGlobalPolynomialSpace(False)
np.testing.assert_equal(aP, aA, "poly space mismatch", True)
aA = np.array([[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1, 3], [2, 0], [2, 1], [3, 0], [3, 1]])
grid.makeGlobalGrid(2, 1, 1, 'level', 'leja-odd')
aP = grid.getGlobalPolynomialSpace(False)
np.testing.assert_equal(aP, aA, "poly space mismatch", True)
grid.makeSequenceGrid(2, 1, 2, 'level', 'leja')
aP = grid.getGlobalPolynomialSpace(False)
np.testing.assert_equal(aP, aA, "poly space mismatch", True)
def checkAnisoCoeff(self):
'''
Check anisotropic coefficients
'''
grid = TasmanianSG.TasmanianSparseGrid()
grid.makeGlobalGrid(2, 1, 9, 'level', 'rleja')
aP = grid.getPoints()
aV = np.exp(aP[:, 0] + aP[:, 1]**2)
grid.loadNeededPoints(aV.reshape([aP.shape[0], 1]))
aC = grid.estimateAnisotropicCoefficients('iptotal', 0)
self.assertEqual(len(aC.shape), 1,
'dimensions of the estimated anisotropic weight')
self.assertEqual(aC.shape[0], 2,
'dimensions of the estimated anisotropic weight')
self.assertLess(np.abs(float(aC[0]) / float(aC[1]) - 2.0), 0.2,
'wrong anisotropic weights estimated')
aC = grid.estimateAnisotropicCoefficients('ipcurved', 0)
self.assertEqual(len(aC.shape), 1,
'dimensions of the estimated anisotropic weight')
self.assertEqual(aC.shape[0], 4,
'dimensions of the estimated anisotropic weight')
self.assertLess(np.abs(float(aC[0]) / float(aC[1]) - 2.0), 0.2,
'wrong anisotropic weights estimated, alpha curved')
self.assertLess(aC[2], 0.0,
'wrong anisotropic weights estimated, beta 1')
self.assertLess(aC[3], 0.0,
'wrong anisotropic weights estimated, beta 2')
def sparse_grid(n_agents, iDepth, sIdx):
grid = TasmanianSG.TasmanianSparseGrid()
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
# TODO: parameterize this
refinement_level = 1
fTol = 1.E-5
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
for iI in range(iNumP1):
aValTemp = 0
for sIdx in range(5):
aValTemp += (1. / 5) * solver.initial(aPoints[iI], n_agents,
sIdx)[0]
aVals[iI] = aValTemp
grid.loadNeededPoints(aVals)
for ik in range(refinement_level):
grid.setSurplusRefinement(fTol, 1,
"fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
print(ik)
file = open("comparison1.txt", 'w')
for iI in range(iNumP1):
aValTemp = 0
for sIdx in range(5):
aValTemp += (1. / 5) * solver.initial(aPoints[iI], n_agents,
sIdx)[0]
aVals[iI] = aValTemp
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
print(aVals)
file.close()
grid.loadNeededPoints(aVals)
f = open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def checkMetaIO(self):
'''
Test the version I/O, available acceleration, gpu info, print stats
'''
grid = TasmanianSG.TasmanianSparseGrid()
print("Tasmanian Sparse Grids version: {0:1s}".format(
grid.getVersion()))
print(" version major: {0:1d}".format(
grid.getVersionMajor()))
print(" version minor: {0:1d}".format(
grid.getVersionMinor()))
print(" License: {0:1s}".format(
grid.getLicense()))
if (grid.isOpenMPEnabled()):
sStatus = "Enabled"
else:
sStatus = "Disabled"
print(" OpenMP: {0:1s}".format(sStatus))
sAvailableAcceleration = ""
for s in ["cpu-blas", "gpu-cublas", "gpu-cuda", "gpu-magma"]:
if (grid.isAccelerationAvailable(s)):
sAvailableAcceleration += " " + s
print(" Available acceleration:{0:1s}".format(
sAvailableAcceleration))
print(" Available GPUs:")
if (grid.getNumGPUs() > 0):
for iGPU in range(grid.getNumGPUs()):
sName = ""
if ("@CMAKE_CXX_COMPILER_ID@" == "MSVC"):
sName = "Unavailable under Windows"
else:
sName = grid.getGPUName(iGPU)
sMem = grid.getGPUMemory(iGPU)
print(" {0:2d}: {1:20s} with{2:6d}MB RAM".format(
iGPU, sName, sMem))
else:
print(" none")
# covers the printStats() in python and C++
grid.printStats() # empty grid
grid.makeGlobalGrid(2, 0, 1, "level", "gauss-gegenbauer", [], 3.0)
grid.printStats()
grid.makeGlobalGrid(2, 0, 1, "level", "gauss-jacobi", [], 3.0, 3.0)
grid.printStats()
grid.makeGlobalGrid(2, 1, 1, "level", "custom-tabulated", [], 0.0, 0.0,
tdata.sGaussPattersonTableFile)
grid.printStats()
grid.makeSequenceGrid(2, 1, 3, "level", "rleja")
ttc.loadExpN2(grid)
grid.printStats()
grid.makeLocalPolynomialGrid(1, 1, 3)
grid.setDomainTransform(np.array([[2.0, 3.0]]))
grid.printStats()
grid.makeWaveletGrid(2, 1, 1)
grid.printStats()
grid.makeFourierGrid(3, 1, 1, "level")
grid.enableAcceleration("gpu-cuda")
grid.printStats()
def read_previous(iteration):
output = []
for shock in range(5):
v = TasmanianSG.TasmanianSparseGrid()
v.read("valnew_1." + str(iteration) + '.s{}'.format(shock) + ".txt")
output.append(v)
return output
def checkReadWriteLocalp(self):
'''
Test reading and writing of Localp grids.
'''
# iDimension, iOutputs, iDepth, iorder, sRule, useTransform, loadFunciton, limitLevels
lGrids = [
[3, 2, 2, 0, "localp", False, False, False],
[3, 0, 2, 0, "localp-boundary", False, False, False],
[2, 1, 4, 1, "semi-localp", False, False, False],
[3, 1, 3, 2, "localp", True, False, False],
[3, 1, 2, 3, "localp-zero", False, True, False],
[3, 1, 2, 3, "localp-zero", False, True, True],
[3, 1, 3, 4, "semi-localp", True, True, False],
[3, 1, 3, -1, "semi-localp", True, True, False],
[3, 1, 3, -1, "semi-localp", True, True, True],
]
for lT in lGrids:
gridA = TasmanianSG.TasmanianSparseGrid()
gridB = TasmanianSG.TasmanianSparseGrid()
if (lT[7]):
gridA.makeLocalPolynomialGrid(lT[0], lT[1], lT[2], lT[3],
lT[4], [3, 1, 2])
else:
gridA.makeLocalPolynomialGrid(lT[0], lT[1], lT[2], lT[3],
lT[4])
if (lT[5]):
gridA.setDomainTransform(
np.array([[0.0, 1.0], [0.0, 1.0], [-2.0, -1.0]]))
if (lT[6]):
ttc.loadExpN2(gridA)
gridA.write("testSave", bUseBinaryFormat=False)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridA.write("testSave", bUseBinaryFormat=True)
gridB.makeLocalPolynomialGrid(1, 1, 0)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridB.makeGlobalGrid(1, 0, 1, "level", "rleja")
gridB.makeLocalPolynomialGrid(1, 1, 0)
gridB.copyGrid(gridA)
ttc.compareGrids(gridA, gridB)
def sparse_grid(n_agents, iDepth):
grid = TasmanianSG.TasmanianSparseGrid()
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges) # Change domain to K low and upper bar
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
file = open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[
0] # Solve the value function problem for all grid points
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid.loadNeededPoints(aVals) # evaluate interpolant at grid points
#refinement level
for iK in range(refinement_level):
grid.setSurplusRefinement(fTol, 1,
"fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(aPoints.shape[0]):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[
0] # Solve the value function problem for all grid points
# Update interpolant
grid.loadNeededPoints(aVals)
#print(" {0:9d} {1:9d} {2:1.2e}".format(iK+1, grid.getNumPoints()))
#grid2 = TasmanianSG.TasmanianSparseGrid()
#grid2.makeLocalPolynomialGrid(iDim, iOut, refinement_level+iDepth, which_basis, "localp")
#a = grid2.getNumPoints()
#f=open("grid.txt", 'w')
#np.savetxt(f, aPoints, fmt='% 2.16f')
#f.close()
return grid
#======================================================================
def get_iteration_list(iteration):
# Gets all the sparse grids from the iteration specified.
output = []
for shock in range(5):
v = TasmanianSG.TasmanianSparseGrid()
v.read("valnew_1." + str(iteration) + '.s{}'.format(shock) + ".txt")
output.append(v)
return output
def checkReadWriteSequence(self):
'''
Test reading and writing of Sequence grids.
'''
# iDimension, iOutputs, iDepth, sType, sRule, useTransform, loadFunciton, limitLevels
lGrids = [
[3, 2, 2, "level", "leja", False, False, False],
[2, 1, 4, "level", "max-lebesgue", False, False, False],
[3, 1, 3, "level", "rleja", True, False, False],
[3, 1, 3, "level", "rleja", True, False, True],
[3, 1, 2, "iptotal", "min-delta", False, True, False],
[3, 1, 3, "level", "leja", True, True, False],
[3, 1, 3, "level", "leja", True, True, True],
]
for lT in lGrids:
gridA = TasmanianSG.TasmanianSparseGrid()
gridB = TasmanianSG.TasmanianSparseGrid()
if (lT[7]):
gridA.makeSequenceGrid(lT[0], lT[1], lT[2], lT[3], lT[4], [],
[2, 3, 1])
else:
gridA.makeSequenceGrid(lT[0], lT[1], lT[2], lT[3], lT[4])
if (lT[5]):
gridA.setDomainTransform(
np.array([[0.0, 1.0], [0.0, 1.0], [-2.0, -1.0]]))
if (lT[6]):
ttc.loadExpN2(gridA)
gridA.write("testSave", bUseBinaryFormat=False)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridA.write("testSave", bUseBinaryFormat=True)
gridB.makeLocalPolynomialGrid(1, 1, 0)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridB.makeGlobalGrid(1, 0, 1, "level", "rleja")
gridB.makeLocalPolynomialGrid(1, 1, 0)
gridB.copyGrid(gridA)
ttc.compareGrids(gridA, gridB)
def checkReadWriteCustomTabulated(self):
'''
Test reading and writing of the CustomTabulated class.
'''
description = "testCT"
def create_nodes(j):
return np.linspace(-1.0, 1.0, num=j)
def create_weights(j):
weights = np.linspace(0.0, 1.0, num=j)
weights = 2.0 * weights / weights.sum()
return weights
# Read and write from explicitly given data.
for i in range(4):
num_levels = i
num_nodes = np.array([3*(j+1) for j in range(i)])
precision = np.array([2*(j+1)-1 for j in range(i)])
nodes = [create_nodes(j) for j in num_nodes]
weights = [create_weights(j) for j in num_nodes]
ctA = TasmanianSG.makeCustomTabulatedFromData(num_levels, num_nodes, precision, nodes, weights, description) # .
ctB = TasmanianSG.CustomTabulated()
ctA.write("testSave")
ctB.read("testSave")
for i in range(num_levels):
read_weights, read_nodes = ctB.getWeightsNodes(i)
np.testing.assert_almost_equal(read_weights, weights[i])
np.testing.assert_almost_equal(read_nodes, nodes[i])
# Read and write from a file.
ctA = TasmanianSG.makeCustomTabulatedFromFile(tdata.sGaussPattersonTableFile)
ctB = TasmanianSG.CustomTabulated()
ctA.write("testSave")
ctB.read("testSave")
ttc.compareCustomTabulated(ctA, ctB)
for i in range(ctB.getNumLevels()):
read_weights, read_nodes = ctB.getWeightsNodes(i)
grid = TasmanianSG.makeGlobalGrid(1, 0, i, "level", "gauss-patterson")
np.testing.assert_almost_equal(read_weights, grid.getQuadratureWeights())
np.testing.assert_almost_equal(read_nodes, grid.getPoints().flatten())
# Test an error message from wrong read.
try:
ctB.read("Test_If_Bogus_Filename_Produces_an_Error")
except TasmanianSG.TasmanianInputError as TSGError:
TSGError.bShowOnExit = False
self.assertEqual(TSGError.sVariable, "sFilename", "Reading a bogus file properly failed, but the error information is wrong.")
def checkReadWriteFourier(self):
'''
Test reading and writing of Fourier grids.
'''
# iDimension, iOutputs, iDepth, useTransform, loadFunction, useLevelLimits
lGrids = [
[3, 2, 2, False, False, False],
[2, 1, 4, False, False, False],
[3, 1, 1, True, False, False],
[3, 1, 1, True, False, True],
[3, 1, 2, False, True, False],
[3, 1, 2, True, True, True],
[3, 1, 2, True, True, False],
]
for lT in lGrids:
gridA = TasmanianSG.TasmanianSparseGrid()
gridB = TasmanianSG.TasmanianSparseGrid()
if (lT[5]):
gridA.makeFourierGrid(lT[0], lT[1], lT[2], 'level', [1, 1, 2])
else:
gridA.makeFourierGrid(lT[0], lT[1], lT[2], 'level')
if (lT[3]):
gridA.setDomainTransform(
np.array([[0.0, 1.0], [0.0, 1.0], [-2.0, -1.0]]))
if (lT[4]):
ttc.loadExpN2(gridA)
gridA.write("testSave", bUseBinaryFormat=False)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridA.write("testSave", bUseBinaryFormat=True)
gridB.makeLocalPolynomialGrid(1, 1, 0)
gridB.read("testSave")
ttc.compareGrids(gridA, gridB)
gridB.makeGlobalGrid(1, 0, 1, "level", "rleja")
gridB.makeLocalPolynomialGrid(1, 1, 0)
gridB.copyGrid(gridA)
ttc.compareGrids(gridA, gridB)
def sparse_grid(n_agents, iDepth, adaptive=False):
grid = TasmanianSG.TasmanianSparseGrid()
# range of k grid
k_range=np.array([k_bar, k_up])
ranges=np.empty((n_agents, 2)) # lower and upper bound for each agent (dimension)
for i in range(n_agents):
ranges[i]=k_range
iDim=n_agents
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges) ### Sets the lower and upper bound for each dimension
aPoints=grid.getPoints()
### returns the points needed to form the interpolant or the next
### level of refinement following a set***Refinement() call
iNumP1=aPoints.shape[0]
aVals=np.empty([iNumP1, 1]) # space to store value for value function at that interpolation evaluated point
if adaptive:
file=open("comparison0.txt", 'w')
for i in range(refinement_level):
grid.setSurplusRefinement(fTol, -1, "fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[0]
v=aVals[iI]*np.ones((1,1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
else:
file=open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI]=solver.initial(aPoints[iI], n_agents)[0]
v=aVals[iI]*np.ones((1,1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid.loadNeededPoints(aVals)
f=open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid(n_agents, iDepth, refinement_level, fTol, theta):
grid = TasmanianSG.TasmanianSparseGrid()
k_range=np.array([k_bar, k_up])
ranges=np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i]=k_range
iDim=n_agents
# level of grid before refinement
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints=grid.getPoints()
iNumP1=aPoints.shape[0]
aVals=np.empty([iNumP1, 1])
file=open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI]=solver.initial(aPoints[iI], n_agents, theta)[0]
v=aVals[iI]*np.ones((1,1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
#file.close()
grid.loadNeededPoints(aVals)
#refinement level
for iK in range(refinement_level):
grid.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(aPoints.shape[0]):
aVals[iI]=solver.initial(aPoints[iI], n_agents, theta)[0]
v = aVals[iI]*np.ones((1, 1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
grid.loadNeededPoints(aVals)
#aRes = grid.evaluateBatch(aPnts)
#fError1 = max(np.fabs(aRes[:,0] - aTres))
file.close()
f=open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def checkSetClear(self):
'''
Set refinement and clear refinement
'''
grid = TasmanianSG.TasmanianSparseGrid()
grid.makeLocalPolynomialGrid(2, 1, 2, 1, 'semi-localp')
ttc.loadExpN2(grid)
self.assertEqual(grid.getNumNeeded(), 0, "num needed")
grid.setSurplusRefinement(0.0001, 0, 'classic')
self.assertTrue((grid.getNumNeeded() > 0), "num needed")
grid.clearRefinement()
self.assertEqual(grid.getNumNeeded(), 0, "num needed")
def run_all(n_agents):
valnew=TasmanianSG.TasmanianSparseGrid()
if (numstart==0):
valnew=interpol.sparse_grid(n_agents, iDepth)
valnew.write("valnew_1." + str(numstart) + ".txt") #write file to disk for restart
# value function during iteration
else:
valnew.read("valnew_1." + str(numstart) + ".txt") #write file to disk for restart
valold=TasmanianSG.TasmanianSparseGrid()
valold=valnew
for i in range(numstart, numits):
valnew=TasmanianSG.TasmanianSparseGrid()
valnew=interpol_iter.sparse_grid_iter(n_agents, iDepth, valold)
valold=TasmanianSG.TasmanianSparseGrid()
valold=valnew
valnew.write("valnew_1." + str(i+1) + ".txt")
#======================================================================
print "==============================================================="
print " "
print " Computation of a growth model of dimension ", n_agents ," finished after ", numits, " steps"
print " "
print "==============================================================="
#======================================================================
# compute errors
avg_err, max_err =post.ls_error(n_agents, numstart, numits, No_samples)
#======================================================================
print "==============================================================="
print " "
print " Errors are computed -- see errors.txt"
print " "
print "==============================================================="
#======================================================================
return avg_err, max_err
def checkLocalpSurplus(self):
'''
Check surplus refinement for local polynomial grids
'''
grid = TasmanianSG.TasmanianSparseGrid()
grid.makeLocalPolynomialGrid(2, 1, 4, 1, 'semi-localp')
ttc.loadExpN2(grid)
aPoints = grid.getPoints()
aScale = np.array([[1.0 if aPoints[i,0] > 0.0 else 0.0] for i in range(aPoints.shape[0])])
grid.setSurplusRefinement(1.E-9, 0, 'classic', [], aScale)
aNeeded = grid.getNeededPoints()
for iI in range(aNeeded.shape[0]):
self.assertLess(0.0, aNeeded[iI, 0], 'wrong set of needed points after rescaling')
def ls_error(paramL):
k_bar = paramL['k_bar']
k_up = paramL['k_up']
n_agents = paramL['n_agents']
t1 = paramL['numstart']
t2 = paramL['numits']
num_points = paramL['No_samples']
for state in range(5):
file=open('errors.'+'s{}'.format(state)+'.txt', 'w')
np.random.seed(0)
unif=np.random.rand(num_points, n_agents)
k_sample=k_bar+(unif)*(k_up-k_bar)
to_print=np.empty((1,3))
for i in range(t1, t2):
sum_diffs=0
diff = 0
v_prev=TasmanianSG.TasmanianSparseGrid()
v_next=TasmanianSG.TasmanianSparseGrid()
v_prev.read("valnew_1." + str(i) +'.s{}'.format(state)+ ".txt")
v_next.read("valnew_1." + str(i+1) +'.s{}'.format(state)+ ".txt")
#print(v_next.evaluateBatch(v_next.getGrid()))
diff=v_next.evaluateBatch(k_sample) - v_prev.evaluateBatch(k_sample)
max_abs_diff=np.amax(np.fabs(diff))
average = np.average(np.fabs(diff))
to_print[0,0]=i+1
to_print[0,1]=max_abs_diff
to_print[0,2]= average
np.savetxt(file, to_print, fmt='%2.16f')
file.close()