def ODE_penalty_solver(self,u,N,m):
"""
Solving the state equation with partitioning
Arguments:
* u: the control
* N: Number of discritization points
* m: Number of intervals we partition time in
"""
T = self.T
y0 = self.y0
dt = float(T)/N
y = partition_func(N+1,m)
y[0][0]=y0
for i in range(1,m):
y[i][0] = u[N+i]
start=0
for i in range(m):
for j in range(len(y[i])-1):
y[i][j+1] = self.ODE_update(y[i],u,j,start+j,dt)
start = start + len(y[i]) - 1
Y = np.zeros(N+1)
start = 0
for i in range(m):
Y[start:start+len(y[i])-1] = y[i][:-1]
start = start + len(y[i]) - 1
Y[-1] = y[-1][-1]
return y,Y
def ODE_penalty_solver(self,u,N,m):
"""
Solving the state equation with partitioning
Arguments:
* u: the control
* N: Number of discritization points
* m: Number of intervals we partition time in
"""
T = self.T
y0 = self.y0
dt = float(T)/N
y = partition_func(N+1,m)
y[0][0]=y0
for i in range(1,m):
y[i][0] = u[-m+i]
Nc = len(u)-m
start=0
u_send = u[:Nc+1]
for i in range(m):
for j in range(len(y[i])-1):
y[i][j+1] = self.ODE_update(y[i],u_send,j,start+j,dt)
start = start + len(y[i]) - 1
Y = np.zeros(N+1)
"""
start = 0
for i in range(m):
Y[start:start+len(y[i])-1] = y[i][:-1]
start = start + len(y[i]) - 1
Y[-1] = y[-1][-1]
"""
Y[0] = y[0][0]
start = 1
for i in range(m):
Y[start:start+len(y[i])-1] = y[i][1:]
start = start + len(y[i]) - 1
#"""
diff_vals = np.zeros(m-1)
for i in range(m-1):
diff_vals = (y[i+1][0]-y[i][-1])
self.jump_diff = np.max(abs(diff_vals))
return y,Y
def adjoint_penalty_solver(self,u,N,m,my,init=initial_penalty):
"""
Solving the adjoint equation using finite difference, and partitioning
the time interval.
Arguments:
* u: the control
* N: Number of discritization points
* m: Number of intervals we partition time in
"""
T = self.T
y0 = self.y0
dt = float(T)/N
yT = self.yT
l = partition_func(N+1,m)
y,Y = self.ODE_penalty_solver(u,N,m)
l[-1][-1] = self.initial_adjoint(y[-1][-1])
for i in range(m-1):
l[i][-1]=init(self,y,u,my,N,i,m) #my*(y[i][-1]-u[N+1+i])
for i in range(m):
self.t = self.T_z[i]
for j in range(len(l[i])-1):
l[i][-(j+2)] = self.adjoint_update(l[i],y[i],j,dt)
self.t=np.linspace(0,T,N+1)
L=self.serial_gather(l,N,m)#np.zeros(N+1)
"""
start=0
for i in range(m):
L[start:start+len(l[i])-1] = l[i][:-1]
start = start + len(l[i])-1
L[-1]=l[-1][-1]
""
L[0] = l[0][0]
start = 1
for i in range(m):
L[start:start+len(l[i])-1] = l[i][1:]
start += len(l[i])-1
#"""
return l,L
def adjoint_penalty_solver(self,u,N,m,my,init=initial_penalty):
"""
Solving the adjoint equation using finite difference, and partitioning
the time interval.
Arguments:
* u: the control
* N: Number of discritization points
* m: Number of intervals we partition time in
"""
T = self.T
y0 = self.y0
dt = float(T)/N
yT = self.yT
l = partition_func(N+1,m)
y,Y = self.ODE_penalty_solver(u,N,m)
l[-1][-1] = self.initial_adjoint(y[-1][-1])
for i in range(m-1):
l[i][-1]=init(self,y,u,my,N,i) #my*(y[i][-1]-u[N+1+i])
for i in range(m):
for j in range(len(l[i])-1):
l[i][-(j+2)] = self.adjoint_update(l[i],y[i],j,dt)
L=np.zeros(N+1)
start=0
for i in range(m):
L[start:start+len(l[i])-1] = l[i][:-1]
start = start + len(l[i])-1
L[-1]=l[-1][-1]
import matplotlib.pyplot as plt
return l,L
