x = X[0]
y = X[1]
return g(*X)+\
-y*(y-1.)*(y-3.)/30.*(np.sin(2.*x)-g(x,-2.*np.ones_like(y)))+\
(y+2.)*(y-1.)*(y-3.)/6.*(5.*np.sqrt(np.abs(x))-g(x,np.zeros_like(y)))+\
-y*(y+2.)*(y-3.)/6.*(9.*np.exp(-x**2)-g(x,np.ones_like(y)))+\
y*(y+2.)*(y-1.)/30.*((1.-x)-g(x,3.*np.ones_like(y)))
# Create plot 1:
g = lambda *x: np.zeros_like(x[0])
lineKwargs = dict(mode='lines',showlegend=False,
line=dict(width=5,color='black'))
zLift = 0.05
p = MakePlot('x','y',zlabs='u(x,y,g(x,y))')
p.Scatter3d(x=x,y=-2.*np.ones_like(y),z=np.sin(2.*x)+zLift,**lineKwargs)
p.Scatter3d(x=x,y=np.zeros_like(y),z=5.*np.sqrt(np.abs(x))+zLift,**lineKwargs)
p.Scatter3d(x=x,y=np.ones_like(y),z=9.*np.exp(-x**2)+zLift,**lineKwargs)
p.Scatter3d(x=x,y=3.*np.ones_like(y),z=(1.-x)+zLift,**lineKwargs)
p.Surface(x=X[0],y=X[1],z=u(g,*X),showscale=False)
p.view(-35.,25.)
# Create plot 2:
g = lambda x,y: x**2*y-np.sin(5.*x)*np.cos(4.*(y%1.5))
p1 = MakePlot('x','y',zlabs='u(x,y,g(x,y))')
p1.Scatter3d(x=x,y=-2.*np.ones_like(y),z=np.sin(2.*x)+zLift,**lineKwargs)
p1.Scatter3d(x=x,y=np.zeros_like(y),z=5.*np.sqrt(np.abs(x)),**lineKwargs)
p1.Scatter3d(x=x,y=np.ones_like(y),z=9.*np.exp(-x**2)+zLift,**lineKwargs)
p1.Scatter3d(x=x,y=3.*np.ones_like(y),z=(1.-x)+zLift,**lineKwargs)
p1.Surface(x=X[0],y=X[1],z=u(g,*X),showscale=False)
matHyp = np.meshgrid(v,th)
phi = np.linspace(0.,np.pi,100)
matEll = np.meshgrid(phi,th)
xHyp = lambda n,v,th: aHyp*np.sinh(np.abs(v))*np.cos(th)+3.
yHyp = lambda n,v,th: bHyp*np.sinh(np.abs(v))*np.sin(th)
zHyp = lambda n,v,th: (-1.)**step(n)*cHyp*np.cosh(np.abs(v))
xEll = lambda phi,th: aEll*np.sin(phi)*np.cos(th)
yEll = lambda phi,th: bEll*np.sin(phi)*np.sin(th)
zEll = lambda phi,th: cEll*np.cos(phi)
opacity = 0.6
p = MakePlot('x','y',zlabs='z')
p.Surface(x=xHyp(1.,*matHyp),
y=yHyp(1.,*matHyp),
z=zHyp(1.,*matHyp),
showscale=False,
colorscale=[[0.,"rebeccapurple"],[1.,"rebeccapurple"]],
opacity=opacity)
p.Surface(x=xHyp(-1.,*matHyp),
y=yHyp(-1.,*matHyp),
z=zHyp(-1.,*matHyp),
showscale=False,
colorscale=[[0.,"rebeccapurple"],[1.,"rebeccapurple"]],
opacity=opacity)
p.Surface(x=xEll(*matEll),
y=yEll(*matEll),
z=zEll(*matEll),
u = lambda x, y: u1(x, y) + (1. - 2. * y) / 2. * (u1(x, 2. * np.ones_like(y)) -
u1(x, np.ones_like(y)) - 2.)
v1 = lambda x, y: gv(x, y) + 5. - np.cos(np.pi * y) - gv(np.zeros_like(x), y)
v = lambda x, y: v1(x, y) + 5. - v1(x, np.zeros_like(y)) - u(
x, np.zeros_like(y))
# Plot results
U = u(x, y).reshape((n, n))
V = v(x, y).reshape((n, n))
if usePlotly:
from tfc.utils.PlotlyMakePlot import MakePlot
p = [
MakePlot(r"x", r"y", zlabs=r"u(x,y,g<sup>u</sup>(x,y))"),
MakePlot(r"x",
r"y",
zlabs=r"v(x,y,g<sup>v</sup>(x,y),g<sup>u</sup>(x,y))")
]
p[0].Surface(x=dark[0], y=dark[1], z=U, showscale=False)
p[0].Scatter3d(x=np.zeros_like(x),
y=y,
z=np.cos(np.pi * y),
mode='lines',
line=dict(color='black', width=10))
p[1].Surface(x=dark[0], y=dark[1], z=V, showscale=False)
p[1].Scatter3d(x=np.zeros_like(x),
y=y,
z=5. - np.cos(np.pi * y),
mode='lines',
import jax.numpy as np
from tfc.utils.PlotlyMakePlot import MakePlot
# Create X:
n = [40,40]
dark = np.linspace(-1.,1.,n[0])
xMat = np.meshgrid(dark,dark)
x = [k.flatten() for k in xMat]
# Create the constrained expression:
g = lambda *x: np.sin(3.*np.pi/4.*x[0])*np.sin(np.pi/2.*x[1])
u = lambda *x: g(*x)+5.-g(np.zeros_like(x[0]),np.zeros_like(x[1]))
# Plot:
p = MakePlot('x','y',zlabs='u(x,y,g(x,y))')
U = u(*x)
p.Surface(x=xMat[0],y=xMat[1],z=U.reshape(n),showscale=False)
p.Scatter3d(x=[0.],y=[0.],z=[5.],mode='markers',
marker=dict(size=4),line=dict(color='red'))
p.view(-45,50)
p.show()
coons = np.zeros_like(x)
for j in range(x.shape[0]):
for k in range(x.shape[1]):
phix = PhiX(x[j, k])
phiy = PhiX(y[j, k])
coons[j, k] = np.linalg.multi_dot([phix, A(x[j, k], y[j, k]), phiy])
ce[j, k] = g(x[j, k], y[j, k]) + np.linalg.multi_dot(
[phix, M(x[j, k], y[j, k]), phiy])
# Create the plots
line = np.linspace(0., 1., 100)
zero = np.zeros_like(line)
one = np.ones_like(line)
width = 7
p1 = MakePlot('x', 'y', zlabs='u(x,y,g(x,y))')
p1.Surface(x=x, y=y, z=ce, showscale=False)
p1.Scatter3d(x=zero,
y=line,
z=np.sin(2. * np.pi * line),
mode='lines',
line=dict(color='red', width=width))
p1.Scatter3d(x=one,
y=line,
z=3. * np.cos(4. * np.pi * line),
mode='lines',
line=dict(color='red', width=width))
p1.Scatter3d(x=line,
y=zero,
z=3. * line**2,
mode='lines',
# Create X:
n = [50, 50]
xMat = np.meshgrid(np.linspace(-4., 4., 50), np.linspace(-4., 4., 50))
x = xMat[0].flatten() + 1.j * xMat[1].flatten()
# Create the constrained expression:
g = lambda x: 0.25 * x + np.cos(x / 4.) * 0.3j
uslow = lambda x: g(x)\
+((-44.+8.j)*x**2+(52.+36.j)*x+(132.-24.j))/125.*(1.+np.pi*1.j-g(0.5j*np.ones_like(x)))\
+((69.+67.j)/125.*x**2-(129.+397.j)/250.*x+(-82.+49.j)/125.)*(g(np.ones_like(x))-g(1.j*np.ones_like(x)))\
+((44.-8.j)*x**2-(52.+36.j)*x+(-7.+24.j))/125.*(2.j-g(np.ones_like(x)*(2.+1.j))-egrad(g)(np.ones_like(x)))
u = jit(uslow)
# Plot:
p = MakePlot('Re[x]', 'Im[x]', zlabs='Re[u(x,g(x))]')
p2 = MakePlot('Re[x]', 'Im[x]', zlabs='Im[u(x,g(x))]')
# Add constraints
p.Scatter3d(
x=[0.],
y=[1. / 2.],
z=[1.],
mode="markers",
marker=dict(color="red", size=5),
)
p2.Scatter3d(
x=[0.],
y=[1. / 2.],
z=[np.pi],
mode="markers",
nTest = 100
dark = np.meshgrid(np.linspace(x0[0], xf[0], nTest),
np.linspace(x0[1], xf[1], nTest))
xTest = (dark[0].flatten(), dark[1].flatten())
err = np.abs(real(*xTest) - u(xi, *xTest))
# Print out solution statistics
print("Time: " + str(time))
print("Max error test: " + str(np.max(err)))
print("Mean error test: " + str(np.mean(err)))
# Create plots
if usePlotly:
from tfc.utils.PlotlyMakePlot import MakePlot
p = MakePlot(r'x', r't', zlabs=r'u(x,t)')
p.Surface(x=x[0].reshape((n, n)),
y=x[1].reshape((n, n)),
z=real(*x).reshape((n, n)),
showscale=False)
p.view(azimuth=-135, elevation=20)
p.fig['layout']['scene']['aspectmode'] = 'cube'
p.show()
p1 = MakePlot('x', 'y', zlabs='error')
p1.Surface(x=dark[0], y=dark[1], z=err.reshape((nTest, nTest)))
p1.show()
else:
from matplotlib import cm
from tfc.utils import MakePlot
dgn1 = lambda xi, *x: egrad(g, 1)(xi, *x) * n1[0] + egrad(g, 2)(xi, *x) * n1[1]
intgn2 = lambda t: -1. / 2. * np.cos(t)**2 * np.sqrt(2.)
u1 = lambda xi,*x: g(xi,*x)+\
n1mag*(Ainv(*x)[0]-1.)*(0.5-dgn1(xi,*A(np.zeros_like(x[0]),Ainv(*x)[1])))+\
1./n2mag*(-2.-intgn2(5.)+intgn2(4.))
uslow = lambda xi,*x: u1(xi,*x)+\
(1./2.-Ainv(*x)[1])*(u1(xi,*A(Ainv(*x)[0],np.ones_like(x[1])))-u1(xi,*A(Ainv(*x)[0],np.zeros_like(x[1]))))
u = jit(uslow)
# Plot:
x = A(*X)
xi = np.zeros(5)
xmat = [k.reshape(n) for k in x]
p = MakePlot('x', 'y', zlabs='u(x,y,g(x,y))')
# Add constraints
c3x = (np.linspace(2., 4., 100), np.linspace(3., 4., 100))
c3u = u(xi, *c3x)
p.Scatter3d(x=c3x[0],
y=c3x[1],
z=c3u,
mode="lines",
line=dict(color="red", width=5))
p.Scatter3d(x=c3x[0] + 1.,
y=c3x[1] + 1.,
z=c3u,
mode="lines",
line=dict(color="red", width=5))
xTest = tuple([k.flatten() for k in dark])
err = np.abs(real(*xTest) - u(xi, *xTest))
# Print out solution statistics
print("Time: " + str(time))
print("Max error test: " + str(np.max(err)))
print("Mean error test: " + str(np.mean(err)))
# Create plots
n = 100
X, Y = np.meshgrid(np.linspace(0., 1., 100), np.linspace(0., 1., 100))
if usePlotly:
from tfc.utils.PlotlyMakePlot import MakePlot
p = MakePlot(r'x', r'y', zlabs=r'u(x,y,0.5)')
p.Surface(x=X, y=Y, z=real(X, Y, 0.5 * np.ones_like(X)), showscale=False)
p.view(azimuth=45, elevation=40)
p.fig['layout']['scene']['aspectmode'] = 'cube'
p.show()
else:
from matplotlib import cm
from tfc.utils import MakePlot
p = MakePlot(r'$x$', r'$y$', zlabs=r'$u(x,y,0.5)$')
p.ax[0].plot_surface(X,
Y,
real(X, Y, 0.5 * np.ones_like(X)),
cmap=cm.gist_rainbow,
antialiased=False,
from tfc.utils.PlotlyMakePlot import MakePlot
# Create X:
n = [20, 20, 20]
dark = np.linspace(0., 1., n[0])
xMat = onp.mgrid[0:1:20j, 0:1:20j, 0:1:20j]
x = [k.flatten() for k in xMat]
# Create the constrained expression:
g = lambda *x: np.cos(x[0]) * np.sqrt(x[1]) + x[2]**2
u = lambda *x: g(*x)\
+x[2]*(np.sin(x[0])*np.cos(x[1])-g(x[0],x[1],np.ones_like(x[2])))\
+(1-x[2])*((1-x[0])*(np.exp(x[1])-g(np.zeros_like(x[0]),x[1],np.zeros_like(x[2])))\
+x[0]*((1.-x[1])*(3.-g(np.ones_like(x[0]),np.zeros_like(x[1]),np.zeros_like(x[2])))\
+x[1]*(5.-g(np.ones_like(x[0]),np.ones_like(x[1]),np.zeros_like(x[2])))))
# Plot:
p = MakePlot('x', 'y', zlabs='z')
U = u(*x)
p.Volume(x=x[0], y=x[1], z=x[2], value=U)
p.view(-45, 30)
p.show()
# Error in constraints
e1 = np.max(
np.abs(np.sin(x[0]) * np.cos(x[1]) - u(x[0], x[1], np.ones_like(x[2]))))
e2 = np.max(
np.abs(np.exp(dark) - u(np.zeros_like(dark), dark, np.zeros_like(dark))))
e3 = np.max(np.abs(3. - u(np.array([1.]), np.array([0.]), np.array([0.]))))
e4 = np.max(np.abs(5. - u(np.array([1.]), np.array([1.]), np.array([0.]))))
du1dy = egrad(u1,1)
u = lambda x,y: u1(x,y)\
-(y-y**2)*du1dy(x,np.zeros_like(y))\
-y**2*(u1(x,np.ones_like(y))-u1(x,np.zeros_like(y)))
# Plot the results
U = u(x,y)
ind1 = np.where(x==0.)[0]
ind2 = np.where(y==0.)[0]
ind3 = np.where(y==1.)[0]
if usePlotly:
from tfc.utils.PlotlyMakePlot import MakePlot
p = MakePlot(r'x',r'y',zlabs=r'u(x,y,g(x,y))')
p.Surface(x=dark[0], y=dark[1], z=U.reshape((n,n)),
showscale=False)
for k,el in enumerate(ind2):
if not k%5:
p.Scatter3d(x=np.array([x[el],]*2),
y=np.array([0.,0.05]),
z=np.array([u(x[el],0.),]*2),
mode='lines',
line=dict(color='black',width=5))
p.Scatter3d(x=x[ind1],
y=y[ind1],
z=c1(y[ind1]),
mode='lines',
line=dict(color='blue',width=10))
p.Scatter3d(x=x[ind2],
# Calculate error at the test points:
dark = np.meshgrid(np.linspace(xInit, xFinal, nTest),
np.linspace(0., 1., nTest))
xTest = tuple([j.flatten() for j in dark])
err = np.abs(u(xi, *xTest) - real(*xTest))
print("Training time: " + str(time))
print("Max error: " + str(np.max(err)))
print("Mean error: " + str(np.mean(err)))
# Plot analytical solution
if usePlotly:
from tfc.utils.PlotlyMakePlot import MakePlot
p = MakePlot(r"x", r"t", zlabs=r"u(x,t)")
p.Surface(x=xTest[0].reshape((nTest, nTest)),
y=xTest[1].reshape((nTest, nTest)),
z=real(*xTest).reshape((nTest, nTest)),
showscale=False)
p.PartScreen(9, 8)
p.show()
else:
from matplotlib import cm
from MakePlot import MakePlot
p = MakePlot(r"$x$", r"$t$", zlabs=r"$u(x,t)$")
p.ax[0].plot_surface(xTest[0].reshape((nTest, nTest)),
xTest[1].reshape((nTest, nTest)),
real(*xTest).reshape((nTest, nTest)),
# Create the loss function:
ur = egrad(u, 1)
u2r = egrad(ur, 1)
u2th = egrad(egrad(u, 2), 2)
L = lambda xi: u2r(xi, *x) + 1. / x[0] * ur(xi, *x) + 1. / x[0]**2 * u2th(
xi, *x)
# Solve the problem:
xi = np.zeros(H(*x).shape[1])
xi, it, time = NLLS(xi, L, timer=True)
# Print out statistics:
print("Solution time: {0} seconds".format(time))
# Plot the solution:
R, Th = np.meshgrid(np.linspace(r0, rf, 50), np.linspace(th0, thf, 200))
dark = (R.flatten(), Th.flatten())
X = R * np.cos(Th)
Y = R * np.sin(Th)
U = u(xi, *dark).reshape((200, 50))
p = MakePlot("x", "y", zlabs="u(x,y,g(x,y))")
p.Surface(x=X, y=Y, z=U, showscale=False)
p.show()
# Plot the error
err = np.abs(realSoln(R, Th) - U)
p = MakePlot("x", "y", zlabs="Error")
p.Surface(x=X, y=Y, z=err, showscale=False)
p.show()