def test_complex_params_Brick(self):
domain=Brick(order=2,n0=10,n1=10,n2=10)
pde = LinearSinglePDE(domain, isComplex=True)
pde.setValue(D=1j)
pde.setValue(Y=1.0)
self.assertTrue(Lsup(pde.getSolution())==1.0, "Failed test_complex_params_Brick")
del domain
class IsostaticPressure(object):
"""
class to calculate isostatic pressure field correction due to gravity forces
"""
def __init__(self, domain, p0=0., level0=0, gravity0=-9.81*U.m*U.sec**(-2),
background_density=2670* U.kg*U.m**(-3),
gravity_constant=U.Gravitational_Constant,
coordinates=None, tol=1e-8):
"""
:param domain: domain of the model
:type domain: `Domain`
:param p0: pressure at level0
:type p0: scalar `Data` or ``float``
:param background_density: defines background_density in kg/m^3
:type background_density: ``float``
:param coordinates: defines coordinate system to be used
:type coordinates: ReferenceSystem` or `SpatialCoordinateTransformation`
:param tol: tolerance of underlying PDE
:type tol: positive ``float``
:param level0: pressure for z>=`level0` is set to zero.
:type level0: ``float``
:param gravity0: vertical background gravity at `level0`
:type gravity0: ``float``
"""
DIM=domain.getDim()
self.__domain = domain
self.__trafo=makeTransformation(domain, coordinates)
self.__pde=LinearSinglePDE(domain)
self.__pde.getSolverOptions().setTolerance(tol)
self.__pde.setSymmetryOn()
z = domain.getX()[DIM-1]
self.__pde.setValue(q=whereNonNegative(z-level0), r=p0)
fw = self.__trafo.getScalingFactors()**2 * self.__trafo.getVolumeFactor()
A=self.__pde.createCoefficient("A")
for i in range(DIM): A[i,i]=fw[i]
self.__pde.setValue(A=A)
z = Function(domain).getX()[DIM-1]
self.__g_b= 4*PI*gravity_constant/self.__trafo.getScalingFactors()[DIM-1]*background_density*(level0-z) + gravity0
self.__rho_b=background_density
def getPressure(self, g = None, rho=None):
"""
return the pressure for gravity force anomaly `g` and
density anomaly `rho`
:param g: gravity anomaly data
:type g: ``Vector``
:param rho: gravity anomaly data
:type rho: ``Scalar``
:return: pressure distribution
:rtype: ``Scalar`
"""
if not g: g=Vector(0., Function(self.__domain))
if not rho: rho=Scalar(0., Function(self.__domain))
g2=(rho * self.__g_b)*[0,0,1] + self.__rho_b*g + rho*g
# Tests need to be updated before the following is uncommented:
#g2=((rho+self.__rho_b) * self.__g_b)*[0,0,1] + self.__rho_b*g + rho*g
d=self.__trafo.getScalingFactors()
V= self.__trafo.getVolumeFactor()
self.__pde.setValue(X = -g2*d*V)
#self.__pde.setValue(X = g2*d*V)
return self.__pde.getSolution()
saveVTK("u.vtu",u=U_star,u0=U)
#
# step 2:
#
# U2=U+teta1*(U_star-U)
U2=U+teta1*U_star
gg2=grad(U2)
div_U2=gg2[0,0]+gg2[1,1]+U2[0]/r
grad_p=grad(p)
pressureStep2.setValue(A=r*dt*B*teta1*teta2/ro*dt*kronecker(dom),
D=r,
Y=-dt*B*r*div_U2,
X=-r*B*dt**2/ro*teta1*(1-teta3)*grad_p)
dp=pressureStep2.getSolution()
#
# step 3:
#
p2=(1-teta3)*p+teta2*dp
grad_p2=grad(p2)
momentumStep3.setValue(D=r*ro*kronecker(dom),
Y=r*(ro*U_star-dt*teta2*grad_p2))
U_new=momentumStep3.getSolution()
#
# update:
#
p+=dp
U=U_new
print("U:",inf(U),sup(U))
print("P:",inf(p),sup(p))
saveVTK("u.vtu",u=U_star,u0=U)
#
# step 2:
#
# U2=U+teta1*(U_star-U)
U2=U+teta1*U_star
gg2=grad(U2)
div_U2=gg2[0,0]+gg2[1,1]+U2[0]/r
grad_p=grad(p)
pressureStep2.setValue(A=r*dt*B*teta1*teta2/ro*dt*kronecker(dom),
D=r,
Y=-dt*B*r*div_U2,
X=-r*B*dt**2/ro*teta1*(1-teta3)*grad_p)
dp=pressureStep2.getSolution()
#
# step 3:
#
p2=(1-teta3)*p+teta2*dp
grad_p2=grad(p2)
momentumStep3.setValue(D=r*ro*kronecker(dom),
Y=r*(ro*U_star-dt*teta2*grad_p2))
U_new=momentumStep3.getSolution()
#
# update:
#
p+=dp
U=U_new
print("U:",inf(U),sup(U))
print("P:",inf(p),sup(p))
c = 0
saveVTK("u.%s.vtu" % c, u=u0)
fc.setInitialSolution(u0)
t = T0
while t < T_END:
print("time step t=", t + dt)
u = fc.solve(dt)
if TEST_SUPG:
#========== supg tests ================
nn = max(ceil(dt / dt_supg), 1.)
dt2 = dt / nn
nnn = 0
while nnn < nn:
supg.setValue(X=-dt2 / 2 * E * grad(u_supg),
Y=u_supg + dt2 / 2 * inner(V, grad(u_supg)))
u2 = supg.getSolution()
supg.setValue(X=-dt2 * E * grad(u2),
Y=u_supg + dt2 * inner(V, grad(u2)))
u_supg = supg.getSolution()
nnn += 1
c += 1
t += dt
print("QUALITY FCT: time = %s pi" % (t / pi), QUALITY(t, u), end=' ')
if TEST_SUPG:
print("QUALITY SUPG: ", QUALITY(t, u_supg))
# saveVTK("u.%s.vtu"%c,u=u,u_supg=u_supg)
else:
# saveVTK("u.%s.vtu"%c,u=u)
pass
# if c == 20: 1/0
def runValetAcceleration(order):
domain=finley.Rectangle(100,10,order)
x=domain.getX()
# test Velet scheme
dt=inf(domain.getSize()/c)*(1./6.)
q=whereZero(x[0])+whereZero(x[0]-1.)
mypde_f=LinearSinglePDE(domain)
mypde_f.setSymmetryOn()
mypde_f.setValue(D=1,q=q)
u_f_old=ref_u(x,-dt)
u_f=ref_u(x,0)
mypde_HRZ=LinearSinglePDE(domain)
mypde_HRZ.getSolverOptions().setSolverMethod(SolverOptions.HRZ_LUMPING)
mypde_HRZ.setValue(D=1,q=q)
u_HRZ_old=ref_u(x,-dt)
u_HRZ=ref_u(x,0)
mypde_RS=LinearSinglePDE(domain)
mypde_RS.getSolverOptions().setSolverMethod(SolverOptions.ROWSUM_LUMPING)
mypde_RS.setValue(D=1,q=q)
u_RS_old=ref_u(x,-dt)
u_RS=ref_u(x,0)
l=Locator(domain,[0.5,0.5])
t=0
u=ref_u(x,t)
t_list=[t]
u_list=[l(u)]
f_list=[l(u_f)]
HRZ_list=[l(u_HRZ)]
RS_list=[l(u_RS)]
print(t_list[-1], u_list[-1], f_list[-1], HRZ_list[-1] , RS_list[-1])
while t< 4/n/c:
t+=dt
u=ref_u(x,t)
mypde_f.setValue(X=-c**2*grad(u_f), r=-c**2*u)
mypde_HRZ.setValue(X=-c**2*grad(u_HRZ), r=-c**2*u)
mypde_RS.setValue(X=-c**2*grad(u_RS), r=-c**2*u)
a_f=mypde_f.getSolution()
a_HRZ=mypde_HRZ.getSolution()
a_RS=mypde_RS.getSolution()
u_f, u_f_old = 2*u_f-u_f_old + dt**2*a_f , u_f
u_HRZ, u_HRZ_old = 2*u_HRZ-u_HRZ_old + dt**2*a_HRZ , u_HRZ
u_RS, u_RS_old = 2*u_RS-u_RS_old + dt**2*a_RS , u_RS
t_list.append(t)
u_list.append(l(u))
f_list.append(l(u_f))
HRZ_list.append(l(u_HRZ))
RS_list.append(l(u_RS))
print(t_list[-1], u_list[-1], f_list[-1], HRZ_list[-1] , RS_list[-1])
import matplotlib.pyplot as plt
if getMPIRankWorld() == 0:
plt.clf()
plt.plot(t_list, u_list, '-', label="exact", linewidth=1)
plt.plot(t_list, f_list, '-', label="full", linewidth=1)
plt.plot(t_list, HRZ_list, '-', label="HRZ lumping", linewidth=1)
plt.plot(t_list, RS_list, '-', label="row sum lumping", linewidth=1)
plt.axis([0.,max(t_list),-1.3,1.3])
plt.xlabel('time')
plt.ylabel('displacement')
plt.legend()
plt.savefig('lumping_valet_a_%d.png'%order, format='png')
def runValetAcceleration(order):
domain=finley.Rectangle(100,10,order)
x=domain.getX()
# test Velet scheme
dt=inf(domain.getSize()/c)*(1./6.)
q=whereZero(x[0])+whereZero(x[0]-1.)
mypde_f=LinearSinglePDE(domain)
mypde_f.setSymmetryOn()
mypde_f.setValue(D=1,q=q)
u_f_old=ref_u(x,-dt)
u_f=ref_u(x,0)
mypde_HRZ=LinearSinglePDE(domain)
mypde_HRZ.getSolverOptions().setSolverMethod(SolverOptions.HRZ_LUMPING)
mypde_HRZ.setValue(D=1,q=q)
u_HRZ_old=ref_u(x,-dt)
u_HRZ=ref_u(x,0)
mypde_RS=LinearSinglePDE(domain)
mypde_RS.getSolverOptions().setSolverMethod(SolverOptions.ROWSUM_LUMPING)
mypde_RS.setValue(D=1,q=q)
u_RS_old=ref_u(x,-dt)
u_RS=ref_u(x,0)
l=Locator(domain,[0.5,0.5])
t=0
u=ref_u(x,t)
t_list=[t]
u_list=[l(u)]
f_list=[l(u_f)]
HRZ_list=[l(u_HRZ)]
RS_list=[l(u_RS)]
print(t_list[-1], u_list[-1], f_list[-1], HRZ_list[-1] , RS_list[-1])
while t< 4/n/c:
t+=dt
u=ref_u(x,t)
mypde_f.setValue(X=-c**2*grad(u_f), r=-c**2*u)
mypde_HRZ.setValue(X=-c**2*grad(u_HRZ), r=-c**2*u)
mypde_RS.setValue(X=-c**2*grad(u_RS), r=-c**2*u)
a_f=mypde_f.getSolution()
a_HRZ=mypde_HRZ.getSolution()
a_RS=mypde_RS.getSolution()
u_f, u_f_old = 2*u_f-u_f_old + dt**2*a_f , u_f
u_HRZ, u_HRZ_old = 2*u_HRZ-u_HRZ_old + dt**2*a_HRZ , u_HRZ
u_RS, u_RS_old = 2*u_RS-u_RS_old + dt**2*a_RS , u_RS
t_list.append(t)
u_list.append(l(u))
f_list.append(l(u_f))
HRZ_list.append(l(u_HRZ))
RS_list.append(l(u_RS))
print(t_list[-1], u_list[-1], f_list[-1], HRZ_list[-1] , RS_list[-1])
import matplotlib.pyplot as plt
if getMPIRankWorld() == 0:
plt.clf()
plt.plot(t_list, u_list, '-', label="exact", linewidth=1)
plt.plot(t_list, f_list, '-', label="full", linewidth=1)
plt.plot(t_list, HRZ_list, '-', label="HRZ lumping", linewidth=1)
plt.plot(t_list, RS_list, '-', label="row sum lumping", linewidth=1)
plt.axis([0.,max(t_list),-1.3,1.3])
plt.xlabel('time')
plt.ylabel('displacement')
plt.legend()
plt.savefig('lumping_valet_a_%d.png'%order, format='png')
class SonicWave(WaveBase):
"""
Solving the sonic wave equation
`p_tt = (v_p**2 * p_i)_i + f(t) * delta_s` where (p-) velocity v_p.
f(t) is wavelet acting at a point source term at positon s
"""
def __init__(self, domain, v_p, wavelet, source_tag, dt=None, p0=None, p0_t=None, absorption_zone=300*U.m, absorption_cut=1e-2, lumping=True):
"""
initialize the sonic wave solver
:param domain: domain of the problem
:type domain: `Domain`
:param v_p: p-velocity field
:type v_p: `Scalar`
:param wavelet: wavelet to describe the time evolution of source term
:type wavelet: `Wavelet`
:param source_tag: tag of the source location
:type source_tag: 'str' or 'int'
:param dt: time step size. If not present a suitable time step size is calculated.
:param p0: initial solution. If not present zero is used.
:param p0_t: initial solution change rate. If not present zero is used.
:param absorption_zone: thickness of absorption zone
:param absorption_cut: boundary value of absorption decay factor
:param lumping: if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion.
"""
f=createAbsorptionLayerFunction(Function(domain).getX(), absorption_zone, absorption_cut)
v_p=v_p*f
if p0 == None:
p0=Scalar(0.,Solution(domain))
else:
p0=interpolate(p0, Solution(domain ))
if p0_t == None:
p0_t=Scalar(0.,Solution(domain))
else:
p0_t=interpolate(p0_t, Solution(domain ))
if dt == None:
dt=min(inf((1./5.)*domain.getSize()/v_p), wavelet.getTimeScale())
super(SonicWave, self).__init__( dt, u0=p0, v0=p0_t, t0=0.)
self.__wavelet=wavelet
self.__mypde=LinearSinglePDE(domain)
if lumping: self.__mypde.getSolverOptions().setSolverMethod(SolverOptions.HRZ_LUMPING)
self.__mypde.setSymmetryOn()
self.__mypde.setValue(D=1./v_p**2)
self.__source_tag=source_tag
self.__r=Scalar(0., DiracDeltaFunctions(self.__mypde.getDomain()))
def _getAcceleration(self, t, u):
"""
returns the acceleraton for time t and solution u at time t
"""
self.__r.setTaggedValue(self.__source_tag, self.__wavelet.getValue(t))
self.__mypde.setValue(X=-grad(u,Function(self.__mypde.getDomain())), y_dirac= self.__r)
return self.__mypde.getSolution()
class IsostaticPressure(object):
"""
class to calculate isostatic pressure field correction due to gravity forces
"""
def __init__(self,
domain,
p0=0.,
level0=0,
gravity0=-9.81 * U.m * U.sec**(-2),
background_density=2670 * U.kg * U.m**(-3),
gravity_constant=U.Gravitational_Constant,
coordinates=None,
tol=1e-8):
"""
:param domain: domain of the model
:type domain: `Domain`
:param p0: pressure at level0
:type p0: scalar `Data` or ``float``
:param background_density: defines background_density in kg/m^3
:type background_density: ``float``
:param coordinates: defines coordinate system to be used
:type coordinates: ReferenceSystem` or `SpatialCoordinateTransformation`
:param tol: tolerance of underlying PDE
:type tol: positive ``float``
:param level0: pressure for z>=`level0` is set to zero.
:type level0: ``float``
:param gravity0: vertical background gravity at `level0`
:type gravity0: ``float``
"""
DIM = domain.getDim()
self.__domain = domain
self.__trafo = makeTransformation(domain, coordinates)
self.__pde = LinearSinglePDE(domain)
self.__pde.getSolverOptions().setTolerance(tol)
self.__pde.setSymmetryOn()
z = domain.getX()[DIM - 1]
self.__pde.setValue(q=whereNonNegative(z - level0), r=p0)
fw = self.__trafo.getScalingFactors(
)**2 * self.__trafo.getVolumeFactor()
A = self.__pde.createCoefficient("A")
for i in range(DIM):
A[i, i] = fw[i]
self.__pde.setValue(A=A)
z = Function(domain).getX()[DIM - 1]
self.__g_b = 4 * PI * gravity_constant / self.__trafo.getScalingFactors(
)[DIM - 1] * background_density * (level0 - z) + gravity0
self.__rho_b = background_density
def getPressure(self, g=None, rho=None):
"""
return the pressure for gravity force anomaly `g` and
density anomaly `rho`
:param g: gravity anomaly data
:type g: ``Vector``
:param rho: gravity anomaly data
:type rho: ``Scalar``
:return: pressure distribution
:rtype: ``Scalar``
"""
if not g: g = Vector(0., Function(self.__domain))
if not rho: rho = Scalar(0., Function(self.__domain))
g2 = (rho * self.__g_b) * [0, 0, 1] + self.__rho_b * g + rho * g
# Tests need to be updated before the following is uncommented:
#g2=((rho+self.__rho_b) * self.__g_b)*[0,0,1] + self.__rho_b*g + rho*g
d = self.__trafo.getScalingFactors()
V = self.__trafo.getVolumeFactor()
self.__pde.setValue(X=-g2 * d * V)
#self.__pde.setValue(X = g2*d*V)
return self.__pde.getSolution()
u_supg=u0*1.
c=0
saveVTK("u.%s.vtu"%c,u=u0)
fc.setInitialSolution(u0)
t=T0
while t<T_END:
print("time step t=",t+dt)
u=fc.solve(dt)
if TEST_SUPG:
#========== supg tests ================
nn=max(ceil(dt/dt_supg),1.)
dt2=dt/nn
nnn=0
while nnn<nn :
supg.setValue(X=-dt2/2*E*grad(u_supg),Y=u_supg+dt2/2*inner(V,grad(u_supg)))
u2=supg.getSolution()
supg.setValue(X=-dt2*E*grad(u2),Y=u_supg+dt2*inner(V,grad(u2)))
u_supg=supg.getSolution()
nnn+=1
c+=1
t+=dt
print("QUALITY FCT: time = %s pi"%(t/pi),QUALITY(t,u), end=' ')
if TEST_SUPG:
print("QUALITY SUPG: ",QUALITY(t,u_supg))
# saveVTK("u.%s.vtu"%c,u=u,u_supg=u_supg)
else:
# saveVTK("u.%s.vtu"%c,u=u)
pass
# if c == 20: 1/0
def runTaylorGalerkinIncremental(order):
domain = finley.Rectangle(100, 10, order)
x = domain.getX()
# test Velet scheme
dt = inf(domain.getSize() / length(v)) * (1. / 6.)
q = whereZero(x[0]) + whereZero(x[0] - 1.)
mypde_f = LinearSinglePDE(domain)
mypde_f.setSymmetryOn()
mypde_f.setValue(D=1, q=q)
u_f = ref_u(x, 0)
mypde_HRZ = LinearSinglePDE(domain)
mypde_HRZ.getSolverOptions().setSolverMethod(SolverOptions.HRZ_LUMPING)
mypde_HRZ.setValue(D=1, q=q)
u_HRZ = ref_u(x, 0)
mypde_RS = LinearSinglePDE(domain)
mypde_RS.getSolverOptions().setSolverMethod(SolverOptions.ROWSUM_LUMPING)
mypde_RS.setValue(D=1, q=q)
u_RS = ref_u(x, 0)
l = Locator(domain, [0.5, 0.5])
t = 0
u = ref_u(x, t)
t_list = [t]
u_list = [l(u)]
f_list = [l(u_f)]
HRZ_list = [l(u_HRZ)]
RS_list = [l(u_RS)]
print(t_list[-1], u_list[-1], f_list[-1], HRZ_list[-1], RS_list[-1])
while t < 1. / Lsup(v):
t += dt
u = ref_u(x, t)
mypde_f.setValue(X=-dt / 2. * u_f * v, r=ref_u(x, t - dt / 2) - u_f)
mypde_HRZ.setValue(X=-dt / 2. * u_HRZ * v,
r=ref_u(x, t - dt / 2) - u_f)
mypde_RS.setValue(X=-dt / 2. * u_RS * v, r=ref_u(x, t - dt / 2) - u_f)
u_f_h = u_f + mypde_f.getSolution()
u_HRZ_h = u_HRZ + mypde_HRZ.getSolution()
u_RS_h = u_RS + mypde_RS.getSolution()
mypde_f.setValue(X=-dt * u_f_h * v, r=u - u_f)
mypde_HRZ.setValue(X=-dt * u_HRZ_h * v, r=u - u_HRZ)
mypde_RS.setValue(X=-dt * u_RS_h * v, r=u - u_RS)
u_f = u_f + mypde_f.getSolution()
u_HRZ = u_HRZ + mypde_HRZ.getSolution()
u_RS = u_RS + mypde_RS.getSolution()
t_list.append(t)
u_list.append(l(u))
f_list.append(l(u_f))
HRZ_list.append(l(u_HRZ))
RS_list.append(l(u_RS))
print(t_list[-1], u_list[-1], f_list[-1], HRZ_list[-1], RS_list[-1],
" : ", sup(u))
import matplotlib.pyplot as plt
if getMPIRankWorld() == 0:
plt.clf()
plt.plot(t_list, u_list, '-', label="exact", linewidth=1)
plt.plot(t_list, f_list, '-', label="full", linewidth=1)
plt.plot(t_list, HRZ_list, '-', label="HRZ lumping", linewidth=1)
plt.plot(t_list, RS_list, '-', label="row sum lumping", linewidth=1)
plt.axis([0., max(t_list), -.3, 2.])
plt.xlabel('time')
plt.ylabel('displacement')
plt.legend()
plt.savefig('lumping_SUPG_du_%d.png' % order, format='png')
def runTaylorGalerkinIncremental(order):
domain = finley.Rectangle(100, 10, order)
x = domain.getX()
# test Velet scheme
dt = inf(domain.getSize() / length(v)) * (1.0 / 6.0)
q = whereZero(x[0]) + whereZero(x[0] - 1.0)
mypde_f = LinearSinglePDE(domain)
mypde_f.setSymmetryOn()
mypde_f.setValue(D=1, q=q)
u_f = ref_u(x, 0)
mypde_HRZ = LinearSinglePDE(domain)
mypde_HRZ.getSolverOptions().setSolverMethod(SolverOptions.HRZ_LUMPING)
mypde_HRZ.setValue(D=1, q=q)
u_HRZ = ref_u(x, 0)
mypde_RS = LinearSinglePDE(domain)
mypde_RS.getSolverOptions().setSolverMethod(SolverOptions.ROWSUM_LUMPING)
mypde_RS.setValue(D=1, q=q)
u_RS = ref_u(x, 0)
l = Locator(domain, [0.5, 0.5])
t = 0
u = ref_u(x, t)
t_list = [t]
u_list = [l(u)]
f_list = [l(u_f)]
HRZ_list = [l(u_HRZ)]
RS_list = [l(u_RS)]
print(t_list[-1], u_list[-1], f_list[-1], HRZ_list[-1], RS_list[-1])
while t < 1.0 / Lsup(v):
t += dt
u = ref_u(x, t)
mypde_f.setValue(X=-dt / 2.0 * u_f * v, r=ref_u(x, t - dt / 2) - u_f)
mypde_HRZ.setValue(X=-dt / 2.0 * u_HRZ * v, r=ref_u(x, t - dt / 2) - u_f)
mypde_RS.setValue(X=-dt / 2.0 * u_RS * v, r=ref_u(x, t - dt / 2) - u_f)
u_f_h = u_f + mypde_f.getSolution()
u_HRZ_h = u_HRZ + mypde_HRZ.getSolution()
u_RS_h = u_RS + mypde_RS.getSolution()
mypde_f.setValue(X=-dt * u_f_h * v, r=u - u_f)
mypde_HRZ.setValue(X=-dt * u_HRZ_h * v, r=u - u_HRZ)
mypde_RS.setValue(X=-dt * u_RS_h * v, r=u - u_RS)
u_f = u_f + mypde_f.getSolution()
u_HRZ = u_HRZ + mypde_HRZ.getSolution()
u_RS = u_RS + mypde_RS.getSolution()
t_list.append(t)
u_list.append(l(u))
f_list.append(l(u_f))
HRZ_list.append(l(u_HRZ))
RS_list.append(l(u_RS))
print(t_list[-1], u_list[-1], f_list[-1], HRZ_list[-1], RS_list[-1], " : ", sup(u))
import matplotlib.pyplot as plt
if getMPIRankWorld() == 0:
plt.clf()
plt.plot(t_list, u_list, "-", label="exact", linewidth=1)
plt.plot(t_list, f_list, "-", label="full", linewidth=1)
plt.plot(t_list, HRZ_list, "-", label="HRZ lumping", linewidth=1)
plt.plot(t_list, RS_list, "-", label="row sum lumping", linewidth=1)
plt.axis([0.0, max(t_list), -0.3, 2.0])
plt.xlabel("time")
plt.ylabel("displacement")
plt.legend()
plt.savefig("lumping_SUPG_du_%d.png" % order, format="png")
from esys.escript import *
from esys.escript.linearPDEs import LinearSinglePDE
from esys.weipa import saveVTK
try:
from esys.finley import Rectangle
HAVE_FINLEY = True
except ImportError:
HAVE_FINLEY = False
# generate domain:
if not HAVE_FINLEY:
print("Finley module not available")
else:
mydomain=Rectangle(30,30, l0=3, l1=2,
diracPoints=[(1.,1.), (2.,1.)], diracTags=['in', 'out'])
# fix the solution on the boundary
x = mydomain.getX()
gammaD = whereZero(x[0])+whereZero(x[1])+whereZero(x[0]-3.)+whereZero(x[1]-2.)
# fix the solution on the boundary
s=Scalar(0., DiracDeltaFunctions(mydomain))
s.setTaggedValue('in', +1.)
s.setTaggedValue('out', -1.)
# define PDE and get its solution u
mypde = LinearSinglePDE(domain=mydomain)
mypde.setValue(q=gammaD, A=kronecker(2), y_dirac=s)
u = mypde.getSolution()
print("Solution = ",str(u))
# write u to an external file
saveVTK("u.vtu",sol=u)
from esys.weipa import saveVTK, saveSilo
from esys.escript.linearPDEs import LinearSinglePDE, SolverOptions
from esys.finley import ReadGmsh
from esys.escript.pdetools import Locator
print("read in mesh")
domain = ReadGmsh("simplemesh.msh", 3, optimize=True)
pde = LinearSinglePDE(domain, isComplex=False)
pde.setSymmetryOn()
x = domain.getX()
pde.setValue(A=kronecker(3), Y=1, q=whereZero(x[0] - inf(x[0])))
options = pde.getSolverOptions()
options.setPackage(SolverOptions.TRILINOS)
options.setSolverMethod(SolverOptions.PCG)
options.setPreconditioner(SolverOptions.AMG)
options.setTrilinosParameter("multigrid algorithm", "sa")
options.setTrilinosParameter("sa: damping factor", 1.3)
options.setTrilinosParameter("max levels", 10)
options.setTrilinosParameter("coarse: max size", 2000)
options.setTrilinosParameter("coarse: type", "SuperLU")
options.setTrilinosParameter("verbosity", "low")
print("solve pde")
u = pde.getSolution()
saveSilo("asimple", u=u)
print("finished")
try:
from esys.finley import Rectangle
HAVE_FINLEY = True
except ImportError:
HAVE_FINLEY = False
# generate domain:
if not HAVE_FINLEY:
print("Finley module not available")
else:
mydomain = Rectangle(30,
30,
l0=3,
l1=2,
diracPoints=[(1., 1.), (2., 1.)],
diracTags=['in', 'out'])
# fix the solution on the boundary
x = mydomain.getX()
gammaD = whereZero(x[0]) + whereZero(
x[1]) + whereZero(x[0] - 3.) + whereZero(x[1] - 2.)
# fix the solution on the boundary
s = Scalar(0., DiracDeltaFunctions(mydomain))
s.setTaggedValue('in', +1.)
s.setTaggedValue('out', -1.)
# define PDE and get its solution u
mypde = LinearSinglePDE(domain=mydomain)
mypde.setValue(q=gammaD, A=kronecker(2), y_dirac=s)
u = mypde.getSolution()
print("Solution = ", str(u))
# write u to an external file
saveVTK("u.vtu", sol=u)
