diff --git a/__pycache__/RBF.cpython-39.pyc b/__pycache__/RBF.cpython-39.pyc new file mode 100644 index 0000000..b348884 Binary files /dev/null and b/__pycache__/RBF.cpython-39.pyc differ diff --git a/__pycache__/ac.cpython-39.pyc b/__pycache__/ac.cpython-39.pyc new file mode 100644 index 0000000..f251f92 Binary files /dev/null and b/__pycache__/ac.cpython-39.pyc differ diff --git a/__pycache__/neuralnetwork.cpython-39.pyc b/__pycache__/neuralnetwork.cpython-39.pyc new file mode 100644 index 0000000..8bebeb3 Binary files /dev/null and b/__pycache__/neuralnetwork.cpython-39.pyc differ diff --git a/__pycache__/singlearea.cpython-39.pyc b/__pycache__/singlearea.cpython-39.pyc new file mode 100644 index 0000000..433079f Binary files /dev/null and b/__pycache__/singlearea.cpython-39.pyc differ diff --git a/__pycache__/two_area.cpython-39.pyc b/__pycache__/two_area.cpython-39.pyc new file mode 100644 index 0000000..2e9fa18 Binary files /dev/null and b/__pycache__/two_area.cpython-39.pyc differ diff --git a/ac.py b/ac.py new file mode 100644 index 0000000..c4c4c6d --- /dev/null +++ b/ac.py @@ -0,0 +1,117 @@ +import numpy as np + +class Actor: + + def __init__(self , aw , av , au , gamma ,h = 3 ): + + # Initialize all parameters + + self.X = np.zeros((3,1)) + self.h = h + self.wh = np.zeros( (h,3) ) + self.K =np.zeros( (3,1) ) + self.w = np.zeros( (3, h) ) + self.output = np.zeros( (h,1) ) + + # Learning Rates + self.aw = aw + self.au = au + self.gamma = gamma + + def HiddenLayer(self): + + # Description : Takes in the state vector at a given time step and computes the output vector for the next layer + + output = 1/(1 + np.exp(self.wh.dot(self.X)) ) + + self.output = output + + def OutputLayer(self): + + # Description : Takes in output from Hiddenlayer and computes Ki,Kp and Kd values + + self.K = self.w.dot(self.output) + + # print(self.K) + + + def Update1(self,y_ref,yt_0,yt_1,yt_2,yt_3,V,Vprev): + + # Update Params for next episode + del_TD = 0.5 * ( y_ref - yt_0 )**2 + self.gamma*V - Vprev + + # Update w matrix + self.w[0] = self.w[0] - self.aw * del_TD*(yt_1 - yt_2)*self.output.T + self.w[1] = self.w[1] + self.aw * del_TD*self.X[0,0]*self.output.T + self.w[2] = self.w[2] + self.aw * del_TD*(yt_1 - 2*yt_2 + yt_3)*self.output.T + + + + def Update2(self,y_ref,yt_0,yt_1,yt_2,yt_3,V,Vprev,v_prev): + + # Update Params for next episode + + del_TD = 0.5 * ( y_ref - yt_0 )**2 + self.gamma*V - Vprev + + for i in range(self.h): + self.wh[i,0] = self.wh[i,0] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[0] + self.wh[i,1] = self.wh[i,1] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[1] + self.wh[i,2] = self.wh[i,2] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[2] + + +class Critic: + + def __init__(self , aw , av , au , gamma ,h = 3 ): + + # Initialize all parameters + + self.X = np.zeros((3,1)) + self.h = h + self.wh = np.zeros( (h,3) ) + self.Vprev = 0 + self.V = 0 + self.v = np.zeros( (1, h) ) + self.output = np.zeros( (h,1) ) + + # Learning Rates + self.av = av + self.au = au + self.gamma = gamma + + + + def HiddenLayer(self): + + # Description : Takes in the state vector at a given time step and computes the output vector for the next layer + + output = 1/(1 + np.exp(self.wh.dot(self.X)) ) + self.output = output + + def OutputLayer(self): + + # Description : Takes in output from Hiddenlayer and computes Ki,Kp and Kd values + + self.Vprev = self.V + self.V = self.v.dot(self.output) + + def Update(self,y_ref,yt_0,yt_1,yt_2,yt_3): + + # Update Params for next episode + + del_TD = 0.5 * ( y_ref - yt_0 )**2 + self.gamma*self.V - self.Vprev + + # Updating the v value + v_prev = self.v + self.v = self.v + self.av * del_TD * self.output.T + + + for i in range(self.h): + self.wh[i,0] = self.wh[i,0] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[0] + self.wh[i,1] = self.wh[i,1] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[1] + self.wh[i,2] = self.wh[i,2] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[2] + + return v_prev + + + + diff --git a/actor.py b/actor.py new file mode 100644 index 0000000..acbf62b --- /dev/null +++ b/actor.py @@ -0,0 +1,92 @@ +import numpy as np + +class Actor: + + def __init__(self , aw , av , au , gamma ,h = 3 ): + + # Initialize all parameters + + self.X = np.zeros((3,1)) + self.h = h + self.wh = np.zeros( (h,3) ) + + + # actor + self.K =np.zeros( (3,1) ) + + + # actor + self.w = np.zeros( (3, h) ) + + + + + self.output = np.zeros( (h,1) ) + + # Learning Rates + + # actor + self.aw = aw + + + # both + self.au = au + + + + + + + + def HiddenLayer(self): + + # Description : Takes in the state vector at a given time step and computes the output vector for the next layer + + output = 1/(1 + np.exp(self.wh.dot(self.X)) ) + + self.output = output + + def OutputLayer(self): + + # Description : Takes in output from Hiddenlayer and computes Ki,Kp and Kd values + + # actor + + self.K = self.w.dot(self.output) + + # print(self.K) + + + def Update1(self,y_ref,yt_0,yt_1,yt_2,yt_3,V,Vprev): + + # Update Params for next episode + + + # both + del_TD = 0.5 * ( y_ref - yt_0 )**2 + self.gamma*V - Vprev + + + # actor + + # Update w matrix + self.w[0] = self.w[0] - self.aw * del_TD*(yt_1 - yt_2)*self.output.T + self.w[1] = self.w[1] + self.aw * del_TD*self.X[0,0]*self.output.T + self.w[2] = self.w[2] + self.aw * del_TD*(yt_1 - 2*yt_2 + yt_3)*self.output.T + + + + def Update2(self,y_ref,yt_0,yt_1,yt_2,yt_3,V,Vprev,v_prev): + + # Update Params for next episode + + del_TD = 0.5 * ( y_ref - yt_0 )**2 + self.gamma*V - Vprev + + for i in range(self.h): + self.wh[i,0] = self.wh[i,0] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[0] + self.wh[i,1] = self.wh[i,1] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[1] + self.wh[i,2] = self.wh[i,2] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[2] + + + + + diff --git a/critic.py b/critic.py new file mode 100644 index 0000000..a9c34fc --- /dev/null +++ b/critic.py @@ -0,0 +1,82 @@ +import numpy as np + +class Critic: + + def __init__(self , aw , av , au , gamma ,h = 3 ): + + # Initialize all parameters + + self.X = np.zeros((3,1)) + self.h = h + self.wh = np.zeros( (h,3) ) + + + # critic + self.Vprev = 0 + self.V = 0 + + + # critic + self.v = np.zeros( (1, h) ) + + + self.output = np.zeros( (h,1) ) + + # Learning Rates + + + # critic + + self.av = av + + # both + self.au = au + + # critic + self.gamma = gamma + + + + def HiddenLayer(self): + + # Description : Takes in the state vector at a given time step and computes the output vector for the next layer + + output = 1/(1 + np.exp(self.wh.dot(self.X)) ) + + + + self.output = output + + def OutputLayer(self): + + # Description : Takes in output from Hiddenlayer and computes Ki,Kp and Kd values + + + # critic + self.Vprev = self.V + self.V = self.v.dot(self.output) + + def Update(self,y_ref,yt_0,yt_1,yt_2,yt_3): + + # Update Params for next episode + + del_TD = 0.5 * ( y_ref - yt_0 )**2 + self.gamma*self.V - self.Vprev + + + # critic + + # Updating the v value + v_prev = self.v + self.v = self.v + self.av * del_TD * self.output.T + + + for i in range(self.h): + self.wh[i,0] = self.wh[i,0] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[0] + self.wh[i,1] = self.wh[i,1] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[1] + self.wh[i,2] = self.wh[i,2] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[2] + + return v_prev + + + + diff --git a/neuralnetwork.py b/neuralnetwork.py new file mode 100644 index 0000000..d9e920d --- /dev/null +++ b/neuralnetwork.py @@ -0,0 +1,80 @@ +import numpy as np + +class NeuralNetwork: + + def __init__(self , aw , av , au , gamma ,h = 3 ): + + # Initialize all parameters + + self.X = np.zeros((3,1)) + self.h = h + self.wh = np.zeros( (h,3) ) + + self.K =np.zeros( (3,1) ) + self.Vprev = 0 + self.V = 0 + + self.w = np.zeros( (3, h) ) + self.v = np.zeros( (1, h) ) + self.output = np.zeros( (h,1) ) + + # Learning Rates + + self.aw = aw + self.av = av + self.au = au + self.gamma = gamma + + + + def HiddenLayer(self): + + # Description : Takes in the state vector at a given time step and computes the output vector for the next layer + + output = 1/(1 + np.exp(self.wh.dot(self.X)) ) + + + + self.output = output + + def OutputLayer(self): + + # Description : Takes in output from Hiddenlayer and computes Ki,Kp and Kd values + + self.K = self.w.dot(self.output) + + # print(self.K) + self.Vprev = self.V + self.V = self.v.dot(self.output) + + def Update(self,y_ref,yt_0,yt_1,yt_2,yt_3): + + # Update Params for next episode + + del_TD = 0.5 * ( y_ref - yt_0 )**2 + self.gamma*self.V - self.Vprev + + # Update w matrix + self.w[0] = self.w[0] - self.aw * del_TD*(yt_1 - yt_2)*self.output.T + self.w[1] = self.w[1] + self.aw * del_TD*self.X[0,0]*self.output.T + self.w[2] = self.w[2] + self.aw * del_TD*(yt_1 - 2*yt_2 + yt_3)*self.output.T + + # Updating the v value + v_prev = self.v + self.v = self.v + self.av * del_TD * self.output.T + + # Updating the centers and widths of hidden layers + + # print("Printing Shapes of Stuff") + + # print("Shape of self.au :", v_prev) + + for i in range(self.h): + self.wh[i,0] = self.wh[i,0] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[0] + self.wh[i,1] = self.wh[i,1] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[1] + self.wh[i,2] = self.wh[i,2] + self.au*del_TD*v_prev[0][i]*self.output[i]*( 1 - self.output[i] )*self.X[2] + + # print(self.K) + + + + diff --git a/singlearea_with_adaptive_pid_actor_critic.py b/singlearea_with_adaptive_pid_actor_critic.py new file mode 100644 index 0000000..5a9ff57 --- /dev/null +++ b/singlearea_with_adaptive_pid_actor_critic.py @@ -0,0 +1,145 @@ +from audioop import cross +import matplotlib.pyplot as plt +import numpy as np +from numpy.lib.function_base import append + +from singlearea import * + +import ac + +def y(yd): + + actor = ac.Actor( aw = 0.0003, av = 0.1, au = 0.0025 , gamma = 0.9) + + critic = ac.Critic( aw = 0.0003, av = 0.1, au = 0.0025 , gamma = 0.9) + + Tg = 0.08 + Tt = 0.3 + M = 0.2 + D = 0.01 + R = 2 + T = dt = 1/400 + + yt_1 = 0 + yt_2 = 0 + yt_3 = 0 + + System = SingleArea( Tg , Tt , M , D , R , T , yt_1 , yt_2 , yt_3 ) + + + + initial_states = [ yt_1, yt_2 , yt_3] + + plot_data = {"ut":[] , "pl" : [] , "delF":[] , 'KI' : [], 'KP' : [] , 'KD' : [] , "time" : []} + + + Ki = 0 + Kd = 0 + Kp = 0 + + ut_1 = 0 + + t = 10 + + y=[] + x=[] + + + for i in range(0, int(t/dt) ): + + # print(System.yt_1) + e_t = 0 - System.yt_1 + del_y = System.yt_1 - System.yt_2 + del2_y = System.yt_1 - 2*System.yt_2 + System.yt_3 + + actor.X[:,0]= critic.X[:,0] = [ e_t , -del_y , -del2_y] + + actor.HiddenLayer() + critic.HiddenLayer() + + actor.OutputLayer() + critic.OutputLayer() + + + # ut_1 = ut_1 + 0.00043*e_t - 0.01*del_y - 0*del2_y + ut_1 = ut_1 + actor.K[1]*e_t - actor.K[0]*del_y - actor.K[2]*del2_y + + plot_data["ut"].append(ut_1) + + + + PL = 0.2 if( i*dt >= 0.2 ) else 0 + plot_data["pl"].append(PL) + + Ut = [ [ut_1] , [ PL] ] + + System.Output(Ut) + + print(actor.K) + + V,Vprev = critic.V, critic.Vprev + + actor.Update1(0 ,System.Y[0,0] ,System.yt_1 , System.yt_2, System.yt_3 , V,Vprev) + + vprev = critic.Update(0 ,System.Y[0,0] ,System.yt_1 , System.yt_2, System.yt_3) + + actor.Update2(0 ,System.Y[0,0] ,System.yt_1 , System.yt_2, System.yt_3 , V,Vprev , vprev) + + + + plot_data["delF"].append(System.Y[0,0]) + plot_data["time"].append(i*dt) + plot_data["KI"].append(actor.K[1]) + plot_data["KP"].append(actor.K[0]) + plot_data["KD"].append(actor.K[2]) + + return plot_data,initial_states + + +if __name__=="__main__": + + + yd = [0 for i in range(10*400) ] + + + ## Generate Reference array here + + plot_data,i = y(yd) + + + plt.subplot(2,2,1) + plt.plot(plot_data["time"],plot_data["pl"], label="Reference Signal") + plt.title( "Load vs Time") + plt.ylabel(" Output from System ") + plt.xlabel("Time (s)") + + plt.subplot(2,2,2) + plt.plot(plot_data["time"],plot_data["KI"], label="KI") + plt.plot(plot_data["time"],plot_data["KP"], label="KP") + plt.plot(plot_data["time"],plot_data["KD"], label="KD") + plt.title( "KI, KP, KD vs Time") + plt.ylabel("KI, KP, KD") + plt.xlabel("Time (s)") + plt.legend() + + plt.subplot(2,2,3) + plt.plot(plot_data["time"],plot_data["ut"], label="Reference Signal") + plt.title( "Control Signal vs Time") + plt.ylabel("Control Signal") + plt.xlabel("Time (s)") + + plt.subplot(2,2,4) + plt.plot(plot_data["time"],yd, label="Reference Signal") + plt.plot(plot_data["time"],plot_data["delF"],label ="Output") + + + plt.title( " Initial States y(t-1) , y(t-2) and y(t-3) are " + str(i[0]) + ", " + str(i[1]) +" and "+ str(i[2]) ) + + plt.legend() + + plt.ylabel(" Output from System ") + plt.xlabel("Time (s)") + + + plt.show() + diff --git a/singlearea_with_adaptive_pid_nn.py b/singlearea_with_adaptive_pid_nn.py new file mode 100644 index 0000000..00ecedb --- /dev/null +++ b/singlearea_with_adaptive_pid_nn.py @@ -0,0 +1,131 @@ +import matplotlib.pyplot as plt +import numpy as np +from numpy.lib.function_base import append + +from singlearea import * + +import neuralnetwork + + +def y(yd): + + nn = neuralnetwork.NeuralNetwork( aw = 0.0003, av = 0.1, au = 0.0025 , gamma = 0.9) + + Tg = 0.08 + Tt = 0.3 + M = 0.2 + D = 0.01 + R = 2 + T = dt = 1/400 + + yt_1 = 0 + yt_2 = 0 + yt_3 = 0 + + System = SingleArea( Tg , Tt , M , D , R , T , yt_1 , yt_2 , yt_3 ) + + + + initial_states = [ yt_1, yt_2 , yt_3] + + plot_data = {"ut":[] , "pl" : [] , "delF":[] , 'KI' : [], 'KP' : [] , 'KD' : [] , "time" : []} + + + Ki = 0 + Kd = 0 + Kp = 0 + + ut_1 = 0 + + t = 10 + + y=[] + x=[] + + + for i in range(0, int(t/dt) ): + + # print(System.yt_1) + e_t = 0 - System.yt_1 + del_y = System.yt_1 - System.yt_2 + del2_y = System.yt_1 - 2*System.yt_2 + System.yt_3 + + nn.X[:,0] = [ e_t , -del_y , -del2_y] + nn.HiddenLayer() + nn.OutputLayer() + + + # ut_1 = ut_1 + 0.00043*e_t - 0.01*del_y - 0*del2_y + ut_1 = ut_1 + nn.K[1]*e_t - nn.K[0]*del_y - nn.K[2]*del2_y + + plot_data["ut"].append(ut_1) + + + + PL = 0.2 if( i*dt >= 0.2 ) else 0 + plot_data["pl"].append(PL) + + Ut = [ [ut_1] , [ PL] ] + + System.Output(Ut) + + print(nn.K) + + nn.Update(0 ,System.Y[0,0] ,System.yt_1 , System.yt_2, System.yt_3 ) + + plot_data["delF"].append(System.Y[0,0]) + plot_data["time"].append(i*dt) + plot_data["KI"].append(nn.K[1]) + plot_data["KP"].append(nn.K[0]) + plot_data["KD"].append(nn.K[2]) + + return plot_data,initial_states + + +if __name__=="__main__": + + + yd = [0 for i in range(10*400) ] + + + ## Generate Reference array here + + plot_data,i = y(yd) + + + plt.subplot(2,2,1) + plt.plot(plot_data["time"],plot_data["pl"], label="Reference Signal") + plt.title( "Load vs Time") + plt.ylabel(" Output from System ") + plt.xlabel("Time (s)") + + plt.subplot(2,2,2) + plt.plot(plot_data["time"],plot_data["KI"], label="KI") + plt.plot(plot_data["time"],plot_data["KP"], label="KP") + plt.plot(plot_data["time"],plot_data["KD"], label="KD") + plt.title( "KI, KP, KD vs Time") + plt.ylabel("KI, KP, KD") + plt.xlabel("Time (s)") + plt.legend() + + plt.subplot(2,2,3) + plt.plot(plot_data["time"],plot_data["ut"], label="Reference Signal") + plt.title( "Control Signal vs Time") + plt.ylabel("Control Signal") + plt.xlabel("Time (s)") + + plt.subplot(2,2,4) + plt.plot(plot_data["time"],yd, label="Reference Signal") + plt.plot(plot_data["time"],plot_data["delF"],label ="Output") + + + plt.title( " Initial States y(t-1) , y(t-2) and y(t-3) are " + str(i[0]) + ", " + str(i[1]) +" and "+ str(i[2]) ) + + plt.legend() + + plt.ylabel(" Output from System ") + plt.xlabel("Time (s)") + + + plt.show() + diff --git a/two_area.py b/two_area.py new file mode 100644 index 0000000..c1f58ab --- /dev/null +++ b/two_area.py @@ -0,0 +1,101 @@ +import numpy as np +from numpy.core.numeric import NaN +from scipy.linalg import expm +import math + +class TwoAreaPS: + + def __init__(self, Tg, Tp, Tt, Kp, T12, a12, R, T, beta1, beta2, yt_1,yt_2,yt_3): + + self.yt_1 = yt_1 + self.yt_2 = yt_2 + self.yt_3 = yt_3 + + self.Xprev = np.zeros( (7,1) ) + self.Y = np.zeros( (2,1) ) + + self.Tg = Tg + self.Tp = Tp + self.Tt = Tt + self.Kp = Kp + self.T12 = T12 + self.a12 = a12 + self.R = R + + self.beta1 = beta1 + self.beta2 = beta2 + + self.T = T + + self.CalcDiscreteCoef() + + def CalcDiscreteCoef(self): + + # Calculating Continous coef + + Tg = self.Tg + Tp = self.Tp + Tt = self.Tt + Kp = self.Kp + T12 = self.T12 + a12 = self.a12 + R = self.R + + self.A = np.array( [ [-1/Tp , Kp/Tp , 0 , -Kp/Tp , 0 , 0 , 0 ] , + [0 , -1/Tt , 1/Tt , 0 , 0 ,0 , 0 ] , + [-1/(R*Tg) , 0 , -1/Tg , 0 , 0, 0, 0 ] , + [ 2*np.pi*T12 , 0 , 0 , 0 , -2*np.pi*T12 , 0 , 0 ] , + [0 ,0 ,0 , -Kp*a12/Tp , -1/Tp , Kp/Tp , 0 ] , + [ 0,0,0,0,0, -1/Tt, 1/Tt] , + [0,0,0,0,-1/(R*Tg) , 1/Tg , -1/Tg ] ] ) + + self.B = np.array( [ [0 ,0, -Kp/Tp , 0 ], + [0 , 0, 0 ,0 ], + [1/Tg, 0 , 0, 0], + [0,0,0,0], + [0,0,0,0], + [0,0,0,0], + [0,1/Tg,0,-Kp/Tp] ]) + + self.C = np.array( [ [ self.beta1 , 0 , 0 ,1 , 0, 0 , 0 ] ]) + # [ 0 , 0, 0, 1, self.beta2, 0, 0 ] ] ) + + + # Calculating Discrete Coefs + + self.Ad = expm(self.A*self.T) + + # Add check later + + self.Bd = np.dot( np.dot(np.linalg.inv(self.A),(self.Ad - np.eye(7) )), self.B ) + + def Output(self,Ut): + + self.yt_1 , self.yt_2 , self.yt_3 = self.Y[0,0], self.yt_1, self.yt_2 + + self.X = np.dot( self.Ad, self.Xprev ) + np.dot( self.Bd, Ut ) + + self.Y = np.dot( self.C, self.Xprev) + + # print("Chooth :" , self.Y) + + self.Xprev = self.X + + if (math.isnan(self.Y[0,0])): + + return True + + return False + + + + + + + + + + + + + diff --git a/twoarea_with_adaptive_pid.py b/twoarea_with_adaptive_pid.py new file mode 100644 index 0000000..ee8e6e8 --- /dev/null +++ b/twoarea_with_adaptive_pid.py @@ -0,0 +1,151 @@ +import matplotlib.pyplot as plt +import numpy as np +from numpy.lib.function_base import append + +from two_area import * + +import RBF + + +def y(yd): + + rbf = RBF.RBF( aw = 0.0003, av = 0.021, au = 0.025 , asig = 0.01, gamma = 0.9) + + + Tg = 0.08 + Tp = 20 + Tt = 0.3 + Kp = 120 + T12 = 0.545/(2*np.pi) + a12 = -1 + R = 2.4 + T = dt = 1/400 + beta1 = 0.425 + beta2 = 0.425 + + yt_1 = 0 + yt_2 = 0 + yt_3 = 0 + + System = TwoAreaPS( Tg, Tp, Tt, Kp, T12, a12, R, T, beta1, beta2, yt_1,yt_2,yt_3 ) + + + + initial_states = [ yt_1, yt_2 , yt_3] + + plot_data = {"ut":[] , "pl" : [] , "delF":[] , 'KI' : [], 'KP' : [] , 'KD' : [] , "time" : []} + + + Ki = 0 + Kd = 0 + Kp = 0 + + ut_1 = 0 + + t = 100 + + y=[] + x=[] + + + for i in range(0, int(t/dt) ): + + # print(System.yt_1) + e_t = 0 - System.yt_1 + del_y = System.yt_1 - System.yt_2 + del2_y = System.yt_1 - 2*System.yt_2 + System.yt_3 + + rbf.X[:,0] = [ e_t , -del_y , -del2_y] + rbf.HiddenLayer() + rbf.OutputLayer() + + + # ut_1 = ut_1 + 0.00043*e_t - 0.01*del_y - 0*del2_y + ut_1 = ut_1 + rbf.K[1]*e_t - rbf.K[0]*del_y - rbf.K[2]*del2_y + + plot_data["ut"].append(ut_1) + + + + PL = 0.2 if( i*dt >= 0.2 ) else 0 + plot_data["pl"].append(PL) + + Ut = [ [ut_1] , [0] , [ PL] , [0] ] + + System.Output(Ut) + + print(rbf.K) + + rbf.Update(0 ,System.Y[0,0] ,System.yt_1 , System.yt_2, System.yt_3 ) + + plot_data["delF"].append(System.Y[0,0]) + plot_data["time"].append(i*dt) + plot_data["KI"].append(rbf.K[1]) + plot_data["KP"].append(rbf.K[0]) + plot_data["KD"].append(rbf.K[2]) + + return plot_data,initial_states + + +if __name__=="__main__": + + + yd = [0 for i in range(100*400) ] + + + ## Generate Reference array here + + plot_data,i = y(yd) + + + plt.subplot(2,3,1) + plt.plot(plot_data["time"],plot_data["pl"], label="Reference Signal") + plt.title( "Load vs Time") + plt.ylabel(" Output from System ") + plt.xlabel("Time (s)") + + + + plt.subplot(2,3,2) + plt.plot(plot_data["time"],plot_data["ut"], label="Reference Signal") + plt.title( "Control Signal vs Time") + plt.ylabel("Control Signal") + plt.xlabel("Time (s)") + + plt.subplot(2,3,3) + plt.plot(plot_data["time"],yd, label="Reference Signal") + plt.plot(plot_data["time"],plot_data["delF"],label ="Output") + + + plt.title( " Initial States y(t-1) , y(t-2) and y(t-3) are " + str(i[0]) + ", " + str(i[1]) +" and "+ str(i[2]) ) + + plt.legend() + + plt.subplot(2,3,4) + plt.plot(plot_data["time"],plot_data["KI"], label="KI") + plt.title( "KI vs Time") + plt.ylabel("KI") + plt.xlabel("Time (s)") + + + plt.subplot(2,3,5) + plt.plot(plot_data["time"],plot_data["KP"], label="KP") + plt.title( "KP vs Time") + plt.ylabel("KP ") + plt.xlabel("Time (s)") + + plt.subplot(2,3,6) + plt.plot(plot_data["time"],plot_data["KD"], label="KD") + plt.title( "KD vs Time") + plt.ylabel("KD") + plt.xlabel("Time (s)") + + + + + plt.ylabel(" Output from System ") + plt.xlabel("Time (s)") + + + plt.show() +