Main goals
Nedan visas diskretiseringen av domänen för de olika metoderna
Vi löser med FEniCS, periodiska randvillkor i x-riktningen. Den streckade linjen visar var vi ska evaluera lösningarna för jämförelsen.
Spektral metod med Navier-slip koppling mellan mikro och makro, 5 st mikroproblem, vardera med storleken 5.13 epsilon (för att undvika heltal så att frekvensen matchas exakt)
Nedan visas lösningarna längsmed den streckade linjen i figur 1.
import sys
sys.path.append('/home/emastr/phd/')
import torch
import time
import numpy as np
import matplotlib.pyplot as plt
from stokes2d.robin_solver import testSolve, solveRobinStokes_fromFunc
from util.plot_tools import *
from boundary_solvers.geometry import MacroGeom
We define a multiscale problem as follows. The PDE is a non-slip zero forcing Stokes flow Problem
\[\Delta u - \nabla p = 0, \qquad \qquad \nabla \cdot u = 0 \qquad \text{inside}\quad \Omega\]with the boundary conditions
\[u = g,\qquad \text{on}\quad\partial\Omega\]the boundary is a two-dimensional pipe with corners at (0,-1) and (1,1), and a micro scale boundary:
from hmm.stokes import StokesMacProb, StokesMicProb, trig_interp, StokesData, StokesHMMProblem
from hmm.stokes import MacroSolver, MicroSolver, IterativeHMMSolver
from util.plot_tools import *
eps = 0.02
k = round(1 / eps / 4) * 4
A = 0.5
h = 1.5
f = lambda x: eps * (-h + A * np.cos(k*x)) #1.6
df = lambda x: -eps * k * np.sin(k*x) * A
ddf = lambda x: -eps * (k**2) * np.cos(k*x) * A
g = lambda x: 1+np.sin(2*np.pi * x) * 0.0
data = StokesData(f, df, ddf, g)
plt.figure(figsize=(10,10))
plt.title("Multi Scale Domain")
data.plot(plt.gca())
remove_axes(plt.gca())
plt.axis("equal")
(-0.05, 1.05, -1.1419995844364166, 1.101999980211258)
To couple the macro domain to the microscopic domain, we make use of the HMM framework. We construct a set of evenly spaced micro problems based on the Stokes data. The macro problem is constructed with a pre-specified resolution in the x- and y-directions.
# Macro problem
xDim = 21
yDim = 23
iDeg = 13 #nMic*2 +1
macro = StokesMacProb(data, lambda x,a: trig_interp(x,a, iDeg))
# Micro problems
nMic = 9
xPos = np.linspace(4*eps, 1-4*eps, nMic)-2*eps
micros = [StokesMicProb(data, x, 3*eps, 3*eps, 0.01) for x in xPos]
# Hmm problem.
hmm_prob = StokesHMMProblem(macro, micros, data)
## PLOT ##
plt.figure(figsize=(15,5))
plt.subplot2grid((1,4), (0,0), colspan=1)
plt.title("Multi Scale Problem")
hmm_prob.plot(plt.gca())
plt.axis("Equal")
remove_axes(plt.gca())
plt.subplot2grid((1,4), (0,1), colspan=3)
plt.title("Micro Problem Positions")
hmm_prob.plot(plt.gca())
plt.axis("Equal")
remove_axes(plt.gca())
plt.xlim([-eps,1 + eps])
plt.ylim([-1-1*eps, -1+6*eps])
(-1.02, -0.88)
To solve the problem, we make use of a sequence of micro solvers, as well as a micro solver.
class Callback():
def __init__(self, macro):
self.N = 100
self.x = np.linspace(0,1,self.N)
self.macro = macro
self.current_alpha = macro.alpha(self.x)
self.diff = []
def __call__(self, it, macro_sol, micro_sols):
self.previous_alpha = self.current_alpha
self.current_alpha = self.macro.alpha(self.x)
self.diff.append(np.linalg.norm(self.previous_alpha - self.current_alpha) / self.N**0.5)
debug_cb = Callback(macro)
print("Precomputing...")
macro_solver = MacroSolver(xDim, yDim)
micro_solvers = [MicroSolver(m) for m in micros]
hmm_solver = IterativeHMMSolver(macro_solver, micro_solvers)
print("Done")
print("HMM Solver...")
macro_guess = macro_solver.solve(macro)
(macro_sol, micro_sols) = hmm_solver.solve(hmm_prob, macro_guess=macro_guess,
callback=debug_cb, verbose=True, maxiter=7)
print("\nDone")
Precomputing...
Done
HMM Solver...
Step 6/7
Done
plt.figure()
plt.title("RMS of difference between iterates")
plt.semilogy(debug_cb.diff, 'b*--')
plt.xlabel("Iterate n")
plt.ylabel("RMS of a_n - a_(n+1)")
Text(0, 0.5, 'RMS of a_n - a_(n+1)')
plt.figure(figsize=(20,10))
plt.subplot(121)
plt.axis("equal")
hmm_prob.plot(plt.gca())
macro_sol.u.plot(plt.gca())
macro_sol.plot_stream(plt.gca(), color="white")
plt.subplot(122)
micros[0].plot(plt.gca())
micros[0].geom.plot_field_on_boundary(plt.gca(), micros[0].condition)
plt.axis("equal")
plt.figure()
plt.title("Alpha")
x = np.linspace(0,1,100)
a = macro.alpha(x)
xm = np.array([sol.x for sol in micro_sols])
am = np.array([sol.alpha for sol in micro_sols])
plt.plot(x, a)
plt.plot(xm, am)
#print(macro.alpha)
#plt.figure(figsize=(10,6))
#plt.title("Condition")
#t = np.linspace(0,2*np.pi, 300)
#v = micros[0].condition(t)
#plt.plot(t, np.real(v))
#plt.plot(t, np.imag(v))
#plt.xlim([1,3])
[<matplotlib.lines.Line2D at 0x7fa5cd550100>]
from scipy.io import loadmat
import matplotlib.pyplot as plt
matf = loadmat("/home/emastr/phd/data/reference/run_24.mat", struct_as_record=True)
info = matf['info'][0][0]
Uc = info['Uc']
Vc = info['Vc']
mask = np.isnan(Uc)
Uc = np.where(mask, -np.ones_like(Uc), Uc)
X = info['X']
Y = info['Y']
plt.figure(figsize=(15,5))
plt.imshow(Uc[::-1, ::-1], vmin=-0.5, vmax=0.5)
plt.ylim([220, 100])
(220.0, 100.0)
Below is a list of useful literature on the subject, along with comments.
Tutorials in multi scale problems by Runborg et al. Some tutorials on Multi Scale Simulations (FMM, Wavelet analysis.) The one on Wavelet analysis is interesting (Runborg.)
Introductory book
Homogenization recap in Appendix B:
Typically a problem of the form
$ \nabla \cdot (a(x/\epsilon) \nabla u(x)) + a_0(x/\epsilon) u(x) = f(x), \implies L_\epsilon u = f $
where $a$ and $a_0$ are 1-periodic functions. Goal is to study the limit as $\epsilon \to 0$. Homogenisation theory is not what we are interested in. Instead, we want to minimize error of a low resolution approximation, at a nonzero $\epsilon$. Of course we still want convergence to homogenized solution as $\epsilon \to 0$. The 1-d homogenization consists of taking the harmonic average.
The standard assumption seems to be periodic multi scale:
$ u(x) = \tilde{u}(x) + \phi(x/\epsilon), $
where $\tilde{u}$ and $\phi$ are periodic, and $\tilde{u}$ is band limited to some large scale $»1/\epsilon$.
Hmm in this case gives us a lot of control. As the number of micro domains tends to infinity, and their sizes tends to zero, we will converge very close to the true solution (depending on how accurate our boundary extrapolation is). Where do we then choose the cutoff?
Below is a list of useful literature on the subject, along with comments.
Tutorials in multi scale problems by Runborg et al. Some tutorials on Multi Scale Simulations (FMM, Wavelet analysis.) The one on Wavelet analysis is interesting (Runborg.)
Introductory book
Homogenization recap in Appendix B:
Typically a problem of the form
\(\nabla \cdot (a(x/\epsilon) \nabla u(x)) + a_0(x/\epsilon) u(x) = f(x), \implies L_\epsilon u = f\)
where $a$ and $a_0$ are 1-periodic functions. Goal is to study the limit as $\epsilon \to 0$. Homogenisation theory is not what we are interested in. Instead, we want to minimize error of a low resolution approximation, at a nonzero $\epsilon$. Of course we still want convergence to homogenized solution as $\epsilon \to 0$. The 1-d homogenization consists of taking the harmonic average.
The standard assumption seems to be periodic multi scale:
\(u(x) = \tilde{u}(x) + \phi(x/\epsilon),\)
where $\tilde{u}$ and $\phi$ are periodic, and $\tilde{u}$ is band limited to some large scale $»1/\epsilon$.
_posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.
Jekyll requires blog post files to be named according to the following format:
YEAR-MONTH-DAY-title.MARKUP
Where YEAR is a four-digit number, MONTH and DAY are both two-digit numbers, and MARKUP is the file extension representing the format used in the file. After that, include the necessary front matter. Take a look at the source for this post to get an idea about how it works.
Jekyll also offers powerful support for code snippets:
def print_hi(name)
puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.
]]>_posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.
Jekyll requires blog post files to be named according to the following format:
YEAR-MONTH-DAY-title.MARKUP
Where YEAR is a four-digit number, MONTH and DAY are both two-digit numbers, and MARKUP is the file extension representing the format used in the file. After that, include the necessary front matter. Take a look at the source for this post to get an idea about how it works.
Jekyll also offers powerful support for code snippets:
def print_hi(name)
puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.
]]>The micro domain is defined by a bounding box and a smooth function parameterising the floor of the micro domain.
import sys
sys.path.append('/home/emastr/phd/')
import numpy as np
import torch as pt
import torch.autograd as agrad
import matplotlib.pyplot as plt
from util.plot_tools import *
from architecture.fno_1d import *
from boundary_solvers.blobs import *
from boundary_solvers.geometry import *
from scipy.sparse.linalg import gmres, LinearOperator
from operators.stokes_operator import StokesAdjointBoundaryOp
from util.unet import *
import torch.nn as nn
Load and transform the data.
def unpack_data(data):
xlabels = ['x', 'y', 'dx', 'dy', 'ddx', 'ddy', 'vx', 'vy', 'w', 't']
ylabels = ['rx', 'ry']
inp = {xlabels[i]: data['X'][:, i, :] for i in range(10)}
out = {ylabels[i]: data['Y'][:, i, :] for i in range(2)}
return (inp, out)
def unpack(transform):
"""Decorator for if a method is supposed to act on the values of a dict."""
def up_transform(data, *args, **kwargs):
if type(data) == dict:
return {k: transform(data[k], *args, **kwargs) for k in data.keys()}
else:
return transform(data, *args, **kwargs)
return up_transform
@unpack
def subsample(x, idx):
return x[idx]
@unpack
def integrate(x, w):
return torch.cumsum(x * w, axis=len(x.shape)-1)
def subdict(dic, keys):
return {k: dic[k] for k in keys if k in dic.keys()}
def concat_dict_entries(data):
return torch.cat(tuple((d[:, None, :] for d in data.values())), dim=1)
def arclength(dx, dy, w):
return integrate((dx**2 + dy**2)**0.5, w)
def normalize(dx, dy):
"""Normalize 2-dim vector"""
mag = (dx**2 + dy**2)**0.5
return dx/mag, dy/mag
def curvature(dx, dy, ddx, ddy):
"""Find curvature of line segment given points"""
mag = (dx**2 + dy**2)**0.5
return (dx * ddy - dy * ddx) / (mag ** 3)
def invariant_quantities(inp):
labels = ('tx', 'ty', 'c')
tx, ty = normalize(inp['dx'], inp['dy'])
c = curvature(inp['dx'], inp['dy'], inp['ddx'], inp['ddy'])
data = (tx, ty, c)
return {labels[i]: data[i] for i in range(len(data))}
Next, we need a way to create the integral operator from a data batch.
def op_factory(inp):
Z = inp['x'] + 1j * inp['y']
dZ = inp['dx'] + 1j * inp['dy']
ddZ = inp['ddx'] + 1j * inp['ddy']
W = inp['w']
a = torch.ones(Z.shape[0],) * 0.5 * 1j
return StokesAdjointBoundaryOp(Z, dZ, ddZ, W, a)
Load Data
@unpack
def to_dtype(tensor, dtype):
return tensor.to(dtype)
# Load and transform
data = torch.load(f"/home/emastr/phd/data/problem_data_riesz_TEST.torch")
inp, out = unpack_data(data)
dtype = torch.double
inp, out = to_dtype(inp, dtype), to_dtype(out, dtype)
# Add invariant quantities to data.
inp.update(invariant_quantities(inp))
# Normalise curvature using monotone function sigmoid(x/2) - 1/2.
inp['c'] = 1/(1 + torch.exp(-0.5 * inp['c'])) - 0.5
Split into training and test data
# Standard features (coordinates, derivatives of parameterisation)
features = {'x', 'y', 'dx','dy','ddx','ddy','vx','vy'}
# Invariant features (coordinates, tangent, curvature)
features = {'x', 'y', 'tx', 'ty', 'c', 'vx', 'vy'}
# Reduced features (trust fourier transform to handle the rest)
features = {'x', 'y', 'vx', 'vy'}
## TRAINING DATA
M_train = 200#0
M_batch = 5 # Batch
idx_train = list(range(M_train))
X_train = concat_dict_entries(subdict(subsample(inp, idx_train), features))
V_train = concat_dict_entries(subdict(subsample(inp, idx_train), {'vx', 'vy'}))
Y_train = concat_dict_entries(subsample(out, idx_train))
#X_train = subdict(X_train, {'vx', 'vy'})
## TEST DATA
M_test = 100#0
idx_test = list(range(M_train, M_test + M_train))
X_test = concat_dict_entries(subdict(subsample(inp, idx_test), features))
V_test = concat_dict_entries(subdict(subsample(inp, idx_test), {'vx', 'vy'}))
Y_test = concat_dict_entries(subsample(out, idx_test))
#X_test = subdict(X_test, {'vx', 'vy'})
in_channels = len(features)
out_channels = 2
Create network
settings = {"modes": 10,
"input_features": features}
net = FNO1d(modes=settings["modes"], in_channels=in_channels, out_channels=out_channels)
Do training
# Predefine list of losses
trainloss = []
testloss = []
# Loss function
loss_fcn = nn.MSELoss()
benchloss = loss_fcn(V_test, Y_test).item()
optim = torch.optim.Adam(net.parameters())
# DO TRAINING LOOP
##################################################
N = 30001 #30001
for i in range(N):
idx_batch = torch.randperm(M_train)[:M_batch]
Y_batch = Y_train[idx_batch]
X_batch = X_train[idx_batch]
# Train on truncated net that expands as iterations progress
loss = loss_fcn(net(X_batch), Y_batch)
loss.backward()
optim.step()
trainloss.append(loss.item())
testloss.append(loss_fcn(net(X_test), Y_test).item())
optim.zero_grad()
print(f"Step {i}. Train loss = {trainloss[-1]}, test loss = {testloss[-1]}, benchmark={benchloss}", end="\r")
if i % 1000 == 0:
torch.save({"state dict" : net.state_dict(),
"settings" : settings,
"trainloss" : trainloss,
"testloss" : testloss},
f"/home/emastr/phd/data/fno_adjoint_state_dict_2022_12_02_default5_{i}.Torch") # old namme unet_state_dict #Kernel size 5, stride 2
Step 30000. Train loss = 0.00014250755874667165, test loss = 0.0002593944797511047, benchmark=0.0248016101648704522
save = torch.load(f"/home/emastr/phd/data/fno_adjoint_state_dict_2022_12_02_default5_{30000}.Torch")
trainloss = save["trainloss"]
testloss = save["testloss"]
net.load_state_dict(save["state dict"])
<All keys matched successfully>
Y_net = net(X_test)
Y_net = Y_net.detach()
for i in [90]:
plt.figure(1)
plt.plot(V_test[i, 0, :], label='inpx')
plt.plot(Y_net[i, 0, :], label='netx')
plt.plot(Y_test[i, 0, :], '--', label='outx')
plt.legend()
plt.figure(2)
plt.plot(V_test[i, 1, :])
plt.plot(Y_net[i, 1, :])
plt.plot(Y_test[i, 1, :])
plt.figure(3)
plt.semilogy(np.linspace(0,1,len(trainloss)), trainloss)
plt.semilogy(np.linspace(0,1,len(testloss)), testloss)
plt.figure(4)
plt.plot(inp['x'][0, :], inp['y'][0, :])
plt.quiver(inp['x'][0,:], inp['y'][0,:], inp['dy'][0,:], -inp['dx'][0,:])
plt.quiver(inp['x'][0,:], inp['y'][0,:], inp['ddx'][0,:], inp['ddy'][0,:], color='red')
plt.axis("equal")
(-0.8800000131130219,
0.8800000131130219,
-0.6743489861488342,
1.0797309041023255)
The micro domain is defined by a bounding box and a smooth function parameterising the floor of the micro domain.
import sys
sys.path.append('/home/emastr/phd/')
import numpy as np
import torch as pt
import torch.autograd as agrad
import matplotlib.pyplot as plt
from util.plot_tools import *
from architecture.fno_1d import *
from boundary_solvers.blobs import *
from boundary_solvers.geometry import *
from scipy.sparse.linalg import gmres, LinearOperator
from operators.stokes_operator import StokesAdjointBoundaryOp
from util.unet import *
import torch.nn as nn
Load and transform the data.
def unpack_data(data):
xlabels = ['x', 'y', 'dx', 'dy', 'ddx', 'ddy', 'vx', 'vy', 'w', 't']
ylabels = ['rx', 'ry']
inp = {xlabels[i]: data['X'][:, i, :] for i in range(10)}
out = {ylabels[i]: data['Y'][:, i, :] for i in range(2)}
return (inp, out)
def unpack(transform):
"""Decorator for if a method is supposed to act on the values of a dict."""
def up_transform(data, *args, **kwargs):
if type(data) == dict:
return {k: transform(data[k], *args, **kwargs) for k in data.keys()}
else:
return transform(data, *args, **kwargs)
return up_transform
@unpack
def subsample(x, idx):
return x[idx]
@unpack
def integrate(x, w):
return torch.cumsum(x * w, axis=len(x.shape)-1)
def subdict(dic, keys):
return {k: dic[k] for k in keys if k in dic.keys()}
def concat_dict_entries(data):
return torch.cat(tuple((d[:, None, :] for d in data.values())), dim=1)
def arclength(dx, dy, w):
return integrate((dx**2 + dy**2)**0.5, w)
def normalize(dx, dy):
"""Normalize 2-dim vector"""
mag = (dx**2 + dy**2)**0.5
return dx/mag, dy/mag
def curvature(dx, dy, ddx, ddy):
"""Find curvature of line segment given points"""
mag = (dx**2 + dy**2)**0.5
return (dx * ddy - dy * ddx) / (mag ** 3)
def invariant_quantities(inp):
labels = ('tx', 'ty', 'c')
tx, ty = normalize(inp['dx'], inp['dy'])
c = curvature(inp['dx'], inp['dy'], inp['ddx'], inp['ddy'])
data = (tx, ty, c)
return {labels[i]: data[i] for i in range(len(data))}
Next, we need a way to create the integral operator from a data batch.
def op_factory(inp):
Z = inp['x'] + 1j * inp['y']
dZ = inp['dx'] + 1j * inp['dy']
ddZ = inp['ddx'] + 1j * inp['ddy']
W = inp['w']
a = torch.ones(Z.shape[0],) * 0.5 * 1j
return StokesAdjointBoundaryOp(Z, dZ, ddZ, W, a)
Load Data
@unpack
def to_dtype(tensor, dtype):
return tensor.to(dtype)
# Load and transform
data = torch.load(f"/home/emastr/phd/data/problem_data_riesz_TEST.torch")
inp, out = unpack_data(data)
dtype = torch.double
inp, out = to_dtype(inp, dtype), to_dtype(out, dtype)
# Add invariant quantities to data.
inp.update(invariant_quantities(inp))
# Normalise curvature using monotone function sigmoid(x/2) - 1/2.
inp['c'] = 1/(1 + torch.exp(-0.5 * inp['c'])) - 0.5
Split into training and test data
# Standard features (coordinates, derivatives of parameterisation)
features = {'x', 'y', 'dx','dy','ddx','ddy','vx','vy'}
# Invariant features (coordinates, tangent, curvature)
features = {'x', 'y', 'tx', 'ty', 'c', 'vx', 'vy'}
# Reduced features (trust fourier transform to handle the rest)
features = {'x', 'y', 'vx', 'vy'}
## TRAINING DATA
M_train = 200#0
M_batch = 5 # Batch
idx_train = list(range(M_train))
X_train = concat_dict_entries(subdict(subsample(inp, idx_train), features))
V_train = concat_dict_entries(subdict(subsample(inp, idx_train), {'vx', 'vy'}))
Y_train = concat_dict_entries(subsample(out, idx_train))
#X_train = subdict(X_train, {'vx', 'vy'})
## TEST DATA
M_test = 100#0
idx_test = list(range(M_train, M_test + M_train))
X_test = concat_dict_entries(subdict(subsample(inp, idx_test), features))
V_test = concat_dict_entries(subdict(subsample(inp, idx_test), {'vx', 'vy'}))
Y_test = concat_dict_entries(subsample(out, idx_test))
#X_test = subdict(X_test, {'vx', 'vy'})
in_channels = len(features)
out_channels = 2
Create network
settings = {"modes": 10,
"input_features": features}
net = FNO1d(modes=settings["modes"], in_channels=in_channels, out_channels=out_channels)
Do training
# Predefine list of losses
trainloss = []
testloss = []
# Loss function
loss_fcn = nn.MSELoss()
benchloss = loss_fcn(V_test, Y_test).item()
optim = torch.optim.Adam(net.parameters())
# DO TRAINING LOOP
##################################################
N = 30001 #30001
for i in range(N):
idx_batch = torch.randperm(M_train)[:M_batch]
Y_batch = Y_train[idx_batch]
X_batch = X_train[idx_batch]
# Train on truncated net that expands as iterations progress
loss = loss_fcn(net(X_batch), Y_batch)
loss.backward()
optim.step()
trainloss.append(loss.item())
testloss.append(loss_fcn(net(X_test), Y_test).item())
optim.zero_grad()
print(f"Step {i}. Train loss = {trainloss[-1]}, test loss = {testloss[-1]}, benchmark={benchloss}", end="\r")
if i % 1000 == 0:
torch.save({"state dict" : net.state_dict(),
"settings" : settings,
"trainloss" : trainloss,
"testloss" : testloss},
f"/home/emastr/phd/data/fno_adjoint_state_dict_2022_12_02_default5_{i}.Torch") # old namme unet_state_dict #Kernel size 5, stride 2
Step 30000. Train loss = 0.00014250755874667165, test loss = 0.0002593944797511047, benchmark=0.0248016101648704522
save = torch.load(f"/home/emastr/phd/data/fno_adjoint_state_dict_2022_12_02_default5_{30000}.Torch")
trainloss = save["trainloss"]
testloss = save["testloss"]
net.load_state_dict(save["state dict"])
<All keys matched successfully>
Y_net = net(X_test)
Y_net = Y_net.detach()
for i in [90]:
plt.figure(1)
plt.plot(V_test[i, 0, :], label='inpx')
plt.plot(Y_net[i, 0, :], label='netx')
plt.plot(Y_test[i, 0, :], '--', label='outx')
plt.legend()
plt.figure(2)
plt.plot(V_test[i, 1, :])
plt.plot(Y_net[i, 1, :])
plt.plot(Y_test[i, 1, :])
plt.figure(3)
plt.semilogy(np.linspace(0,1,len(trainloss)), trainloss)
plt.semilogy(np.linspace(0,1,len(testloss)), testloss)
plt.figure(4)
plt.plot(inp['x'][0, :], inp['y'][0, :])
plt.quiver(inp['x'][0,:], inp['y'][0,:], inp['dy'][0,:], -inp['dx'][0,:])
plt.quiver(inp['x'][0,:], inp['y'][0,:], inp['ddx'][0,:], inp['ddy'][0,:], color='red')
plt.axis("equal")
(-0.8800000131130219,
0.8800000131130219,
-0.6743489861488342,
1.0797309041023255)