def test_computeSingleT(self):
NWorldCoarse = np.array([4, 5, 6])
NCoarseElement = np.array([5, 2, 3])
world = World(NWorldCoarse, NCoarseElement)
d = np.size(NWorldCoarse)
k = 1
iElementWorldCoarse = np.array([2, 1, 2])
ec = lod.elementCorrector(world, k, iElementWorldCoarse)
IPatch = interp.nodalPatchMatrix(ec.iPatchWorldCoarse, ec.NPatchCoarse, NWorldCoarse, NCoarseElement)
NtPatch = np.prod(ec.NPatchCoarse*NCoarseElement)
coefficientPatch = coef.coefficientFine(ec.NPatchCoarse, NCoarseElement, np.ones(NtPatch))
ec.computeCorrectors(coefficientPatch, IPatch)
correctorSum = reduce(np.add, ec.fsi.correctorsList)
self.assertTrue(np.allclose(correctorSum, 0))
ec.computeCoarseQuantities()
# Test that the matrices have the constants in their null space
#self.assertTrue(np.allclose(np.sum(ec.csi.LTPrimeij, axis=1), 0))
#self.assertTrue(np.allclose(np.sum(ec.csi.LTPrimeij, axis=2), 0))
self.assertTrue(np.allclose(np.sum(ec.csi.Kij, axis=0), 0))
self.assertTrue(np.allclose(np.sum(ec.csi.Kij, axis=1), 0))
self.assertTrue(np.allclose(np.sum(ec.csi.Kmsij, axis=0), 0))
self.assertTrue(np.allclose(np.sum(ec.csi.Kmsij, axis=1), 0))
# I had difficulties come up with test cases here. This test
# verifies that most "energy" is in the element T.
elementTIndex = util.convertpCoordinateToIndex(ec.NPatchCoarse-1, ec.iElementPatchCoarse)
self.assertTrue(np.all(ec.csi.muTPrime[elementTIndex] >= ec.csi.muTPrime))
self.assertTrue(not np.all(ec.csi.muTPrime[elementTIndex+1] >= ec.csi.muTPrime))
ec.clearFineQuantities()
def test_trivial(self):
NPatchCoarse = np.array([3,3])
NCoarseElement = np.array([2,2])
NPatchFine = NPatchCoarse*NCoarseElement
Nt = np.prod(NPatchFine)
Np = np.prod(NPatchFine+1)
fixed = util.boundarypIndexMap(NPatchFine)
world = World(NPatchCoarse, NCoarseElement)
patch = Patch(world, 3, 0)
aFlatPatchFine = np.ones(Nt)
ALoc = fem.localStiffnessMatrix(NPatchFine)
APatchFull = fem.assemblePatchMatrix(NPatchFine, ALoc, aFlatPatchFine)
PPatch = fem.assembleProlongationMatrix(NPatchCoarse, NCoarseElement)
IPatchNodal = interp.nodalPatchMatrix(patch)
#IPatchuncL2 = interp.uncoupledL2ProjectionPatchMatrix(np.array([0, 0]), NPatchCoarse, NPatchCoarse, NCoarseElement)
IPatchL2 = interp.L2ProjectionPatchMatrix(patch)
for IPatch in [IPatchNodal, IPatchL2]:
np.random.seed(0)
bPatchFullList = []
self.assertTrue(not lod.ritzProjectionToFinePatch(patch, APatchFull, bPatchFullList, IPatch))
bPatchFullList = [np.zeros(Np)]
projections = lod.ritzProjectionToFinePatch(patch, APatchFull, bPatchFullList, IPatch)
self.assertEqual(len(projections), 1)
self.assertTrue(np.allclose(projections[0], 0*projections[0]))
bPatchFull = np.random.rand(Np)
bPatchFullList = [bPatchFull]
projections = lod.ritzProjectionToFinePatch(patch, APatchFull, bPatchFullList, IPatch)
self.assertTrue(np.isclose(np.linalg.norm(IPatch*projections[0]), 0))
self.assertTrue(np.isclose(np.dot(projections[0], APatchFull*projections[0]),
np.dot(projections[0], bPatchFullList[0])))
self.assertTrue(np.isclose(np.linalg.norm(projections[0][fixed]), 0))
bPatchFullList = [bPatchFull, -bPatchFull]
projections = lod.ritzProjectionToFinePatch(patch, APatchFull, bPatchFullList, IPatch)
self.assertTrue(np.allclose(projections[0], -projections[1]))
bPatchFullList = [np.random.rand(Np), np.random.rand(Np)]
projections = lod.ritzProjectionToFinePatch(patch, APatchFull, bPatchFullList, IPatch)
self.assertTrue(np.isclose(np.dot(projections[1], APatchFull*projections[0]),
np.dot(projections[1], bPatchFullList[0])))
bPatchFull = np.random.rand(Np)
bPatchFullList = [bPatchFull]
projectionCheckAgainst = lod.ritzProjectionToFinePatch(patch, APatchFull, bPatchFullList, IPatch)[0]
for saddleSolver in [#lod.nullspaceOneLevelHierarchySolver(NPatchCoarse, NCoarseElement),
lod.SchurComplementSolver()]:
projection = lod.ritzProjectionToFinePatch(patch, APatchFull, bPatchFullList,
IPatch, saddleSolver)[0]
self.assertTrue(np.isclose(np.max(np.abs(projectionCheckAgainst-projection)), 0))
def test_computeFullDomain(self):
NWorldCoarse = np.array([2, 3, 4], dtype='int64')
NWorldCoarse = np.array([1, 1, 1], dtype='int64')
NCoarseElement = np.array([4, 2, 3], dtype='int64')
NWorldFine = NWorldCoarse*NCoarseElement
NpWorldFine = np.prod(NWorldFine+1)
NpWorldCoarse = np.prod(NWorldCoarse+1)
NtWorldFine = np.prod(NWorldCoarse*NCoarseElement)
np.random.seed(0)
world = World(NWorldCoarse, NCoarseElement)
d = np.size(NWorldCoarse)
IWorld = interp.nodalPatchMatrix(0*NWorldCoarse, NWorldCoarse, NWorldCoarse, NCoarseElement)
aWorld = np.exp(np.random.rand(NtWorldFine))
coefficientWorld = coef.coefficientFine(NWorldCoarse, NCoarseElement, aWorld)
k = np.max(NWorldCoarse)
elementpIndexMap = util.lowerLeftpIndexMap(np.ones_like(NWorldCoarse), NWorldCoarse)
elementpIndexMapFine = util.lowerLeftpIndexMap(NCoarseElement, NWorldFine)
coarsepBasis = util.linearpIndexBasis(NWorldCoarse)
finepBasis = util.linearpIndexBasis(NWorldFine)
correctors = np.zeros((NpWorldFine, NpWorldCoarse))
basis = np.zeros((NpWorldFine, NpWorldCoarse))
for iElementWorldCoarse in it.product(*[np.arange(n, dtype='int64') for n in NWorldCoarse]):
iElementWorldCoarse = np.array(iElementWorldCoarse)
ec = lod.elementCorrector(world, k, iElementWorldCoarse)
ec.computeCorrectors(coefficientWorld, IWorld)
worldpIndices = np.dot(coarsepBasis, iElementWorldCoarse) + elementpIndexMap
correctors[:,worldpIndices] += np.column_stack(ec.fsi.correctorsList)
worldpFineIndices = np.dot(finepBasis, iElementWorldCoarse*NCoarseElement) + elementpIndexMapFine
basis[np.ix_(worldpFineIndices, worldpIndices)] = world.localBasis
AGlob = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, aWorld)
alpha = np.random.rand(NpWorldCoarse)
vH = np.dot(basis, alpha)
QvH = np.dot(correctors, alpha)
# Check norm inequality
self.assertTrue(np.dot(QvH.T, AGlob*QvH) <= np.dot(vH.T, AGlob*vH))
# Check that correctors are really fine functions
self.assertTrue(np.isclose(np.linalg.norm(IWorld*correctors, ord=np.inf), 0))
v = np.random.rand(NpWorldFine, NpWorldCoarse)
v[util.boundarypIndexMap(NWorldFine)] = 0
# The chosen interpolation operator doesn't ruin the boundary conditions.
vf = v-np.dot(basis, IWorld*v)
vf = vf/np.sqrt(np.sum(vf*(AGlob*vf), axis=0))
# Check orthogonality
self.assertTrue(np.isclose(np.linalg.norm(np.dot(vf.T, AGlob*(correctors - basis)), ord=np.inf), 0))
def test_nodalPatchMatrix(self):
iPatchCoarse = np.array([0, 0, 0])
NPatchCoarse = np.array([1, 1, 1])
NWorldCoarse = np.array([1, 1, 1])
NCoarseElement = np.array([1, 1, 1])
INodalPatch = interp.nodalPatchMatrix(iPatchCoarse, NPatchCoarse, NWorldCoarse, NCoarseElement)
self.assertTrue(sparse.linalg.onenormest(INodalPatch - sparse.eye(np.size(INodalPatch,0))) == 0)
iPatchCoarse = np.array([0, 0, 0])
NPatchCoarse = np.array([1, 1, 1])
NWorldCoarse = np.array([1, 1, 1])
NCoarseElement = np.array([2, 1, 1])
INodalPatch = interp.nodalPatchMatrix(iPatchCoarse, NPatchCoarse, NWorldCoarse, NCoarseElement)
self.assertTrue(np.allclose(INodalPatch.todense(),
np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]])))
def computeKmsij(TInd, aPatch, k, boundaryConditions):
tic = time.perf_counter()
patch = lod_periodic.PatchPeriodic(world, k, TInd)
if dim == 1:
IPatch = lambda: interp.nodalPatchMatrix(patch)
else:
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
correctorsList = lod.computeBasisCorrectors(patch, IPatch, aPatch)
csi = lod.computeBasisCoarseQuantities(patch, correctorsList, aPatch)
toc = time.perf_counter()
return patch, correctorsList, csi.Kmsij, csi.muTPrime, toc - tic
def test_ritzProjectionToFinePatchBoundaryConditions(self):
NPatchCoarse = np.array([4, 4])
NCoarseElement = np.array([10, 10])
world = World(NPatchCoarse, NCoarseElement)
patch = Patch(world, 4, 0)
NPatchFine = NPatchCoarse*NCoarseElement
NpFine = np.prod(NPatchFine + 1)
APatchFull = fem.assemblePatchMatrix(NPatchCoarse*NCoarseElement, world.ALocFine)
bPatchFullList = [np.ones(NpFine)]
fixed = util.boundarypIndexMap(NPatchFine)
for IPatch in [interp.L2ProjectionPatchMatrix(patch),
interp.nodalPatchMatrix(patch)]:
schurComplementSolver = lod.SchurComplementSolver()
schurComplementSolution = lod.ritzProjectionToFinePatch(patch,
APatchFull, bPatchFullList,
IPatch,
schurComplementSolver)[0]
self.assertTrue(np.isclose(np.max(np.abs(schurComplementSolution[fixed])), 0))
ii = 0
for p in pList:
for N in range(NSamples):
aPert = build_coefficient.build_randomcheckerboard(
Nepsilon, NFine, alpha, beta, p)
MFull = fem.assemblePatchMatrix(world.NWorldFine, world.MLocFine)
basis = fem.assembleProlongationMatrix(world.NWorldCoarse,
world.NCoarseElement)
bFull = basis.T * MFull * f
faverage = np.dot(MFull * np.ones(NpFine), f)
#true LOD
middle = NCoarse[0] // 2
patchRef = lod_periodic.PatchPeriodic(world, k, middle)
IPatch = lambda: interp.nodalPatchMatrix(patchRef)
computeKmsijT = lambda TInd: computeKmsij(TInd, aPert, IPatch)
patchT, _, KmsijTtrue, _ = zip(
*map(computeKmsijT, range(world.NtCoarse)))
KFulltrue = lod_periodic.assembleMsStiffnessMatrix(world,
patchT,
KmsijTtrue,
periodic=True)
bFull = basis.T * MFull * f
uFulltrue, _ = lod_periodic.solvePeriodic(world, KFulltrue, bFull,
faverage,
boundaryConditions)
uLodCoarsetrue = basis * uFulltrue
#combined LOD
