def ritzProjectionToFinePatchWithGivenSaddleSolver(world,
iPatchWorldCoarse,
NPatchCoarse,
APatchFull,
bPatchFullList,
IPatch,
saddleSolver):
d = np.size(NPatchCoarse)
NPatchFine = NPatchCoarse * world.NCoarseElement
NpFine = np.prod(NPatchFine + 1)
# Find what patch faces are common to the world faces, and inherit
# boundary conditions from the world for those. For the other
# faces, all DoFs fixed (Dirichlet)
boundaryMapWorld = world.boundaryConditions == 0
inherit0 = iPatchWorldCoarse == 0
inherit1 = (iPatchWorldCoarse + NPatchCoarse) == world.NWorldCoarse
boundaryMap = np.ones([d, 2], dtype='bool')
boundaryMap[inherit0, 0] = boundaryMapWorld[inherit0, 0]
boundaryMap[inherit1, 1] = boundaryMapWorld[inherit1, 1]
# Using schur complement solver for the case when there are no
# Dirichlet conditions does not work. Fix if necessary.
assert (np.any(boundaryMap == True))
fixed = util.boundarypIndexMap(NPatchFine, boundaryMap)
# projectionsList = saddleSolver.solve(APatch, IPatch, bPatchList)
projectionsList = saddleSolver.solve(APatchFull, IPatch, bPatchFullList, fixed, NPatchCoarse, world.NCoarseElement)
return projectionsList
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 solveCoarse_fem(world, aFine, bFine, MbFine, U, tau, boundaryConditions,
i):
NWorldCoarse = world.NWorldCoarse
NWorldFine = world.NWorldCoarse * world.NCoarseElement
NCoarseElement = world.NCoarseElement
NpFine = np.prod(NWorldFine + 1)
NpCoarse = np.prod(NWorldCoarse + 1)
if MbFine is None:
MbFine = np.zeros(NpFine)
boundaryMap = boundaryConditions == 0
fixedCoarse = util.boundarypIndexMap(NWorldCoarse, boundaryMap=boundaryMap)
freeCoarse = np.setdiff1d(np.arange(NpCoarse), fixedCoarse)
AFine = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, aFine)
BFine = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, bFine)
MFine = fem.assemblePatchMatrix(NWorldFine, world.MLocFine)
bFine = MFine * MbFine
basis = fem.assembleProlongationMatrix(NWorldCoarse, NCoarseElement)
ACoarse = basis.T * (AFine * basis)
BCoarse = basis.T * (BFine * basis)
MCoarse = basis.T * (MFine * basis)
bCoarse = basis.T * bFine
ACoarseFree = ACoarse[freeCoarse][:, freeCoarse]
BCoarseFree = BCoarse[freeCoarse][:, freeCoarse]
MCoarseFree = MCoarse[freeCoarse][:, freeCoarse]
bCoarseFree = bCoarse[freeCoarse]
A = (1. / tau**2) * MCoarseFree + (1. / tau) * ACoarseFree + BCoarseFree
if i == 0:
b = bCoarseFree + (1. / tau) * ACoarseFree * U[i][freeCoarse] + (
1. / tau) * MCoarseFree * ((2. / tau) * U[i][freeCoarse])
else:
b = bCoarseFree + (1. / tau) * ACoarseFree * U[i][freeCoarse] + (
1. / tau) * MCoarseFree * ((2. / tau) * U[i][freeCoarse] -
(1. / tau) * U[i - 1][freeCoarse])
uCoarseFree = linalg.linSolve(A, b)
uCoarseFull = np.zeros(NpCoarse)
uCoarseFull[freeCoarse] = uCoarseFree
uCoarseFull = uCoarseFull
return uCoarseFull
def reference_sol(world, fine, tau, tot_time_steps, init_val, aFine, bFine, f):
NFine = np.array([fine, fine])
NpFine = np.prod(NFine + 1)
bc = world.boundaryConditions
NWorldFine = world.NWorldCoarse * world.NCoarseElement
# set initial value
U = [init_val]
U.append(init_val)
# assemble matrices
S = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, aFine)
K = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, bFine)
M = fem.assemblePatchMatrix(NWorldFine, world.MLocFine)
# find free indices
boundary_map = bc == 0
fixed = util.boundarypIndexMap(NWorldFine, boundary_map)
free = np.setdiff1d(np.arange(NpFine), fixed)
# create free matrices
Sf = S[free][:, free]
Kf = K[free][:, free]
Mf = M[free][:, free]
Lf = (M * f)[free]
for i in range(tot_time_steps):
# reference system
A = (1. / (tau ** 2)) * Mf + (1. / tau) * Sf + Kf
b = Lf + (1. / tau) * Sf * U[1][free] + (2. / (tau ** 2)) * Mf * U[1][free] - \
(1. / (tau ** 2)) * Mf * U[0][free]
# solve system
UFineFree = linalg.linSolve(A, b)
UFineFull = np.zeros(NpFine)
UFineFull[free] = UFineFree
# append solution
U[0] = U[1]
U[1] = UFineFull
return U[-1]
def solveDampedFine_fem(world, aFine, bFine, f, uSol, tau, boundaryConditions,
i):
NWorldCoarse = world.NWorldCoarse
NWorldFine = world.NWorldCoarse * world.NCoarseElement
NpFine = np.prod(NWorldFine + 1)
prevU = uSol[-1]
if f is None:
f = np.zeros(NpFine)
boundaryMap = boundaryConditions == 0
fixedFine = util.boundarypIndexMap(NWorldFine, boundaryMap=boundaryMap)
freeFine = np.setdiff1d(np.arange(NpFine), fixedFine)
AFine = fem.assemblePatchMatrix(NWorldFine, world.MLocFine, aFine)
BFine = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, bFine)
MFine = fem.assemblePatchMatrix(NWorldFine, world.MLocFine)
bFine = MFine * f
AFineFree = AFine[freeFine][:, freeFine]
BFineFree = BFine[freeFine][:, freeFine]
MFineFree = MFine[freeFine][:, freeFine]
bFineFree = bFine[freeFine]
A = (1. / tau**2) * MFineFree + (1. / tau) * AFineFree + BFineFree
if i == 0:
b = bFineFree + (1. / tau) * AFineFree * prevU[freeFine] + (
1. / tau) * MFineFree * ((2. / tau) * prevU[freeFine])
else:
b = bFineFree + (1. / tau) * AFineFree * prevU[freeFine] + (
1. / tau) * MFineFree * ((2. / tau) * prevU[freeFine] -
(1. / tau) * uSol[i - 1][freeFine])
uFineFree = linalg.linSolve(A, b)
uFineFull = np.zeros(NpFine)
uFineFull[freeFine] = uFineFree
uFineFull = uFineFull
return uFineFull
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 ritzProjectionToFinePatch(patch,
APatchFull,
bPatchFullList,
IPatch,
saddleSolver=None):
if saddleSolver is None:
saddleSolver = DirectSolver() # Fast for small patch problems
world = patch.world
d = np.size(patch.NPatchCoarse)
NPatchFine = patch.NPatchFine
NpFine = patch.NpFine
# Find what patch faces are common to the world faces, and inherit
# boundary conditions from the world for those. For the other
# faces, all DoFs fixed (Dirichlet)
boundaryMapWorld = world.boundaryConditions == 0
inherit0 = patch.iPatchWorldCoarse == 0
inherit1 = (patch.iPatchWorldCoarse +
patch.NPatchCoarse) == world.NWorldCoarse
boundaryMap = np.ones([d, 2], dtype='bool')
boundaryMap[inherit0, 0] = boundaryMapWorld[inherit0, 0]
boundaryMap[inherit1, 1] = boundaryMapWorld[inherit1, 1]
# Using schur complement solver for the case when there are no
# Dirichlet conditions does not work. Fix if necessary.
fixed = util.boundarypIndexMap(NPatchFine, boundaryMap)
projectionsList = saddleSolver.solve(APatchFull, IPatch, bPatchFullList,
fixed, patch.NPatchCoarse,
world.NCoarseElement)
return projectionsList
S = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, aFine)
K = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, bFine)
M = fem.assemblePatchMatrix(NWorldFine, world.MLocFine)
SmsFull = ms_basis.T * S * ms_basis
KmsFull = ms_basis.T * K * ms_basis
MmsFull = ms_basis.T * M * ms_basis
free = util.interiorpIndexMap(NWorldCoarse)
SmsFree = SmsFull[free][:, free]
KmsFree = KmsFull[free][:, free]
MmsFree = MmsFull[free][:, free]
boundaryMap = boundaryConditions == 0
fixedFine = util.boundarypIndexMap(NWorldFine, boundaryMap)
freeFine = np.setdiff1d(np.arange(NpFine), fixedFine)
# load vector
f = np.ones(NpFine)
LFull = M * f
LmsFull = ms_basis.T * LFull
LmsFree = LmsFull[free]
RmsFreeList = []
for i in xrange(numTimeSteps):
print 'LOD N=%d, i=%d' %(N,i)
n = i + 1
# linear system
def test_pgtransport(self):
NWorldCoarse = np.array([16, 16])
NCoarseElement = np.array([8, 8])
NWorldFine = NWorldCoarse * NCoarseElement
boundaryConditions = np.array([[1, 1], [0, 0]])
d = 2
world = World(NWorldCoarse, NCoarseElement, boundaryConditions)
# Load coefficient
aLogBase = np.loadtxt(
os.path.dirname(os.path.realpath(__file__)) +
'/data/randomfield64x64')
#aBase = np.loadtxt(os.path.dirname(os.path.realpath(__file__)) + '/data/upperness_x.txt')
#aBase = aBase[:60*220]
#aLogBase = np.random.rand(128*128)
aBase = np.exp(3 * aLogBase)
drawCoefficient(NWorldFine, aBase)
plt.title('a')
# Compute coordinates
coordsFine = util.pCoordinates(NWorldFine)
xFine = coordsFine[:, 0]
yFine = coordsFine[:, 1]
# Compute fixed and free dofs
allDofs = np.arange(world.NpFine)
fixed = util.boundarypIndexMap(NWorldFine, boundaryConditions == 0)
free = np.setdiff1d(allDofs, fixed)
# Compute matrices
AFull = fem.assemblePatchMatrix(NWorldFine, world.ALocFine, aBase)
A = AFull[free][:, free]
# Compute rhs
gFine = 1 - yFine
bFull = -AFull * gFine
b = bFull[free]
# Solve fine system
u0Free = sparse.linalg.spsolve(A, b)
u0Full = np.zeros(world.NpFine)
u0Full[free] = u0Free
uFull = u0Full + gFine
## First, compute flux on fine mesh
def computeAvgVelocitiesTF(NFluxElement):
fluxWorld = World(NWorldFine / NFluxElement, NFluxElement,
boundaryConditions)
if True:
avgFluxTF = transport.computeHarmonicMeanFaceFlux(
fluxWorld.NWorldCoarse, fluxWorld.NWorldCoarse,
NFluxElement, aBase, uFull)
avgFluxTF = transport.computeAverageFaceFlux(
fluxWorld.NWorldCoarse, avgFluxTF)
conservativeFluxTF = transport.computeConservativeFlux(
fluxWorld, avgFluxTF)
if False:
avgFluxTF = transport.computeElementFaceFlux(
fluxWorld.NWorldCoarse, fluxWorld.NWorldCoarse,
NFluxElement, aBase, uFull)
avgFluxTF = transport.computeAverageFaceFlux(
fluxWorld.NWorldCoarse, avgFluxTF)
return avgFluxTF, conservativeFluxTF
avgFluxTF, conservativeFluxTF = computeAvgVelocitiesTF(NCoarseElement)
avgFluxtf, conservativeFluxtf = computeAvgVelocitiesTF(
np.ones_like(NCoarseElement))
def fractionalFlow(s):
return s**3
boundarys = np.array([[0, 0], [1, 0]])
sT = np.zeros(world.NtCoarse)
st = np.zeros(world.NtFine)
nTime = 1e5
endTime = 1
dTime = endTime / float(nTime)
volt = np.prod(1. / world.NWorldFine)
volT = np.prod(1. / world.NWorldCoarse)
plt.figure()
h1 = plt.gcf().number
plt.figure()
h2 = plt.gcf().number
plt.figure()
h3 = plt.gcf().number
for timeStep in np.arange(nTime):
def computeElementNetFluxT(NFluxElement, avgFluxTF, sT):
fluxWorld = World(NWorldFine / NFluxElement, NFluxElement,
boundaryConditions)
netFluxT = transport.computeElementNetFlux(
fluxWorld, avgFluxTF, sT, boundarys, fractionalFlow)
return netFluxT
netFluxT = computeElementNetFluxT(NCoarseElement,
conservativeFluxTF, sT)
netFluxt = computeElementNetFluxT(np.ones_like(NCoarseElement),
conservativeFluxtf, st)
sT = sT + dTime / volT * netFluxT
#sT[sT > 1] = 1.
#sT[sT < 0] = 0.
st = st + dTime / volt * netFluxt
#st[st > 1] = 1.
#st[st < 0] = 0.
if timeStep % 1000 == 0 or timeStep == nTime - 1:
plt.figure(h1)
drawSaturation(NWorldCoarse, sT)
plt.title('sT')
plt.gcf().canvas.draw()
plt.figure(h2)
drawSaturation(NWorldFine, st)
plt.title('st')
plt.gcf().canvas.draw()
plt.figure(h3)
stProjected = projectSaturation(NWorldCoarse, NCoarseElement,
st)
drawSaturation(NWorldCoarse, stProjected)
plt.title('st projected')
plt.gcf().canvas.draw()
print np.sqrt(np.mean((stProjected - sT)**2))
plt.pause(0.0001)
plt.show()
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))
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})
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_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 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 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()
