def test_alive(self):
NWorldCoarse = np.array([5, 5])
NCoarseElement = np.array([20, 20])
NFine = NWorldCoarse * NCoarseElement
NtFine = np.prod(NFine)
NpCoarse = np.prod(NWorldCoarse + 1)
NpFine = np.prod(NWorldCoarse * NCoarseElement + 1)
world = World(NWorldCoarse, NCoarseElement)
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement)
k = 5
pglod = pg.PetrovGalerkinLOD(world, k, IPatchGenerator, 0)
aBase = np.ones(NtFine)
pglod.updateCorrectors(coef.coefficientFine(NWorldCoarse,
NCoarseElement, aBase),
clearFineQuantities=False)
K = pglod.assembleMsStiffnessMatrix()
self.assertTrue(np.all(K.shape == NpCoarse))
basisCorrectors = pglod.assembleBasisCorrectors()
self.assertTrue(np.all(basisCorrectors.shape == (NpFine, NpCoarse)))
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 computeKmsij(TInd):
patch = Patch(world, k, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine_ref)
correctorsList = lod.computeBasisCorrectors(patch, IPatch, aPatch)
csi = lod.computeBasisCoarseQuantities(patch, correctorsList, aPatch)
return patch, correctorsList, csi.Kmsij, csi
def real_computeKmsij(TInd):
print('.', end='', flush=True)
patch = Patch(world, k, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, a_Fine_to_be_approximated)
correctorsList = lod.computeBasisCorrectors(patch, IPatch, aPatch)
csi = lod.computeBasisCoarseQuantities(patch, correctorsList, aPatch)
return patch, correctorsList, csi.Kmsij, csi
def computeRmsi(TInd):
patch = Patch(world, k, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine_ref)
MRhsList = [f_ref[util.extractElementFine(world.NWorldCoarse,
world.NCoarseElement,
patch.iElementWorldCoarse,
extractElements=False)]];
correctorRhs = lod.computeElementCorrector(patch, IPatch, aPatch, None, MRhsList)[0]
Rmsi = lod.computeRhsCoarseQuantities(patch, correctorRhs, aPatch)
return patch, correctorRhs, Rmsi
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 UpdateCorrectors(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch, k2Patch)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch, k2Patch)
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def real_computeRmsi(TInd):
print('.', end='', flush=True)
patch = Patch(world, k, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, a_Fine_to_be_approximated)
MRhsList = [f_ref[util.extractElementFine(world.NWorldCoarse,
world.NCoarseElement,
patch.iElementWorldCoarse,
extractElements=False)]];
correctorRhs = lod.computeElementCorrector(patch, IPatch, aPatch, None, MRhsList)[0]
Rmsi, cetaTPrime = lod.computeRhsCoarseQuantities(patch, correctorRhs, aPatch, True)
return patch, correctorRhs, Rmsi, cetaTPrime
def test_stiffessMatrix(self):
# Compare stiffness matrix from PG object with the one
# computed from correctors and fine stiffness matrix
NWorldFine = np.array([10, 10])
NpFine = np.prod(NWorldFine + 1)
NtFine = np.prod(NWorldFine)
NWorldCoarse = np.array([2, 2])
NCoarseElement = NWorldFine / NWorldCoarse
NtCoarse = np.prod(NWorldCoarse)
NpCoarse = np.prod(NWorldCoarse + 1)
world = World(NWorldCoarse, NCoarseElement)
np.random.seed(0)
aBase = np.random.rand(NtFine)
aCoef = coef.coefficientFine(NWorldCoarse, NCoarseElement, aBase)
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement)
IWorld = IPatchGenerator(0 * NWorldCoarse, NWorldCoarse)
k = 2
printLevel = 0
pglod = pg.PetrovGalerkinLOD(world, k, IPatchGenerator, 0, printLevel)
pglod.updateCorrectors(aCoef, clearFineQuantities=False)
KmsFull = pglod.assembleMsStiffnessMatrix()
KFull = pglod.assembleStiffnessMatrix()
basis = fem.assembleProlongationMatrix(NWorldCoarse, NCoarseElement)
basisCorrectors = pglod.assembleBasisCorrectors()
self.assertTrue(
np.isclose(np.linalg.norm(IWorld * basisCorrectors.todense()), 0))
modifiedBasis = basis - basisCorrectors
AFine = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, aBase)
KmsRef = np.dot(basis.T, AFine * modifiedBasis)
KRef = np.dot(basis.T, AFine * basis)
self.assertTrue(
np.isclose(np.linalg.norm(KFull.todense() - KRef.todense()), 0))
self.assertTrue(
np.isclose(np.linalg.norm(KmsFull.todense() - KmsRef.todense()),
0))
def test_testCsi(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.L2ProjectionPatchMatrix(ec.iPatchWorldCoarse, ec.NPatchCoarse, NWorldCoarse, NCoarseElement)
NtPatch = np.prod(ec.NPatchCoarse*NCoarseElement)
np.random.seed(1)
aPatch = np.random.rand(NtPatch)
coefficientPatch = coef.coefficientFine(ec.NPatchCoarse, NCoarseElement, aPatch)
ec.computeCorrectors(coefficientPatch, IPatch)
ec.computeCoarseQuantities()
TFinetIndexMap = util.extractElementFine(ec.NPatchCoarse,
NCoarseElement,
ec.iElementPatchCoarse,
extractElements=True)
TFinepIndexMap = util.extractElementFine(ec.NPatchCoarse,
NCoarseElement,
ec.iElementPatchCoarse,
extractElements=False)
TCoarsepIndexMap = util.extractElementFine(ec.NPatchCoarse,
np.ones_like(NCoarseElement),
ec.iElementPatchCoarse,
extractElements=False)
APatchFine = fem.assemblePatchMatrix(ec.NPatchCoarse*NCoarseElement, world.ALocFine, aPatch)
AElementFine = fem.assemblePatchMatrix(NCoarseElement, world.ALocFine, aPatch[TFinetIndexMap])
basisPatch = fem.assembleProlongationMatrix(ec.NPatchCoarse, NCoarseElement)
correctorsPatch = np.column_stack(ec.fsi.correctorsList)
localBasis = world.localBasis
KmsijShouldBe = -basisPatch.T*(APatchFine*(correctorsPatch))
KmsijShouldBe[TCoarsepIndexMap,:] += np.dot(localBasis.T, AElementFine*localBasis)
self.assertTrue(np.isclose(np.max(np.abs(ec.csi.Kmsij-KmsijShouldBe)), 0))
def test_testCsi_Kmsij(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])
TInd = util.convertpCoordIndexToLinearIndex(NWorldCoarse, iElementWorldCoarse)
patch = Patch(world, k, TInd)
IPatch = interp.L2ProjectionPatchMatrix(patch)
NtPatch = patch.NtFine
np.random.seed(1)
aPatch = np.random.rand(NtPatch)
basisCorrectorsList = lod.computeBasisCorrectors(patch, IPatch, aPatch)
csi = lod.computeBasisCoarseQuantities(patch, basisCorrectorsList, aPatch)
TFinetIndexMap = util.extractElementFine(patch.NPatchCoarse,
NCoarseElement,
patch.iElementPatchCoarse,
extractElements=True)
TFinepIndexMap = util.extractElementFine(patch.NPatchCoarse,
NCoarseElement,
patch.iElementPatchCoarse,
extractElements=False)
TCoarsepIndexMap = util.extractElementFine(patch.NPatchCoarse,
np.ones_like(NCoarseElement),
patch.iElementPatchCoarse,
extractElements=False)
APatchFine = fem.assemblePatchMatrix(patch.NPatchFine, world.ALocFine, aPatch)
AElementFine = fem.assemblePatchMatrix(NCoarseElement, world.ALocFine, aPatch[TFinetIndexMap])
basisPatch = fem.assembleProlongationMatrix(patch.NPatchCoarse, NCoarseElement)
correctorsPatch = np.column_stack(basisCorrectorsList)
localBasis = world.localBasis
KmsijShouldBe = -basisPatch.T*(APatchFine*(correctorsPatch))
KmsijShouldBe[TCoarsepIndexMap,:] += np.dot(localBasis.T, AElementFine*localBasis)
self.assertTrue(np.isclose(np.max(np.abs(csi.Kmsij-KmsijShouldBe)), 0))
def computeRmsi(TInd):
print('.', end='', flush=True)
patch = Patch(world, k, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine_ref)
MRhsList = [
f_ref[util.extractElementFine(world.NWorldCoarse,
world.NCoarseElement,
patch.iElementWorldCoarse,
extractElements=False)]
]
correctorRhs = lod.computeElementCorrector(patch, IPatch, aPatch, None,
MRhsList)[0]
Rmsi, cetaTPrime = lod.computeRhsCoarseQuantities(patch, correctorRhs,
aPatch, True)
eft_patch = Patch(world, 1, TInd)
a_eft_Patch = lambda: coef.localizeCoefficient(eft_patch, aFine_ref)
etaT = lod.computeSupremumForEf(eft_patch, a_eft_Patch)
return patch, correctorRhs, Rmsi, cetaTPrime, etaT
def PGsolver(world, ABase, f,k):
NWorldFine = world.NWorldFine
NWorldCoarse = world.NWorldCoarse
NCoarseElement = world.NCoarseElement
boundaryConditions = world.boundaryConditions
NpFine = np.prod(NWorldFine+1)
NpCoarse = np.prod(NWorldCoarse+1)
#interpolant
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
#Coefficient (need flatten form)
aCoef = coef.coefficientFine(NWorldCoarse, NCoarseElement, ABase)
pglod = pg_pert.PerturbedPetrovGalerkinLOD(aCoef, world, k, IPatchGenerator, 0)
pglod.originCorrectors(clearFineQuantities=False)
KFull = pglod.assembleMsStiffnessMatrix()
MFull = fem.assemblePatchMatrix(NWorldCoarse, world.MLocCoarse)
free = util.interiorpIndexMap(NWorldCoarse)
bFull = MFull*f
KFree = KFull[free][:,free]
bFree = bFull[free]
xFree = sparse.linalg.spsolve(KFree, bFree)
basis = fem.assembleProlongationMatrix(NWorldCoarse, NCoarseElement)
basisCorrectors = pglod.assembleBasisCorrectors()
modifiedBasis = basis - basisCorrectors
xFull = np.zeros(NpCoarse)
xFull[free] = xFree
uLodCoarse = xFull
uLodFine = modifiedBasis*xFull
return uLodCoarse, uLodFine
def UpdateCorrectors(self, TInd):
# print(" UPDATING {}".format(TInd))
patch = Patch(self.world, self.k, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, self.boundaryConditions)
rPatch = lambda: coef.localizeCoefficient(
patch, self.a_Fine_to_be_approximated)
MRhsList = [
self.f_trans[util.extractElementFine(self.world.NWorldCoarse,
self.world.NCoarseElement,
patch.iElementWorldCoarse,
extractElements=False)]
]
correctorsList = lod.computeBasisCorrectors(patch, IPatch, rPatch)
csi = lod.computeBasisCoarseQuantities(patch, correctorsList, rPatch)
correctorRhs = lod.computeElementCorrector(patch, IPatch, rPatch, None,
MRhsList)[0]
Rmsij = lod.computeRhsCoarseQuantities(patch, correctorRhs, rPatch)
return patch, correctorsList, csi.Kmsij, Rmsij, correctorRhs
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))
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])
TInd = util.convertpCoordIndexToLinearIndex(NWorldCoarse, iElementWorldCoarse)
patch = Patch(world, k, TInd)
IPatch = interp.L2ProjectionPatchMatrix(patch)
NtPatch = patch.NtFine
aPatch = np.ones(NtPatch)
basisCorrectorsList = lod.computeBasisCorrectors(patch, IPatch, aPatch)
correctorSum = reduce(np.add, basisCorrectorsList)
self.assertTrue(np.allclose(correctorSum, 0))
csi = lod.computeBasisCoarseQuantities(patch, basisCorrectorsList, aPatch)
# 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(csi.Kij, axis=0), 0))
self.assertTrue(np.allclose(np.sum(csi.Kij, axis=1), 0))
self.assertTrue(np.allclose(np.sum(csi.Kmsij, axis=0), 0))
self.assertTrue(np.allclose(np.sum(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.convertpCoordIndexToLinearIndex(patch.NPatchCoarse-1, patch.iElementPatchCoarse)
self.assertTrue(np.all(csi.muTPrime[elementTIndex] >= csi.muTPrime))
self.assertTrue(not np.all(csi.muTPrime[elementTIndex+1] >= csi.muTPrime))
def helmholtz_nonlinear_adaptive(mapper, fineLvl, coarseLvl, maxit):
fineExp = fineLvl
NFine = np.array([2**fineLvl, 2**fineLvl])
NpFine = np.prod(NFine + 1)
N = 2**coarseLvl
tolList = [2.0, 1.0, 0.5, 0.25, 0.125, 0.0625, 0.]
ell = 2 # localization parameter
k = 15. # wavenumber
maxit_Fine = 200
xt = util.tCoordinates(NFine)
xp = util.pCoordinates(NFine)
# multiscale coefficients on the scale NFine-2
np.random.seed(444)
sizeK = np.size(xt[:, 0])
nFine = NFine[0]
# determine domain D_eps = supp(1-n) = supp(1-A) (all equal for the moment)
indicesIn = (xt[:, 0] > 0.15) & (xt[:, 0] < 0.85) & (xt[:, 1] > 0.15) & (
xt[:, 1] < 0.85)
indicesInEps = (xt[:, 0] > 0.15) & (xt[:, 0] < 0.85) & (
xt[:, 1] > 0.15) & (xt[:, 1] < 0.85)
# coefficients
aFine = np.ones(xt.shape[0])
cn = .05 # lower bound on n
Cn = 1. # upper bound on n
nEpsPro = coeffi(xt[:, 0], xt[:, 1], fineLvl)
k2Fine = k**2 * np.ones(xt.shape[0])
k2Fine[indicesIn] = k**2 * ((Cn - cn) * nEpsPro[indicesIn] + cn)
kFine = k * np.ones(xt.shape[0])
Ceps = 0.3 # upper bound on eps (lower bound is 0)
epsEpsPro = np.ones(sizeK)
epsFine = np.zeros(xt.shape[0])
epsFine[indicesInEps] = Ceps * epsEpsPro[indicesInEps] # 0 OR Ceps
plotC = np.ones(sizeK)
plotC[indicesIn] = nEpsPro[indicesIn]
drawCoefficient(NFine, plotC)
xC = xp[:, 0]
yC = xp[:, 1]
# define right-hand side and boundary condition
def funcF(x, y):
res = 100 * np.ones(x.shape, dtype='complex128')
return res
f = funcF(xC, yC)
# reference solution
uSol = np.zeros(NpFine, dtype='complex128')
# boundary conditions
boundaryConditions = np.array([[1, 1], [1, 1]])
worldFine = World(NFine, np.array([1, 1]), boundaryConditions)
# fine matrices
BdFineFEM = fem.assemblePatchBoundaryMatrix(
NFine, fem.localBoundaryMassMatrixGetter(NFine))
MFineFEM = fem.assemblePatchMatrix(NFine, fem.localMassMatrix(NFine))
KFineFEM = fem.assemblePatchMatrix(
NFine, fem.localStiffnessMatrix(NFine)) # , aFine)
kBdFine = fem.assemblePatchBoundaryMatrix(
NFine, fem.localBoundaryMassMatrixGetter(NFine), kFine)
KFine = fem.assemblePatchMatrix(NFine, fem.localStiffnessMatrix(NFine),
aFine)
print('***computing reference solution***')
uOldFine = np.zeros(NpFine, dtype='complex128')
for it in np.arange(maxit_Fine):
print('-- itFine = %d' % it)
knonlinUpreFine = np.abs(uOldFine)
knonlinUFine = func.evaluateCQ1(NFine, knonlinUpreFine, xt)
k2FineUfine = np.copy(k2Fine)
k2FineUfine[indicesInEps] *= (
1. + epsFine[indicesInEps] * knonlinUFine[indicesInEps]**2
) # full coefficient, including nonlinearity
k2MFine = fem.assemblePatchMatrix(
NFine, fem.localMassMatrix(NFine),
k2FineUfine) # weighted mass matrix, updated in every iteration
nodesFine = np.arange(worldFine.NpFine)
fixFine = util.boundarypIndexMap(NFine, boundaryConditions == 0)
freeFine = np.setdiff1d(nodesFine, fixFine)
# right-hand side
fhQuad = MFineFEM * f
# fine system
lhsh = KFine[freeFine][:, freeFine] - k2MFine[
freeFine][:, freeFine] + 1j * kBdFine[freeFine][:, freeFine]
rhsh = fhQuad[freeFine]
xFreeFine = sparse.linalg.spsolve(lhsh, rhsh)
xFullFine = np.zeros(worldFine.NpFine, dtype='complex128')
xFullFine[freeFine] = xFreeFine
uOldFine = np.copy(xFullFine)
# residual - used as stopping criterion
knonlinU = np.abs(uOldFine)
knonlinUFineIt = func.evaluateCQ1(NFine, knonlinU, xt)
k2FineUfineIt = np.copy(k2Fine)
k2FineUfineIt[indicesInEps] *= (
1. + epsFine[indicesInEps] * knonlinUFineIt[indicesInEps]**2
) # update full coefficient, including nonlinearity
k2MFineIt = fem.assemblePatchMatrix(NFine, fem.localMassMatrix(NFine),
k2FineUfineIt)
Ares = KFine - k2MFineIt + 1j * kBdFine
residual = np.linalg.norm(Ares * xFullFine - fhQuad) / np.linalg.norm(
Ares * xFullFine)
print('---- residual = %.4e' % residual)
if residual < 1e-12:
break # stopping criterion
uSol = xFullFine # final fine reference solution
print('***reference solution computed***\n')
counter = 0 # for figures
print('***computing multiscale approximations***')
relErrEnergy = np.zeros([len(tolList), maxit])
for tol in tolList:
counter += 1
print('H = %.4e, tol = %.4e' % (1. / N, tol))
NWorldCoarse = np.array([N, N])
NCoarseElement = NFine // NWorldCoarse
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
NpCoarse = np.prod(NWorldCoarse + 1)
uOldUps = np.zeros(NpFine, dtype='complex128')
for it in np.arange(maxit):
print('-- it = %d:' % it)
knonlinUpre = np.abs(uOldUps)
knonlinU = func.evaluateCQ1(NFine, knonlinUpre, xt)
k2FineU = np.copy(k2Fine)
k2FineU[indicesInEps] *= (
1. + epsFine[indicesInEps] * knonlinU[indicesInEps]**2)
print('---- starting computation of correctors')
def computeLocalContribution(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def computeIndicators(TInd):
k2FineUPatch = lambda: coef.localizeCoefficient(
patchT[TInd], k2FineU)
k2FineUOldPatch = lambda: coef.localizeCoefficient(
patchT[TInd], k2FineUOld)
E_vh = lod.computeErrorIndicatorCoarse_helmholtz(
patchT[TInd], muTPrime[TInd], k2FineUOldPatch,
k2FineUPatch)
return E_vh
def UpdateCorrectors(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch, k2Patch)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def UpdateElements(tol, E, Kmsij_old, Mmsij_old, Bdmsij_old,
correctors_old, mu_old):
print('---- apply tolerance')
Elements_to_be_updated = []
for (i, eps) in E.items():
if eps > tol * k**2:
Elements_to_be_updated.append(i)
if len(E) > 0:
print(
'---- percentage of non-zero element correctors to be updated: %.4f'
% (100 * np.size(Elements_to_be_updated) / len(E)),
flush=True)
print(
'---- total percentage of element correctors to be updated: %.4f'
%
(100 * np.size(Elements_to_be_updated) / len(mu_old)),
flush=True)
print('---- update local contributions')
KmsijT_list = list(np.copy(Kmsij_old))
MmsijT_list = list(np.copy(Mmsij_old))
BdmsijT_list = list(np.copy(Bdmsij_old))
muT_list = np.copy(mu_old)
for T in np.setdiff1d(range(world.NtCoarse),
Elements_to_be_updated):
patch = Patch(world, ell, T)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctors_old[T], aPatch, kPatch, k2Patch)
KmsijT_list[T] = csi.Kmsij
MmsijT_list[T] = csi.Mmsij
BdmsijT_list[T] = csi.Bdmsij
muT_list[T] = csi.muTPrime
if np.size(Elements_to_be_updated) != 0:
#print('---- update correctors')
patchT_irrelevant, correctorsListTNew, KmsijTNew, MmsijTNew, BdmsijTNew, muTPrimeNew = zip(
*mapper(UpdateCorrectors, Elements_to_be_updated))
#print('---- update correctorsList')
correctorsListT_list = list(np.copy(correctors_old))
i = 0
for T in Elements_to_be_updated:
KmsijT_list[T] = KmsijTNew[i]
correctorsListT_list[T] = correctorsListTNew[i]
MmsijT_list[T] = MmsijTNew[i]
BdmsijT_list[T] = BdmsijTNew[i]
muT_list[T] = muTPrimeNew[i]
i += 1
KmsijT = tuple(KmsijT_list)
correctorsListT = tuple(correctorsListT_list)
MmsijT = tuple(MmsijT_list)
BdmsijT = tuple(BdmsijT_list)
muTPrime = tuple(muT_list)
return correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime
else:
KmsijT = tuple(KmsijT_list)
MmsijT = tuple(MmsijT_list)
BdmsijT = tuple(BdmsijT_list)
muTPrime = tuple(muT_list)
return correctors_old, KmsijT, MmsijT, BdmsijT, muTPrime
if it == 0:
patchT, correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime = zip(
*mapper(computeLocalContribution, range(world.NtCoarse)))
else:
E_vh = list(mapper(computeIndicators, range(world.NtCoarse)))
print(
'---- maximal value error estimator for basis correctors {}'
.format(np.max(E_vh)))
E = {i: E_vh[i] for i in range(np.size(E_vh)) if E_vh[i] > 0}
# loop over elements with possible recomputation of correctors
correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime = UpdateElements(
tol, E, KmsijT, MmsijT, BdmsijT, correctorsListT,
muTPrime) # tol scaled by maximal error indicator
print('---- finished computation of correctors')
KLOD = pglod.assembleMsStiffnessMatrix(
world, patchT, KmsijT) # ms stiffness matrix
k2MLOD = pglod.assembleMsStiffnessMatrix(world, patchT,
MmsijT) # ms mass matrix
kBdLOD = pglod.assembleMsStiffnessMatrix(
world, patchT, BdmsijT) # ms boundary matrix
MFEM = fem.assemblePatchMatrix(NWorldCoarse, world.MLocCoarse)
BdFEM = fem.assemblePatchBoundaryMatrix(
NWorldCoarse, fem.localBoundaryMassMatrixGetter(NWorldCoarse))
print('---- coarse matrices assembled')
nodes = np.arange(world.NpCoarse)
fix = util.boundarypIndexMap(NWorldCoarse, boundaryConditions == 0)
free = np.setdiff1d(nodes, fix)
assert (nodes.all() == free.all())
# compute global interpolation matrix
patchGlobal = Patch(world, NFine[0] + 2, 0)
IH = interp.L2ProjectionPatchMatrix(patchGlobal,
boundaryConditions)
assert (IH.shape[0] == NpCoarse)
basis = fem.assembleProlongationMatrix(NWorldCoarse,
NCoarseElement)
fHQuad = basis.T * MFineFEM * f
print('---- solving coarse system')
# coarse system
lhsH = KLOD[free][:, free] - k2MLOD[
free][:, free] + 1j * kBdLOD[free][:, free]
rhsH = fHQuad[free]
xFree = sparse.linalg.spsolve(lhsH, rhsH)
basisCorrectors = pglod.assembleBasisCorrectors(
world, patchT, correctorsListT)
modifiedBasis = basis - basisCorrectors
xFull = np.zeros(world.NpCoarse, dtype='complex128')
xFull[free] = xFree
uLodCoarse = basis * xFull
uLodFine = modifiedBasis * xFull
uOldUps = np.copy(uLodFine)
k2FineUOld = np.copy(k2FineU)
Err = np.sqrt(
np.dot((uSol - uLodFine).conj(), KFineFEM *
(uSol - uLodFine)) + k**2 *
np.dot((uSol - uLodFine).conj(), MFineFEM * (uSol - uLodFine)))
ErrEnergy = Err / np.sqrt(
np.dot((uSol).conj(), KFineFEM *
(uSol)) + k**2 * np.dot((uSol).conj(), MFineFEM *
(uSol)))
print('---- ', np.abs(ErrEnergy),
'\n***********************************************')
# save errors in arrays
relErrEnergy[counter - 1, it] = ErrEnergy
print('\n')
its = np.arange(1, maxit + 1)
plt.figure(1)
plt.title(
'Relative energy errors w.r.t iterations for different tolerances - Ex 3'
)
plt.plot(its, relErrEnergy[0, :], 'x--', color='black', label='tol = 2')
plt.plot(its, relErrEnergy[1, :], 'x-', color='blue', label='tol = 1')
plt.plot(its, relErrEnergy[2, :], 'x-', color='green', label='tol = 0.5')
plt.plot(its, relErrEnergy[3, :], 'x-', color='orange', label='tol = 0.25')
plt.plot(its, relErrEnergy[4, :], 'x-', color='red', label='tol = 0.125')
plt.plot(its,
relErrEnergy[5, :],
'x-',
color='magenta',
label='tol = 0.0625')
plt.plot(its, relErrEnergy[6, :], 'x--', color='black', label='tol = 0')
plt.yscale('log')
plt.legend()
plt.show()
def compute_perturbed_MsStiffness(world, aPert, aRef, KmsijRef, muTPrimeRef, k,
update_percentage):
computePatch = lambda TInd: lod_periodic.PatchPeriodic(world, k, TInd)
patchT = list(map(computePatch, range(world.NtCoarse)))
dim = np.size(world.NWorldFine)
if dim == 2:
middle = world.NWorldCoarse[1] // 2 * world.NWorldCoarse[
0] + world.NWorldCoarse[0] // 2 #2d!!!
elif dim == 1:
middle = world.NWorldCoarse[0] // 2
patchRef = lod_periodic.PatchPeriodic(world, k, middle)
IPatch = lambda: interp.L2ProjectionPatchMatrix(patchRef)
def computeIndicator(TInd):
aPatch = lambda: lod_periodic.localizeCoefficient(
patchT[TInd], aPert, periodic=True) # true coefficient
E_vh = lod.computeErrorIndicatorCoarseFromCoefficients(
patchT[TInd], muTPrimeRef, aRef, aPatch)
return E_vh
def UpdateCorrectors(TInd):
rPatch = lambda: lod_periodic.localizeCoefficient(
patchT[TInd], aPert, periodic=True)
correctorsList = lod.computeBasisCorrectors(patchT[TInd], IPatch,
rPatch)
csi = lod.computeBasisCoarseQuantities(patchT[TInd], correctorsList,
rPatch)
return patchT[TInd], correctorsList, csi.Kmsij
def UpdateElements(tol, E, Kmsij_old):
Elements_to_be_updated = []
for (i, eps) in E.items():
if eps > tol:
Elements_to_be_updated.append(i)
if np.size(Elements_to_be_updated) != 0:
patchT_irrelevant, correctorsListT_irrelevant, KmsijTNew = zip(
*map(UpdateCorrectors, Elements_to_be_updated))
KmsijT_list = list(np.copy(Kmsij_old))
i = 0
for T in Elements_to_be_updated:
KmsijT_list[T] = np.copy(KmsijTNew[i])
i += 1
KmsijT = tuple(KmsijT_list)
return KmsijT
else:
return Kmsij_old
E_vh = list(map(computeIndicator, range(world.NtCoarse)))
E = {i: E_vh[i] for i in range(np.size(E_vh)) if E_vh[i] > 0}
# loop over elements with possible recomputation of correctors
tol_relative = np.quantile(E_vh,
1. - update_percentage,
interpolation='higher')
KmsijRefList = [KmsijRef for _ in range(world.NtCoarse)
] #tile up the stiffness matrix for one element
KmsijT = UpdateElements(tol_relative, E, KmsijRefList)
#assembly of matrix
KFull = lod_periodic.assembleMsStiffnessMatrix(world,
patchT,
KmsijT,
periodic=True)
return KFull, E_vh
def test_2d_exactSolution(self):
NWorldFine = np.array([30, 40])
NpFine = np.prod(NWorldFine + 1)
NtFine = np.prod(NWorldFine)
NWorldCoarse = np.array([3, 4])
NCoarseElement = NWorldFine / NWorldCoarse
NtCoarse = np.prod(NWorldCoarse)
NpCoarse = np.prod(NWorldCoarse + 1)
boundaryConditions = np.array([[0, 0], [1, 1]])
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
np.random.seed(0)
aBaseSquare = np.exp(5 * np.random.random_sample(NWorldFine[0]))
aBaseCube = np.tile(aBaseSquare, [NWorldFine[1], 1])
aBaseCube = aBaseCube[..., np.newaxis]
aBase = aBaseCube.flatten()
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
rCoarse = np.ones(NtCoarse)
aCoef = coef.coefficientCoarseFactor(NWorldCoarse, NCoarseElement,
aBase, rCoarse)
k = 4
printLevel = 0
epsilonTol = 0.05
pglod = pg.PetrovGalerkinLOD(world, k, IPatchGenerator, epsilonTol,
printLevel)
pglod.updateCorrectors(aCoef, clearFineQuantities=False)
boundaryMap = boundaryConditions == 0
fixed = util.boundarypIndexMap(NWorldCoarse, boundaryMap)
free = np.setdiff1d(np.arange(0, NpCoarse), fixed)
coords = util.pCoordinates(NWorldCoarse)
xC = coords[:, 0]
yC = coords[:, 1]
g = 1 - xC
firstIteration = True
# First case is to not modify. Error should be 0
# The other cases modify one, a few or half of the coarse elements to different degrees.
rCoarseModPairs = [([], []), ([0], [2.]), ([10], [3.]),
([4, 3, 2], [1.3, 1.5, 1.8])]
rCoarseModPairs.append((range(NtCoarse / 2), [2] * NtCoarse))
rCoarseModPairs.append((range(NtCoarse / 2), [0.9] * NtCoarse))
rCoarseModPairs.append((range(NtCoarse / 2), [0.95] * NtCoarse))
for i, rCoarseModPair in zip(count(), rCoarseModPairs):
for ind, val in zip(rCoarseModPair[0], rCoarseModPair[1]):
rCoarse[ind] *= val
aCoef = coef.coefficientCoarseFactor(NWorldCoarse, NCoarseElement,
aBase, rCoarse)
pglod.updateCorrectors(aCoef, clearFineQuantities=False)
KmsFull = pglod.assembleMsStiffnessMatrix()
bFull = -KmsFull * g
KmsFree = KmsFull[free][:, free]
bFree = bFull[free]
xFree = sparse.linalg.spsolve(KmsFree, bFree)
basis = fem.assembleProlongationMatrix(NWorldCoarse,
NCoarseElement)
basisCorrectors = pglod.assembleBasisCorrectors()
modifiedBasis = basis - basisCorrectors
xFull = np.zeros(NpCoarse)
xFull[free] = xFree
uLodFine = modifiedBasis * (xFull + g)
gFine = basis * g
uFineFull, AFine, MFine = femsolver.solveFine(
world, aCoef.aFine, None, -gFine, boundaryConditions)
uFineFull += gFine
errorFineA = np.sqrt(
np.dot(uFineFull - uLodFine, AFine * (uFineFull - uLodFine)))
errorFineM = np.sqrt(
np.dot(uFineFull - uLodFine, MFine * (uFineFull - uLodFine)))
if firstIteration:
self.assertTrue(np.isclose(errorFineA, 0))
self.assertTrue(np.isclose(errorFineM, 0))
# Also compute upscaled solution and compare with uFineFull
uLodFineUpscaled = basis * (
xFull + g) - pglod.computeCorrection(ARhsFull=basis *
(xFull + g))
self.assertTrue(np.allclose(uLodFineUpscaled, uLodFine))
firstIteration = False
else:
# For this problem, it seems that
# error < 1.1*errorTol
self.assertTrue(errorFineA <= 1.1 * epsilonTol)
def test_2d_flux(self):
# Stripes perpendicular to flow direction gives effective
# permeability as the harmonic mean of the permeabilities of
# the stripes.
NWorldFine = np.array([20, 20])
NpFine = np.prod(NWorldFine + 1)
NtFine = np.prod(NWorldFine)
NWorldCoarse = np.array([2, 2])
NCoarseElement = NWorldFine / NWorldCoarse
NtCoarse = np.prod(NWorldCoarse)
NpCoarse = np.prod(NWorldCoarse + 1)
boundaryConditions = np.array([[0, 0], [1, 1]])
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
np.random.seed(0)
aBaseSquare = np.exp(5 * np.random.random_sample(NWorldFine[1]))
aBaseCube = np.tile(aBaseSquare[..., np.newaxis], [NWorldFine[0], 1])
aBaseCube = aBaseCube[..., np.newaxis]
aBase = aBaseCube.flatten()
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
aCoef = coef.coefficientFine(NWorldCoarse, NCoarseElement, aBase)
k = 2
printLevel = 0
pglod = pg.PetrovGalerkinLOD(world, k, IPatchGenerator, 0, printLevel)
pglod.updateCorrectors(aCoef)
KmsFull = pglod.assembleMsStiffnessMatrix()
coords = util.pCoordinates(NWorldCoarse)
xC = coords[:, 0]
g = 1 - xC
bFull = -KmsFull * g
boundaryMap = boundaryConditions == 0
fixed = util.boundarypIndexMap(NWorldCoarse, boundaryMap)
free = np.setdiff1d(np.arange(0, NpCoarse), fixed)
KmsFree = KmsFull[free][:, free]
bFree = bFull[free]
xFree = sparse.linalg.spsolve(KmsFree, bFree)
xFull = np.zeros(NpCoarse)
xFull[free] = xFree
MGammaLocGetter = fem.localBoundaryMassMatrixGetter(NWorldCoarse)
MGammaFull = fem.assemblePatchBoundaryMatrix(NWorldCoarse,
MGammaLocGetter,
boundaryMap=boundaryMap)
# Solve (F, w) = a(u0, w) + a(g, w) in space of fixed DoFs only
KmsFixedFull = KmsFull[fixed]
cFixed = KmsFixedFull * (xFull + g)
MGammaFixed = MGammaFull[fixed][:, fixed]
FFixed = sparse.linalg.spsolve(MGammaFixed, cFixed)
FFull = np.zeros(NpCoarse)
FFull[fixed] = FFixed
self.assertTrue(
np.isclose(np.mean(FFixed[FFixed > 0]), stats.hmean(aBaseSquare)))
def test_1d_toReference(self):
NWorldFine = np.array([200])
NWorldCoarse = np.array([10])
NCoarseElement = NWorldFine / NWorldCoarse
boundaryConditions = np.array([[0, 0]])
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
NpFine = np.prod(NWorldFine + 1)
NtFine = np.prod(NWorldFine)
NpCoarse = np.prod(NWorldCoarse + 1)
aBase = np.zeros(NtFine)
aBase[:90] = 1
aBase[90:] = 2
k = 10
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
aCoef = coef.coefficientFine(NWorldCoarse, NCoarseElement, aBase)
pglod = pg.PetrovGalerkinLOD(world, k, IPatchGenerator, 0)
pglod.updateCorrectors(aCoef, clearFineQuantities=False)
KmsFull = pglod.assembleMsStiffnessMatrix()
KFull = pglod.assembleStiffnessMatrix()
MFull = fem.assemblePatchMatrix(NWorldCoarse, world.MLocCoarse)
free = util.interiorpIndexMap(NWorldCoarse)
coords = util.pCoordinates(NWorldCoarse)
g = 1 - coords[:, 0]
bFull = -KmsFull * g
KmsFree = KmsFull[free][:, free]
bFree = bFull[free]
xFree = sparse.linalg.spsolve(KmsFree, bFree)
basis = fem.assembleProlongationMatrix(NWorldCoarse, NCoarseElement)
basisCorrectors = pglod.assembleBasisCorrectors()
modifiedBasis = basis - basisCorrectors
xFull = np.zeros(NpCoarse)
xFull[free] = xFree
uLodCoarse = basis * (xFull + g)
uLodFine = modifiedBasis * (xFull + g)
coordsFine = util.pCoordinates(NWorldFine)
gFine = 1 - coordsFine[:, 0]
uFineFull, AFine, _ = femsolver.solveFine(world, aBase, None, -gFine,
boundaryConditions)
uFineFull += gFine
errorFine = np.sqrt(
np.dot(uFineFull - uLodFine, AFine * (uFineFull - uLodFine)))
self.assertTrue(np.isclose(errorFine, 0))
# Also compute upscaled solution and compare with uFineFull
uLodFineUpscaled = basis * (xFull + g) - pglod.computeCorrection(
ARhsFull=basis * (xFull + g))
self.assertTrue(np.allclose(uLodFineUpscaled, uLodFine))
def test_computeCoarseErrorIndicatorFlux(self):
NWorldCoarse = np.array([7, 7], dtype='int64')
NCoarseElement = np.array([10, 10], dtype='int64')
NWorldFine = NWorldCoarse * NCoarseElement
NpWorldFine = np.prod(NWorldFine + 1)
NpWorldCoarse = np.prod(NWorldCoarse + 1)
NtWorldFine = np.prod(NWorldCoarse * NCoarseElement)
NtWorldCoarse = np.prod(NWorldCoarse)
np.random.seed(0)
world = World(NWorldCoarse, NCoarseElement)
d = np.size(NWorldCoarse)
aBase = np.exp(np.random.rand(NtWorldFine))
k = np.max(NWorldCoarse)
iElementWorldCoarse = np.array([3, 3])
rCoarseFirst = 1 + 3 * np.random.rand(NtWorldCoarse)
coefFirst = coef.CoefficientCoarseFactor(NWorldCoarse, NCoarseElement,
aBase, rCoarseFirst)
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement)
ec = lod_flux.CoarseBasisElementCorrectorFlux(world, k,
iElementWorldCoarse,
IPatchGenerator)
ec.computeCorrectors(coefFirst)
ec.computeCoarseQuantities()
# If both rCoarseFirst and rCoarseSecond are equal, the error indicator should be zero
rCoarseSecond = np.array(rCoarseFirst)
self.assertTrue(
np.isclose(ec.computeCoarseErrorIndicatorFlux(rCoarseSecond), 0))
coefSecond = coef.CoefficientCoarseFactor(NWorldCoarse, NCoarseElement,
aBase, rCoarseSecond)
self.assertTrue(np.isclose(ec.computeErrorIndicatorFine(coefSecond),
0))
# If rCoarseSecond is not rCoarseFirst, the error indicator should not be zero
rCoarseSecond = 2 * np.array(rCoarseFirst)
self.assertTrue(
ec.computeCoarseErrorIndicatorFlux(rCoarseSecond) >= 0.1)
coefSecond = coef.CoefficientCoarseFactor(NWorldCoarse, NCoarseElement,
aBase, rCoarseSecond)
self.assertTrue(ec.computeErrorIndicatorFine(coefSecond) >= 0.1)
# Fine should be smaller than coarse estimate
self.assertTrue(
ec.computeErrorIndicatorFine(coefSecond) <
ec.computeCoarseErrorIndicatorFlux(rCoarseSecond))
# If rCoarseSecond is different in the element itself, the error
# indicator should be large
elementCoarseIndex = util.convertpCoordIndexToLinearIndex(
NWorldCoarse - 1, iElementWorldCoarse)
rCoarseSecond = np.array(rCoarseFirst)
rCoarseSecond[elementCoarseIndex] *= 2
saveForNextTest = ec.computeCoarseErrorIndicatorFlux(rCoarseSecond)
self.assertTrue(saveForNextTest >= 0.1)
coefSecond = coef.CoefficientCoarseFactor(NWorldCoarse, NCoarseElement,
aBase, rCoarseSecond)
fineResult = ec.computeErrorIndicatorFine(coefSecond)
self.assertTrue(fineResult >= 0.1)
self.assertTrue(
ec.computeErrorIndicatorFine(coefSecond) <
ec.computeCoarseErrorIndicatorFlux(rCoarseSecond))
# A difference in the perifery should be smaller than in the center
rCoarseSecond = np.array(rCoarseFirst)
rCoarseSecond[0] *= 2
self.assertTrue(
saveForNextTest > ec.computeCoarseErrorIndicatorFlux(rCoarseSecond)
)
# Again, but closer
rCoarseSecond = np.array(rCoarseFirst)
rCoarseSecond[elementCoarseIndex - 1] *= 2
self.assertTrue(
saveForNextTest > ec.computeCoarseErrorIndicatorFlux(rCoarseSecond)
)
ii = 0
for p in pList:
if p == 0.1:
mean_time_true = 0.
mean_time_perturbed = 0.
mean_time_combined = 0.
for N in range(NSamples):
aPert = build_coefficient.build_randomcheckerboard(
Nepsilon, NFine, alpha, beta, p)
#true LOD
middle = world.NWorldCoarse[1] // 2 * world.NWorldCoarse[
0] + world.NWorldCoarse[0] // 2
patchRef = lod_periodic.PatchPeriodic(world, k, middle)
IPatch = lambda: interp.L2ProjectionPatchMatrix(patchRef)
computeKmsijT = lambda TInd: computeKmsij(TInd, aPert, IPatch)
if p == 0.1:
tic = time.perf_counter()
patchT, correctorsTtrue, KmsijTtrue, _ = zip(
*map(computeKmsijT, range(world.NtCoarse)))
KFulltrue = lod_periodic.assembleMsStiffnessMatrix(world,
patchT,
KmsijTtrue,
periodic=True)
toc = time.perf_counter()
mean_time_true += (toc - tic)
correctorsTtrue = tuple(correctorsTtrue)
modbasistrue = basis - lod_periodic.assembleBasisCorrectors(
world, patchT, correctorsTtrue, periodic=True)
else:
def test_1d(self):
# Example from Peterseim, Variational Multiscale Stabilization and the Exponential Decay of correctors, p. 2
# Two modifications: A with minus and u(here) = 1/4*u(paper).
NFine = np.array([3200])
NpFine = np.prod(NFine + 1)
NList = [10, 20, 40, 80, 160]
epsilon = 1024. / NFine
epsilon = 1. / 320
k = 2
pi = np.pi
xt = util.tCoordinates(NFine).flatten()
xp = util.pCoordinates(NFine).flatten()
#aFine = (2 + np.cos(2*pi*xt/epsilon))**(-1)
aFine = (2 - np.cos(2 * pi * xt / epsilon))**(-1)
uSol = 4 * (xp - xp**2) - 4 * epsilon * (
1 / (4 * pi) * np.sin(2 * pi * xp / epsilon) - 1 /
(2 * pi) * xp * np.sin(2 * pi * xp / epsilon) - epsilon /
(4 * pi**2) * np.cos(2 * pi * xp / epsilon) + epsilon /
(4 * pi**2))
uSol = uSol / 4
previousErrorCoarse = np.inf
previousErrorFine = np.inf
for N in NList:
NWorldCoarse = np.array([N])
NCoarseElement = NFine / NWorldCoarse
boundaryConditions = np.array([[0, 0]])
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
xpCoarse = util.pCoordinates(NWorldCoarse).flatten()
NpCoarse = np.prod(NWorldCoarse + 1)
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
aCoef = coef.coefficientFine(NWorldCoarse, NCoarseElement, aFine)
pglod = pg.PetrovGalerkinLOD(world, k, IPatchGenerator, 0)
pglod.updateCorrectors(aCoef, clearFineQuantities=False)
KFull = pglod.assembleMsStiffnessMatrix()
MFull = fem.assemblePatchMatrix(NWorldCoarse, world.MLocCoarse)
free = util.interiorpIndexMap(NWorldCoarse)
f = np.ones(NpCoarse)
bFull = MFull * f
KFree = KFull[free][:, free]
bFree = bFull[free]
xFree = sparse.linalg.spsolve(KFree, bFree)
basis = fem.assembleProlongationMatrix(NWorldCoarse,
NCoarseElement)
basisCorrectors = pglod.assembleBasisCorrectors()
modifiedBasis = basis - basisCorrectors
xFull = np.zeros(NpCoarse)
xFull[free] = xFree
uLodCoarse = basis * xFull
uLodFine = modifiedBasis * xFull
AFine = fem.assemblePatchMatrix(NFine, world.ALocFine, aFine)
MFine = fem.assemblePatchMatrix(NFine, world.MLocFine)
newErrorCoarse = np.sqrt(
np.dot(uSol - uLodCoarse, MFine * (uSol - uLodCoarse)))
newErrorFine = np.sqrt(
np.dot(uSol - uLodFine, AFine * (uSol - uLodFine)))
self.assertTrue(newErrorCoarse < previousErrorCoarse)
self.assertTrue(newErrorFine < previousErrorFine)
def helmholtz_nonlinear_adaptive(mapper, fineLvl, maxCoarseLvl, maxit):
NFine = np.array([2**fineLvl, 2**fineLvl])
NpFine = np.prod(NFine + 1)
NList = 2**np.arange(1, maxCoarseLvl + 1)
ell = 2 # localization parameter
k = 30. # wavenumber
maxit_Fine = 250
tol = 0.5 # coupled to maximal error indicator
xt = util.tCoordinates(NFine)
xp = util.pCoordinates(NFine)
# multiscale coefficients on the scale NFine-2
np.random.seed(123)
sizeK = np.size(xt[:, 0])
nFine = NFine[0]
# determine domain D_eps = supp(1-n) = supp(1-A) (all equal for this experiment)
indicesIn = (xt[:, 0] > 0.25) & (xt[:, 0] < 0.75) & (xt[:, 1] > 0.25) & (
xt[:, 1] < 0.75)
indicesInEps = (xt[:, 0] > 0.25) & (xt[:, 0] < 0.75) & (
xt[:, 1] > 0.25) & (xt[:, 1] < 0.75)
# coefficients
cA = .2 # lower bound on A
CA = 1. # upper bound on A
aEps = np.random.uniform(0, 1, sizeK // 16)
aEpsPro = np.zeros(sizeK)
for i in range((nFine) // 4):
aEpsPro[4 * i * (nFine):4 * (i + 1) * (nFine)] = np.tile(
np.repeat(aEps[i * (nFine) // 4:(i + 1) * (nFine) // 4], 4), 4)
aFine = np.ones(xt.shape[0])
aFine[indicesIn] = (CA - cA) * aEpsPro[indicesIn] + cA
cn = 1. # lower bound on n
Cn = 1. # upper bound on n
nEps = np.random.uniform(0, 1, sizeK // 16)
nEpsPro = np.zeros(sizeK)
for i in range((nFine) // 4):
nEpsPro[4 * i * (nFine):4 * (i + 1) * (nFine)] = np.tile(
np.repeat(nEps[i * (nFine) // 4:(i + 1) * (nFine) // 4], 4), 4)
k2Fine = k**2 * np.ones(xt.shape[0])
k2Fine[indicesIn] = k**2 * ((Cn - cn) * nEpsPro[indicesIn] + cn)
kFine = k * np.ones(xt.shape[0])
Ceps = .85 # upper bound on eps (lower bound is 0)
lvl = 4
epsEps = np.random.randint(2, size=(sizeK // lvl**2))
epsEpsPro = np.zeros(sizeK)
for i in range((nFine) // lvl):
epsEpsPro[lvl * i * (nFine):lvl * (i + 1) * (nFine)] = np.tile(
np.repeat(epsEps[i * (nFine) // lvl:(i + 1) * (nFine) // lvl],
lvl), lvl)
epsFine = np.zeros(xt.shape[0])
epsFine[indicesInEps] = Ceps * epsEpsPro[indicesInEps] # 0 OR Ceps
drawCoefficient(NFine, epsFine)
xC = xp[:, 0]
yC = xp[:, 1]
fact = 100.
mult = .8
a = .5
b = .25
k2 = 30.
# define right-hand side and boundary condition
def funcF(x, y):
res = mult * (-np.exp(-1.j * k2 * (a * x - b)) *
(2 * a**2 * fact**2 * np.sinh(fact * (a * x - b))**2 /
(np.cosh(fact * (a * x - b)) + 1)**3 -
a**2 * fact**2 * np.cosh(fact * (a * x - b)) /
(np.cosh(fact * (a * x - b)) + 1)**2) +
a**2 * k2**2 * np.exp(-1.j * k2 * (a * x - b)) /
(np.cosh(fact * (a * x - b)) + 1) - 2.j * a**2 * fact *
k2 * np.exp(-1.j * k2 *
(a * x - b)) * np.sinh(fact * (a * x - b)) /
(np.cosh(fact * (a * x - b)) + 1)**2 -
k**2 * np.exp(-1.j * k2 * (a * x - b)) /
(np.cosh(fact * (a * x - b)) + 1))
return res
f = funcF(xC, yC)
g = np.zeros(NpFine, dtype='complex128')
# bottom boundary
g[0:(NFine[0] +
1)] = mult * 1.j * k * 1. / (np.cosh(fact *
(a * xC[0:(NFine[0] + 1)] - b)) +
1) * np.exp(
-1.j * k2 *
(a * xC[0:(NFine[0] + 1)] - b))
# top boundary
g[(NpFine - NFine[0] -
1):] = mult * 1.j * k * 1. / (np.cosh(fact * (a * xC[
(NpFine - NFine[0] - 1):NpFine] - b)) + 1) * np.exp(
-1.j * k2 * (a * xC[(NpFine - NFine[0] - 1):NpFine] - b))
# left boundary
g[0:(NpFine - NFine[0]):(
NFine[0] +
1)] = mult * 1.j * k * np.ones_like(yC[0:(NpFine - NFine[0]):(
NFine[0] + 1)]) / (np.cosh(fact * (a * 0 - b)) + 1) * np.exp(
-1.j * k2 * (a * 0 - b)) + mult * np.ones_like(
yC[0:(NpFine - NFine[0]):(NFine[0] + 1)]) * (
a * 1.j * k2 * np.exp(-1.j * k2 * (a * 0 - b)) /
(np.cosh((a * 0 - b) * fact) + 1) + a * fact * np.sinh(
(a * 0 - b) * fact) * np.exp(-1.j * k2 *
(a * 0 - b)) /
(np.cosh((a * 0 - b) * fact) + 1)**2)
# right boundary
g[NFine[0]:NpFine:(
NFine[0] + 1)] = mult * 1.j * k * np.ones_like(yC[NFine[0]:NpFine:(
NFine[0] + 1)]) / (np.cosh(fact * (a * 1. - b)) + 1) * np.exp(
-1.j * k2 * (a * 1. - b)) - mult * np.ones_like(
yC[NFine[0]:NpFine:(NFine[0] + 1)]) * (
a * 1.j * k2 * np.exp(-1.j * k2 * (a * 1. - b)) /
(np.cosh(
(a * 1. - b) * fact) + 1) + a * fact * np.sinh(
(a * 1. - b) * fact) * np.exp(-1.j * k2 *
(a * 1. - b)) /
(np.cosh((a * 1. - b) * fact) + 1)**2)
# reference solution
uSol = np.zeros(NpFine, dtype='complex128')
# boundary conditions
boundaryConditions = np.array([[1, 1], [1, 1]]) # Robin boundary
worldFine = World(NFine, np.array([1, 1]), boundaryConditions)
# fine matrices
BdFineFEM = fem.assemblePatchBoundaryMatrix(
NFine, fem.localBoundaryMassMatrixGetter(NFine))
MFineFEM = fem.assemblePatchMatrix(NFine, fem.localMassMatrix(NFine))
KFineFEM = fem.assemblePatchMatrix(NFine, fem.localStiffnessMatrix(NFine))
kBdFine = fem.assemblePatchBoundaryMatrix(
NFine, fem.localBoundaryMassMatrixGetter(NFine), kFine)
KFine = fem.assemblePatchMatrix(NFine, fem.localStiffnessMatrix(NFine),
aFine)
# incident beam
uInc = mult / (np.cosh(fact * (a * xC - b)) + 1) * np.exp(-1.j * k2 *
(a * xC - b))
print('***computing reference solution***')
uOldFine = np.zeros(NpFine, dtype='complex128')
for it in np.arange(maxit_Fine):
print('-- itFine = %d' % it)
knonlinUpreFine = np.abs(uOldFine)
knonlinUFine = func.evaluateCQ1(NFine, knonlinUpreFine, xt)
k2FineUfine = np.copy(k2Fine)
k2FineUfine[indicesInEps] *= (
1. + epsFine[indicesInEps] * knonlinUFine[indicesInEps]**2
) # full coefficient, including nonlinearity
k2MFine = fem.assemblePatchMatrix(
NFine, fem.localMassMatrix(NFine),
k2FineUfine) # weighted mass matrix, updated in every iteration
nodesFine = np.arange(worldFine.NpFine)
fixFine = util.boundarypIndexMap(NFine, boundaryConditions == 0)
freeFine = np.setdiff1d(nodesFine, fixFine)
# right-hand side (including boundary condition)
fhQuad = MFineFEM * f + BdFineFEM * g
# fine system
lhsh = KFine[freeFine][:, freeFine] - k2MFine[
freeFine][:, freeFine] + 1j * kBdFine[freeFine][:, freeFine]
rhsh = fhQuad[freeFine]
xFreeFine = sparse.linalg.spsolve(lhsh, rhsh)
xFullFine = np.zeros(worldFine.NpFine, dtype='complex128')
xFullFine[freeFine] = xFreeFine
uOldFine = np.copy(xFullFine)
# residual - used as stopping criterion
knonlinU = np.abs(uOldFine)
knonlinUFineIt = func.evaluateCQ1(NFine, knonlinU, xt)
k2FineUfineIt = np.copy(k2Fine)
k2FineUfineIt[indicesInEps] *= (
1. + epsFine[indicesInEps] * knonlinUFineIt[indicesInEps]**2
) # update full coefficient, including nonlinearity
k2MFineIt = fem.assemblePatchMatrix(NFine, fem.localMassMatrix(NFine),
k2FineUfineIt)
Ares = KFine - k2MFineIt + 1j * kBdFine
residual = np.linalg.norm(Ares * xFullFine - fhQuad) / np.linalg.norm(
Ares * xFullFine)
print('---- residual = %.4e' % residual)
if residual < 1e-12:
break # stopping criterion
uSol = xFullFine # final fine reference solution
print('***reference solution computed***\n')
######################################################################################
print('***computing multiscale approximations***')
relErrEnergy = np.zeros([len(NList), maxit])
counter = 0
for N in NList:
counter += 1
print('H = %.4e' % (1. / N))
NWorldCoarse = np.array([N, N])
NCoarseElement = NFine // NWorldCoarse
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
NpCoarse = np.prod(NWorldCoarse + 1)
uOldUps = np.zeros(NpFine, dtype='complex128')
for it in np.arange(maxit):
print('-- it = %d:' % it)
knonlinUpre = np.abs(uOldUps)
knonlinU = func.evaluateCQ1(NFine, knonlinUpre, xt)
k2FineU = np.copy(k2Fine)
k2FineU[indicesInEps] *= (
1. + epsFine[indicesInEps] * knonlinU[indicesInEps]**2)
print('---- starting computation of correctors')
def computeLocalContribution(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch, k2Patch)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch, k2Patch)
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def computeIndicators(TInd):
k2FineUPatch = lambda: coef.localizeCoefficient(
patchT[TInd], k2FineU)
k2FineUOldPatch = lambda: coef.localizeCoefficient(
patchT[TInd], k2FineUOld)
E_vh = lod.computeErrorIndicatorCoarse_helmholtz(
patchT[TInd], muTPrime[TInd], k2FineUOldPatch,
k2FineUPatch)
return E_vh
def UpdateCorrectors(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch, k2Patch)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch, k2Patch)
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def UpdateElements(tol, E, Kmsij_old, Mmsij_old, Bdmsij_old,
correctors_old, mu_old):
print('---- apply tolerance')
Elements_to_be_updated = []
for (i, eps) in E.items():
if eps > tol:
Elements_to_be_updated.append(i)
if len(E) > 0:
print(
'---- total percentage of element correctors to be updated: %.4f'
%
(100 * np.size(Elements_to_be_updated) / len(mu_old)),
flush=True)
print('---- update local contributions')
KmsijT_list = list(np.copy(Kmsij_old))
MmsijT_list = list(np.copy(Mmsij_old))
BdmsijT_list = list(np.copy(Bdmsij_old))
muT_list = np.copy(mu_old)
for T in np.setdiff1d(range(world.NtCoarse),
Elements_to_be_updated):
patch = Patch(world, ell, T)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctors_old[T], aPatch, kPatch, k2Patch)
KmsijT_list[T] = csi.Kmsij
MmsijT_list[T] = csi.Mmsij
BdmsijT_list[T] = csi.Bdmsij
muT_list[T] = csi.muTPrime
if np.size(Elements_to_be_updated) != 0:
#print('---- update correctors')
patchT_irrelevant, correctorsListTNew, KmsijTNew, MmsijTNew, BdmsijTNew, muTPrimeNew = zip(
*mapper(UpdateCorrectors, Elements_to_be_updated))
#print('---- update correctorsList')
correctorsListT_list = list(np.copy(correctors_old))
i = 0
for T in Elements_to_be_updated:
KmsijT_list[T] = KmsijTNew[i]
correctorsListT_list[T] = correctorsListTNew[i]
MmsijT_list[T] = MmsijTNew[i]
BdmsijT_list[T] = BdmsijTNew[i]
muT_list[T] = muTPrimeNew[i]
i += 1
KmsijT = tuple(KmsijT_list)
correctorsListT = tuple(correctorsListT_list)
MmsijT = tuple(MmsijT_list)
BdmsijT = tuple(BdmsijT_list)
muTPrime = tuple(muT_list)
return correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime
else:
KmsijT = tuple(KmsijT_list)
MmsijT = tuple(MmsijT_list)
BdmsijT = tuple(BdmsijT_list)
muTPrime = tuple(muT_list)
return correctors_old, KmsijT, MmsijT, BdmsijT, muTPrime
if it == 0:
patchT, correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime = zip(
*mapper(computeLocalContribution, range(world.NtCoarse)))
else:
E_vh = list(mapper(computeIndicators, range(world.NtCoarse)))
print(
'---- maximal value error estimator for basis correctors {}'
.format(np.max(E_vh)))
E = {i: E_vh[i] for i in range(np.size(E_vh)) if E_vh[i] > 0}
# loop over elements with possible recomputation of correctors
correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime = UpdateElements(
tol * np.max(E_vh), E, KmsijT, MmsijT, BdmsijT,
correctorsListT,
muTPrime) # tol scaled by maximal error indicator
print('---- finished computation of correctors')
KLOD = pglod.assembleMsStiffnessMatrix(
world, patchT, KmsijT) # ms stiffness matrix
k2MLOD = pglod.assembleMsStiffnessMatrix(world, patchT,
MmsijT) # ms mass matrix
kBdLOD = pglod.assembleMsStiffnessMatrix(
world, patchT, BdmsijT) # ms boundary matrix
MFEM = fem.assemblePatchMatrix(NWorldCoarse, world.MLocCoarse)
BdFEM = fem.assemblePatchBoundaryMatrix(
NWorldCoarse, fem.localBoundaryMassMatrixGetter(NWorldCoarse))
print('---- coarse matrices assembled')
nodes = np.arange(world.NpCoarse)
fix = util.boundarypIndexMap(NWorldCoarse, boundaryConditions == 0)
free = np.setdiff1d(nodes, fix)
assert (nodes.all() == free.all())
# compute global interpolation matrix
patchGlobal = Patch(world, NFine[0] + 2, 0)
IH = interp.L2ProjectionPatchMatrix(patchGlobal,
boundaryConditions)
assert (IH.shape[0] == NpCoarse)
basis = fem.assembleProlongationMatrix(NWorldCoarse,
NCoarseElement)
fHQuad = basis.T * MFineFEM * f + basis.T * BdFineFEM * g
print('---- solving coarse system')
# coarse system
lhsH = KLOD[free][:, free] - k2MLOD[
free][:, free] + 1j * kBdLOD[free][:, free]
rhsH = fHQuad[free]
xFree = sparse.linalg.spsolve(lhsH, rhsH)
basisCorrectors = pglod.assembleBasisCorrectors(
world, patchT, correctorsListT)
modifiedBasis = basis - basisCorrectors
xFull = np.zeros(world.NpCoarse, dtype='complex128')
xFull[free] = xFree
uLodCoarse = basis * xFull
uLodFine = modifiedBasis * xFull
uOldUps = np.copy(uLodFine)
k2FineUOld = np.copy(k2FineU)
# visualization
if it == maxit - 1 and N == 2**4:
grid = uLodFine.reshape(NFine + 1, order='C')
plt.figure(2)
plt.title('LOD_ad, Hlvl=4 - Ex 2')
plt.imshow(grid.real,
extent=(xC.min(), xC.max(), yC.min(), yC.max()),
cmap=plt.cm.hot,
origin='lower',
vmin=-.6,
vmax=.6)
plt.colorbar()
grid2 = uSol.reshape(NFine + 1, order='C')
plt.figure(1)
plt.title('reference solution - Ex 2')
plt.imshow(grid2.real,
extent=(xC.min(), xC.max(), yC.min(), yC.max()),
cmap=plt.cm.hot,
origin='lower',
vmin=-.6,
vmax=.6)
plt.colorbar()
grid3 = uInc.reshape(NFine + 1, order='C')
plt.figure(6)
plt.title('incident beam - Ex 2')
plt.imshow(grid3.real,
extent=(xC.min(), xC.max(), yC.min(), yC.max()),
cmap=plt.cm.hot,
origin='lower',
vmin=-.6,
vmax=.6)
plt.colorbar()
Err = np.sqrt(
np.dot((uSol - uLodFine).conj(), KFineFEM *
(uSol - uLodFine)) + k**2 *
np.dot((uSol - uLodFine).conj(), MFineFEM * (uSol - uLodFine)))
ErrEnergy = Err / np.sqrt(
np.dot((uSol).conj(), KFineFEM *
(uSol)) + k**2 * np.dot((uSol).conj(), MFineFEM *
(uSol)))
print('---- ', np.abs(ErrEnergy),
'\n***********************************************')
# save errors in arrays
relErrEnergy[counter - 1, it] = ErrEnergy
print('\n')
######################################################################################
print(
'***computing multiscale approximations without updates of correctors***'
)
relErrEnergyNoUpdate = np.zeros([len(NList), maxit])
counter = 0
for N in NList:
counter += 1
print('H = %.4e' % (1. / N))
NWorldCoarse = np.array([N, N])
NCoarseElement = NFine // NWorldCoarse
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
NpCoarse = np.prod(NWorldCoarse + 1)
uOldUps = np.zeros(NpFine, dtype='complex128')
for it in np.arange(maxit):
print('-- it = %d:' % it)
knonlinUpre = np.abs(uOldUps)
knonlinU = func.evaluateCQ1(NFine, knonlinUpre, xt)
k2FineU = np.copy(k2Fine)
k2FineU[indicesInEps] *= (
1. + epsFine[indicesInEps] * knonlinU[indicesInEps]**2)
print('---- starting computation of correctors')
def computeLocalContribution(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def computeIndicators(TInd):
k2FineUPatch = lambda: coef.localizeCoefficient(
patchT[TInd], k2FineU)
k2FineUOldPatch = lambda: coef.localizeCoefficient(
patchT[TInd], k2FineUOld)
E_vh = lod.computeErrorIndicatorCoarse_helmholtz(
patchT[TInd], muTPrime[TInd], k2FineUOldPatch,
k2FineUPatch)
return E_vh
def UpdateCorrectors(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch, k2Patch)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def UpdateElements(tol, E, Kmsij_old, Mmsij_old, Bdmsij_old,
correctors_old, mu_old):
print('---- apply tolerance')
Elements_to_be_updated = []
for (i, eps) in E.items():
if eps > tol:
Elements_to_be_updated.append(i)
if len(E) > 0:
print(
'---- total percentage of element correctors to be updated: %.4f'
%
(100 * np.size(Elements_to_be_updated) / len(mu_old)),
flush=True)
print('---- update local contributions')
KmsijT_list = list(np.copy(Kmsij_old))
MmsijT_list = list(np.copy(Mmsij_old))
BdmsijT_list = list(np.copy(Bdmsij_old))
muT_list = np.copy(mu_old)
for T in np.setdiff1d(range(world.NtCoarse),
Elements_to_be_updated):
patch = Patch(world, ell, T)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctors_old[T], aPatch, kPatch, k2Patch)
KmsijT_list[T] = csi.Kmsij
MmsijT_list[T] = csi.Mmsij
BdmsijT_list[T] = csi.Bdmsij
muT_list[T] = csi.muTPrime
if np.size(Elements_to_be_updated) != 0:
#print('---- update correctors')
patchT_irrelevant, correctorsListTNew, KmsijTNew, MmsijTNew, BdmsijTNew, muTPrimeNew = zip(
*mapper(UpdateCorrectors, Elements_to_be_updated))
#print('---- update correctorsList')
correctorsListT_list = list(np.copy(correctors_old))
i = 0
for T in Elements_to_be_updated:
KmsijT_list[T] = KmsijTNew[i]
correctorsListT_list[T] = correctorsListTNew[i]
MmsijT_list[T] = MmsijTNew[i]
BdmsijT_list[T] = BdmsijTNew[i]
muT_list[T] = muTPrimeNew[i]
i += 1
KmsijT = tuple(KmsijT_list)
correctorsListT = tuple(correctorsListT_list)
MmsijT = tuple(MmsijT_list)
BdmsijT = tuple(BdmsijT_list)
muTPrime = tuple(muT_list)
return correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime
else:
KmsijT = tuple(KmsijT_list)
MmsijT = tuple(MmsijT_list)
BdmsijT = tuple(BdmsijT_list)
muTPrime = tuple(muT_list)
return correctors_old, KmsijT, MmsijT, BdmsijT, muTPrime
if it == 0:
patchT, correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime = zip(
*mapper(computeLocalContribution, range(world.NtCoarse)))
else:
E_vh = list(mapper(computeIndicators, range(world.NtCoarse)))
print(
'---- maximal value error estimator for basis correctors {}'
.format(np.max(E_vh)))
E = {i: E_vh[i] for i in range(np.size(E_vh)) if E_vh[i] > 0}
# loop over elements with possible recomputation of correctors
correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime = UpdateElements(
2. * np.max(E_vh), E, KmsijT, MmsijT, BdmsijT,
correctorsListT, muTPrime) # no updates
print('---- finished computation of correctors')
KLOD = pglod.assembleMsStiffnessMatrix(
world, patchT, KmsijT) # ms stiffness matrix
k2MLOD = pglod.assembleMsStiffnessMatrix(world, patchT,
MmsijT) # ms mass matrix
kBdLOD = pglod.assembleMsStiffnessMatrix(
world, patchT, BdmsijT) # ms boundary matrix
MFEM = fem.assemblePatchMatrix(NWorldCoarse, world.MLocCoarse)
BdFEM = fem.assemblePatchBoundaryMatrix(
NWorldCoarse, fem.localBoundaryMassMatrixGetter(NWorldCoarse))
print('---- coarse matrices assembled')
nodes = np.arange(world.NpCoarse)
fix = util.boundarypIndexMap(NWorldCoarse, boundaryConditions == 0)
free = np.setdiff1d(nodes, fix)
assert (nodes.all() == free.all())
# compute global interpolation matrix
patchGlobal = Patch(world, NFine[0] + 2, 0)
IH = interp.L2ProjectionPatchMatrix(patchGlobal,
boundaryConditions)
assert (IH.shape[0] == NpCoarse)
basis = fem.assembleProlongationMatrix(NWorldCoarse,
NCoarseElement)
fHQuad = basis.T * MFineFEM * f + basis.T * BdFineFEM * g
print('---- solving coarse system')
# coarse system
lhsH = KLOD[free][:, free] - k2MLOD[
free][:, free] + 1j * kBdLOD[free][:, free]
rhsH = fHQuad[free]
xFree = sparse.linalg.spsolve(lhsH, rhsH)
basisCorrectors = pglod.assembleBasisCorrectors(
world, patchT, correctorsListT)
modifiedBasis = basis - basisCorrectors
xFull = np.zeros(world.NpCoarse, dtype='complex128')
xFull[free] = xFree
uLodCoarse = basis * xFull
uLodFine = modifiedBasis * xFull
uOldUps = np.copy(uLodFine)
k2FineUOld = np.copy(k2FineU)
# visualization
if it == maxit - 1 and N == 2**4:
grid = uLodFine.reshape(NFine + 1, order='C')
plt.figure(3)
plt.title('LOD_inf, Hlvl=4 - Ex 2')
plt.imshow(grid.real,
extent=(xC.min(), xC.max(), yC.min(), yC.max()),
cmap=plt.cm.hot,
origin='lower',
vmin=-.6,
vmax=.6)
plt.colorbar()
Err = np.sqrt(
np.dot((uSol - uLodFine).conj(), KFineFEM *
(uSol - uLodFine)) + k**2 *
np.dot((uSol - uLodFine).conj(), MFineFEM * (uSol - uLodFine)))
ErrEnergy = Err / np.sqrt(
np.dot((uSol).conj(), KFineFEM *
(uSol)) + k**2 * np.dot((uSol).conj(), MFineFEM *
(uSol)))
print('---- ', np.abs(ErrEnergy),
'\n***********************************************')
# save errors in arrays
relErrEnergyNoUpdate[counter - 1, it] = ErrEnergy
print('\n')
######################################################################################
print(
'***computing multiscale approximations where all correctors in the part of the domain with active nonlinearity are recomputed***'
)
relErrEnergyFullUpdate = np.zeros([len(NList), maxit])
counter = 0
for N in NList:
counter += 1
print('H = %.4e' % (1. / N))
NWorldCoarse = np.array([N, N])
NCoarseElement = NFine // NWorldCoarse
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
NpCoarse = np.prod(NWorldCoarse + 1)
uOldUps = np.zeros(NpFine, dtype='complex128')
for it in np.arange(maxit):
print('-- it = %d:' % it)
knonlinUpre = np.abs(uOldUps)
knonlinU = func.evaluateCQ1(NFine, knonlinUpre, xt)
k2FineU = np.copy(k2Fine)
k2FineU[indicesInEps] *= (
1. + epsFine[indicesInEps] * knonlinU[indicesInEps]**2)
print('---- starting computation of correctors')
def computeLocalContribution(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def computeIndicators(TInd):
k2FineUPatch = lambda: coef.localizeCoefficient(
patchT[TInd], k2FineU)
k2FineUOldPatch = lambda: coef.localizeCoefficient(
patchT[TInd], k2FineUOld)
E_vh = lod.computeErrorIndicatorCoarse_helmholtz(
patchT[TInd], muTPrime[TInd], k2FineUOldPatch,
k2FineUPatch)
return E_vh
def UpdateCorrectors(TInd):
patch = Patch(world, ell, TInd)
IPatch = lambda: interp.L2ProjectionPatchMatrix(
patch, boundaryConditions)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
correctorsList = lod.computeBasisCorrectors_helmholtz(
patch, IPatch, aPatch, kPatch, k2Patch)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctorsList, aPatch, kPatch,
k2Patch) # adapted for Helmholtz setting
return patch, correctorsList, csi.Kmsij, csi.Mmsij, csi.Bdmsij, csi.muTPrime
def UpdateElements(tol, E, Kmsij_old, Mmsij_old, Bdmsij_old,
correctors_old, mu_old):
print('---- apply tolerance')
Elements_to_be_updated = []
for (i, eps) in E.items():
if eps > tol:
Elements_to_be_updated.append(i)
if len(E) > 0:
print(
'---- total percentage of element correctors to be updated: %.4f'
%
(100 * np.size(Elements_to_be_updated) / len(mu_old)),
flush=True)
print('---- update local contributions')
KmsijT_list = list(np.copy(Kmsij_old))
MmsijT_list = list(np.copy(Mmsij_old))
BdmsijT_list = list(np.copy(Bdmsij_old))
muT_list = np.copy(mu_old)
for T in np.setdiff1d(range(world.NtCoarse),
Elements_to_be_updated):
patch = Patch(world, ell, T)
aPatch = lambda: coef.localizeCoefficient(patch, aFine)
kPatch = lambda: coef.localizeCoefficient(patch, kFine)
k2Patch = lambda: coef.localizeCoefficient(patch, k2FineU)
csi = lod.computeBasisCoarseQuantities_helmholtz(
patch, correctors_old[T], aPatch, kPatch, k2Patch)
KmsijT_list[T] = csi.Kmsij
MmsijT_list[T] = csi.Mmsij
BdmsijT_list[T] = csi.Bdmsij
muT_list[T] = csi.muTPrime
if np.size(Elements_to_be_updated) != 0:
#print('---- update correctors')
patchT_irrelevant, correctorsListTNew, KmsijTNew, MmsijTNew, BdmsijTNew, muTPrimeNew = zip(
*mapper(UpdateCorrectors, Elements_to_be_updated))
#print('---- update correctorsList')
correctorsListT_list = list(np.copy(correctors_old))
i = 0
for T in Elements_to_be_updated:
KmsijT_list[T] = KmsijTNew[i]
correctorsListT_list[T] = correctorsListTNew[i]
MmsijT_list[T] = MmsijTNew[i]
BdmsijT_list[T] = BdmsijTNew[i]
muT_list[T] = muTPrimeNew[i]
i += 1
KmsijT = tuple(KmsijT_list)
correctorsListT = tuple(correctorsListT_list)
MmsijT = tuple(MmsijT_list)
BdmsijT = tuple(BdmsijT_list)
muTPrime = tuple(muT_list)
return correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime
else:
KmsijT = tuple(KmsijT_list)
MmsijT = tuple(MmsijT_list)
BdmsijT = tuple(BdmsijT_list)
muTPrime = tuple(muT_list)
return correctors_old, KmsijT, MmsijT, BdmsijT, muTPrime
if it == 0:
patchT, correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime = zip(
*mapper(computeLocalContribution, range(world.NtCoarse)))
else:
E_vh = list(mapper(computeIndicators, range(world.NtCoarse)))
print(
'---- maximal value error estimator for basis correctors {}'
.format(np.max(E_vh)))
E = {i: E_vh[i] for i in range(np.size(E_vh)) if E_vh[i] > 0}
# loop over elements with possible recomputation of correctors
correctorsListT, KmsijT, MmsijT, BdmsijT, muTPrime = UpdateElements(
0., E, KmsijT, MmsijT, BdmsijT, correctorsListT,
muTPrime) # no updates
print('---- finished computation of correctors')
KLOD = pglod.assembleMsStiffnessMatrix(
world, patchT, KmsijT) # ms stiffness matrix
k2MLOD = pglod.assembleMsStiffnessMatrix(world, patchT,
MmsijT) # ms mass matrix
kBdLOD = pglod.assembleMsStiffnessMatrix(
world, patchT, BdmsijT) # ms boundary matrix
MFEM = fem.assemblePatchMatrix(NWorldCoarse, world.MLocCoarse)
BdFEM = fem.assemblePatchBoundaryMatrix(
NWorldCoarse, fem.localBoundaryMassMatrixGetter(NWorldCoarse))
print('---- coarse matrices assembled')
nodes = np.arange(world.NpCoarse)
fix = util.boundarypIndexMap(NWorldCoarse, boundaryConditions == 0)
free = np.setdiff1d(nodes, fix)
assert (nodes.all() == free.all())
# compute global interpolation matrix
patchGlobal = Patch(world, NFine[0] + 2, 0)
IH = interp.L2ProjectionPatchMatrix(patchGlobal,
boundaryConditions)
assert (IH.shape[0] == NpCoarse)
basis = fem.assembleProlongationMatrix(NWorldCoarse,
NCoarseElement)
fHQuad = basis.T * MFineFEM * f + basis.T * BdFineFEM * g
print('---- solving coarse system')
# coarse system
lhsH = KLOD[free][:, free] - k2MLOD[
free][:, free] + 1j * kBdLOD[free][:, free]
rhsH = fHQuad[free]
xFree = sparse.linalg.spsolve(lhsH, rhsH)
basisCorrectors = pglod.assembleBasisCorrectors(
world, patchT, correctorsListT)
modifiedBasis = basis - basisCorrectors
xFull = np.zeros(world.NpCoarse, dtype='complex128')
xFull[free] = xFree
uLodCoarse = basis * xFull
uLodFine = modifiedBasis * xFull
uOldUps = np.copy(uLodFine)
k2FineUOld = np.copy(k2FineU)
# visualization
if it == maxit - 1 and N == 2**4:
grid = uLodFine.reshape(NFine + 1, order='C')
plt.figure(7)
plt.title('LOD_inf, Hlvl=4 - Ex 2')
plt.imshow(grid.real,
extent=(xC.min(), xC.max(), yC.min(), yC.max()),
cmap=plt.cm.hot,
origin='lower',
vmin=-.6,
vmax=.6)
plt.colorbar()
Err = np.sqrt(
np.dot((uSol - uLodFine).conj(), KFineFEM *
(uSol - uLodFine)) + k**2 *
np.dot((uSol - uLodFine).conj(), MFineFEM * (uSol - uLodFine)))
ErrEnergy = Err / np.sqrt(
np.dot((uSol).conj(), KFineFEM *
(uSol)) + k**2 * np.dot((uSol).conj(), MFineFEM *
(uSol)))
print('---- ', np.abs(ErrEnergy),
'\n***********************************************')
# save errors in arrays
relErrEnergyFullUpdate[counter - 1, it] = ErrEnergy
print('\n')
######################################################################################
print('***computing FEM approximations***')
FEMrelErrEnergy = np.zeros([len(NList), maxit])
counter = 0
for N in NList:
counter += 1
print('H = %.4e' % (1. / N))
NWorldCoarse = np.array([N, N])
NCoarseElement = NFine // NWorldCoarse
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
NpCoarse = np.prod(NWorldCoarse + 1)
xT = util.tCoordinates(NWorldCoarse)
xP = util.pCoordinates(NWorldCoarse)
uOld = np.zeros(NpCoarse, dtype='complex128')
# compute coarse coefficients by averaging
NtC = np.prod(NWorldCoarse)
aCoarse = np.zeros(NtC)
kCoarse = k * np.ones(xT.shape[0])
k2Coarse = np.zeros(NtC)
epsCoarse = np.zeros(NtC)
for Q in range(NtC):
patch = Patch(world, 0, Q)
aPatch = coef.localizeCoefficient(patch, aFine)
epsPatch = coef.localizeCoefficient(patch, epsFine)
k2Patch = coef.localizeCoefficient(patch, k2Fine)
aCoarse[Q] = np.sum(aPatch) / (len(aPatch))
k2Coarse[Q] = np.sum(k2Patch) / (len(k2Patch))
epsCoarse[Q] = np.sum(epsPatch) / (len(epsPatch))
# coarse matrices
KFEM = fem.assemblePatchMatrix(NWorldCoarse,
fem.localStiffnessMatrix(NWorldCoarse),
aCoarse)
kBdFEM = fem.assemblePatchBoundaryMatrix(
NWorldCoarse, fem.localBoundaryMassMatrixGetter(NWorldCoarse),
kCoarse)
MFEM = fem.assemblePatchMatrix(NWorldCoarse, world.MLocCoarse)
BdFEM = fem.assemblePatchBoundaryMatrix(
NWorldCoarse, fem.localBoundaryMassMatrixGetter(NWorldCoarse))
for it in np.arange(maxit):
print('-- it = %d:' % it)
knonlinUpre = np.abs(uOld)
knonlinU = func.evaluateCQ1(NWorldCoarse, knonlinUpre, xT)
k2CoarseU = np.copy(k2Coarse)
k2CoarseU *= (1. + epsCoarse * knonlinU**2)
# update weighted mass matrix
k2MFEM = fem.assemblePatchMatrix(NWorldCoarse,
fem.localMassMatrix(NWorldCoarse),
k2CoarseU)
nodes = np.arange(world.NpCoarse)
fix = util.boundarypIndexMap(NWorldCoarse, boundaryConditions == 0)
free = np.setdiff1d(nodes, fix)
assert (nodes.all() == free.all())
basis = fem.assembleProlongationMatrix(NWorldCoarse,
NCoarseElement)
fHQuad = basis.T * MFineFEM * f + basis.T * BdFineFEM * g
print('---- solving coarse system')
# coarse system
lhsH = KFEM[free][:, free] - k2MFEM[
free][:, free] + 1j * kBdFEM[free][:, free]
rhsH = fHQuad[free]
xFree = sparse.linalg.spsolve(lhsH, rhsH)
xFull = np.zeros(world.NpCoarse, dtype='complex128')
xFull[free] = xFree
uCoarseInt = basis * xFull
uOld = np.copy(xFull)
# visualization
if it == maxit - 1 and N == 2**4:
grid = uCoarseInt.reshape(NFine + 1, order='C')
plt.figure(4)
plt.title('FEM, Hlvl=4 - Ex 2')
plt.imshow(grid.real,
extent=(xC.min(), xC.max(), yC.min(), yC.max()),
cmap=plt.cm.hot,
origin='lower',
vmin=-.6,
vmax=.6)
plt.colorbar()
Err = np.sqrt(
np.dot((uSol -
uCoarseInt).conj(), KFineFEM * (uSol - uCoarseInt)) +
k**2 * np.dot(
(uSol - uCoarseInt).conj(), MFineFEM *
(uSol - uCoarseInt)))
ErrEnergy = Err / np.sqrt(
np.dot((uSol).conj(), KFineFEM *
(uSol)) + k**2 * np.dot((uSol).conj(), MFineFEM *
(uSol)))
print('---- ', np.abs(ErrEnergy),
'\n***********************************************')
# save errors in arrays
FEMrelErrEnergy[counter - 1, it] = ErrEnergy
print('\n')
# error plots
errLOD_2 = np.min(relErrEnergy, 1)
errLOD0_2 = np.min(relErrEnergyNoUpdate, 1)
errLODall_2 = np.min(relErrEnergyFullUpdate, 1)
errFEM_2 = np.min(FEMrelErrEnergy, 1)
Hs = 0.5**np.arange(1, maxCoarseLvl + 1)
plt.figure(5)
plt.title('Relative energy errors w.r.t H - Ex 2')
plt.plot(Hs, errLOD_2, 'x-', color='blue', label='LOD_ad')
plt.plot(Hs, errLOD0_2, 'x-', color='green', label='LOD_inf')
plt.plot(Hs, errLODall_2, 'x-', color='orange', label='LOD_0')
plt.plot(Hs, errFEM_2, 'x-', color='red', label='FEM')
plt.plot([0.5, 0.0078125], [0.75, 0.01171875],
color='black',
linestyle='dashed',
label='order 1')
plt.yscale('log')
plt.xscale('log')
plt.legend()
plt.show()
def IPatchGenerator(i, N):
return interp.L2ProjectionPatchMatrix(i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
def test_3d(self):
return
NWorldFine = np.array([60, 220, 50])
NpFine = np.prod(NWorldFine + 1)
NtFine = np.prod(NWorldFine)
NWorldCoarse = np.array([6, 22, 5])
NCoarseElement = NWorldFine / NWorldCoarse
NtCoarse = np.prod(NWorldCoarse)
NpCoarse = np.prod(NWorldCoarse + 1)
boundaryConditions = np.array([[1, 1], [0, 0], [1, 1]])
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
aBase = np.loadtxt(
os.path.dirname(os.path.realpath(__file__)) +
'/data/upperness_x.txt')
#aBase = aBase[::8]
print 'a'
coords = util.pCoordinates(NWorldFine)
gFine = 1 - coords[:, 1]
uFineFull, AFine, _ = femsolver.solveFine(world, aBase, None, -gFine,
boundaryConditions)
print 'b'
rCoarse = np.ones(NtCoarse)
self.assertTrue(np.size(aBase) == NtFine)
if True:
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
aCoef = coef.coefficientCoarseFactor(NWorldCoarse, NCoarseElement,
aBase, rCoarse)
k = 2
printLevel = 1
pglod = pg.PetrovGalerkinLOD(world, k, IPatchGenerator, 1e-1,
printLevel)
pglod.updateCorrectors(aCoef, clearFineQuantities=True)
KmsFull = pglod.assembleMsStiffnessMatrix()
coords = util.pCoordinates(NWorldCoarse)
g = 1 - coords[:, 1]
bFull = -KmsFull * g
boundaryMap = boundaryConditions == 0
fixed = util.boundarypIndexMap(NWorldCoarse, boundaryMap)
free = np.setdiff1d(np.arange(0, NpCoarse), fixed)
KmsFree = KmsFull[free][:, free]
bFree = bFull[free]
xFree = sparse.linalg.spsolve(KmsFree, bFree)
uCoarse = np.zeros(NpCoarse)
uCoarse[free] = xFree
uCoarse += g
uCube = np.reshape(uCoarse, (NWorldCoarse + 1)[::-1])
uCube = np.ascontiguousarray(np.transpose(uCube, axes=[2, 1, 0]))
imageToVTK("./image", pointData={"u": uCube})
if False:
coord = util.pCoordinates(NWorldCoarse)
uCoarse = coord[:, 1].flatten()
uCube = np.reshape(uCoarse, (NWorldCoarse + 1)[::-1])
uCube = np.ascontiguousarray(np.transpose(uCube, axes=[2, 1, 0]))
imageToVTK("./image", pointData={"u": uCube})
ShapeRestriction = True,
ShapeWave = None,
Original = True,
NewShapeChange = True)
# precompute
NWorldFine = world.NWorldFine
NWorldCoarse = world.NWorldCoarse
NCoarseElement = world.NCoarseElement
boundaryConditions = world.boundaryConditions
NpFine = np.prod(NWorldFine+1)
NpCoarse = np.prod(NWorldCoarse+1)
#interpolant
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
#old Coefficient (need flatten form)
Aold = coef.coefficientFine(NWorldCoarse, NCoarseElement, ABase)
for k in range(1,6):
print(('<<<<<<<<<<<<<<<< ' + str(k) + ' >>>>>>>>>>>>>>>>'))
pglod = pg_pert.PerturbedPetrovGalerkinLOD(Aold, world, k, IPatchGenerator, 1)
pglod.originCorrectors(clearFineQuantities=False)
#new Coefficient
ANew = R2.flatten()
Anew = coef.coefficientFine(NWorldCoarse, NCoarseElement, ANew)
# tolerance = 0
vis, eps = pglod.updateCorrectors(Anew, 0,clearFineQuantities=False, Computing = False)
def test_00coarseFlux(self):
NWorldFine = np.array([20, 20])
NpFine = np.prod(NWorldFine + 1)
NtFine = np.prod(NWorldFine)
NWorldCoarse = np.array([4, 4])
NCoarseElement = NWorldFine / NWorldCoarse
NtCoarse = np.prod(NWorldCoarse)
NpCoarse = np.prod(NWorldCoarse + 1)
boundaryConditions = np.array([[0, 0], [1, 1]])
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
np.random.seed(0)
aBaseSquare = np.exp(5 * np.random.random_sample(NWorldFine[1]))
aBaseCube = np.tile(aBaseSquare[..., np.newaxis], [NWorldFine[0], 1])
aBaseCube = aBaseCube[..., np.newaxis]
aBase = aBaseCube.flatten()
IPatchGenerator = lambda i, N: interp.L2ProjectionPatchMatrix(
i, N, NWorldCoarse, NCoarseElement, boundaryConditions)
aCoef = coef.coefficientFine(NWorldCoarse, NCoarseElement, aBase)
k = 4
printLevel = 0
pglod = pg.PetrovGalerkinLOD(world, k, IPatchGenerator, 0, printLevel)
pglod.updateCorrectors(aCoef)
KmsFull = pglod.assembleMsStiffnessMatrix()
coords = util.pCoordinates(NWorldCoarse)
xC = coords[:, 0]
g = 1 - xC
bFull = -KmsFull * g
boundaryMap = boundaryConditions == 0
fixed = util.boundarypIndexMap(NWorldCoarse, boundaryMap)
free = np.setdiff1d(np.arange(0, NpCoarse), fixed)
KmsFree = KmsFull[free][:, free]
bFree = bFull[free]
xFree = sparse.linalg.spsolve(KmsFree, bFree)
xFull = np.zeros(NpCoarse)
xFull[free] = xFree
uFull = xFull + g
lodFluxTF = pglod.computeFaceFluxTF(uFull)
## Compute fine solution
coords = util.pCoordinates(NWorldFine)
xF = coords[:, 0]
gFine = 1 - xF
uFineFull, AFine, _ = femsolver.solveFine(world, aBase, None, -gFine,
boundaryConditions)
uFineFull = uFineFull + gFine
fineFluxTF = transport.computeHarmonicMeanFaceFlux(
NWorldCoarse, NWorldCoarse, NCoarseElement, aBase, uFineFull)
self.assertTrue(np.allclose(lodFluxTF, fineFluxTF, rtol=1e-7))
