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