def sindy(n, p, a, thres):
if n == 2:
functions = [
lambda x1, y1, x2, y2: (x2 - x1) / (
(x2 - x1)**2 + (y2 - y1)**2)**(3 / 2), lambda x1, y1, x2, y2:
(y2 - y1) / ((x2 - x1)**2 + (y2 - y1)**2)**(3 / 2)
]
lib_custom = CustomLibrary(library_functions=functions)
optimizer = ps.STLSQ(threshold=thres)
t = np.arange(0, p.shape[0], 1)
model = ps.SINDy(feature_library=lib_custom,
optimizer=optimizer,
feature_names=['x0', 'y0', 'x1', 'y1', 'x2', 'y2'])
model.fit(p, t=t, x_dot=a)
model.print(lhs=["x0''", "y0''", "x1''", "y1''"])
coef = model.coefficients()
print(coef)
return coef
elif n == 3:
functions = [
lambda x0, y0, x1, y1, x2, y2: (x1 - x0) / ((x1 - x0)**2 +
(y1 - y0)**2)**(3 / 2),
lambda x0, y0, x1, y1, x2, y2: (y1 - y0) / ((x1 - x0)**2 +
(y1 - y0)**2)**(3 / 2),
lambda x0, y0, x1, y1, x2, y2: (x2 - x0) / ((x2 - x0)**2 +
(y2 - y0)**2)**(3 / 2),
lambda x0, y0, x1, y1, x2, y2: (y2 - y0) / ((x2 - x0)**2 +
(y2 - y0)**2)**(3 / 2),
lambda x0, y0, x1, y1, x2, y2: (x2 - x1) / ((x2 - x1)**2 +
(y2 - y1)**2)**(3 / 2),
lambda x0, y0, x1, y1, x2, y2: (y2 - y1) / ((x2 - x1)**2 +
(y2 - y1)**2)**(3 / 2)
]
lib_custom = CustomLibrary(library_functions=functions)
optimizer = ps.STLSQ(threshold=thres)
t = np.arange(0, p.shape[0], 1)
model = ps.SINDy(feature_library=lib_custom,
optimizer=optimizer,
feature_names=['x0', 'y0', 'x1', 'y1', 'x2', 'y2'])
model.fit(p, t=t, x_dot=a)
model.print(lhs=["x0''", "y0''", "x1''", "y1''", "x2''", "y2''"])
coef = model.coefficients()
print(coef)
return coef
else:
print('Number of bodies not supported')
def test_form_custom_library():
library_functions = [lambda x: x, lambda x: x ** 2, lambda x: 0 * x]
function_names = [
lambda s: str(s),
lambda s: "{}^2".format(s),
lambda s: "0",
]
# Test with user-supplied function names
CustomLibrary(library_functions=library_functions, function_names=function_names)
# Test without user-supplied function names
CustomLibrary(library_functions=library_functions, function_names=None)
def data_custom_library():
library_functions = [lambda x: x, lambda x: x ** 2, lambda x: 0 * x]
function_names = [lambda s: str(s), lambda s: str(s) + "^2", lambda s: "0"]
return CustomLibrary(
library_functions=library_functions, function_names=function_names
)
def data_custom_library():
library_functions = [
lambda x: x,
lambda x: x**2,
lambda x: 0 * x,
lambda x, y: x * y,
]
function_names = [
lambda s: str(s),
lambda s: str(s) + "^2",
lambda s: "0",
lambda s, t: str(s) + " " + str(t),
]
return CustomLibrary(library_functions=library_functions,
function_names=function_names)
def test_trapping_quadratic_library(params):
x = np.random.standard_normal((10, 3))
library_functions = [
lambda x: x,
lambda x, y: x * y,
lambda x: x**2,
]
library_function_names = [
lambda x: str(x),
lambda x, y: "{} * {}".format(x, y),
lambda x: "{}^2".format(x),
]
sindy_library = CustomLibrary(library_functions=library_functions,
function_names=library_function_names)
opt = TrappingSR3(**params)
model = SINDy(optimizer=opt, feature_library=sindy_library)
model.fit(x)
assert opt.PL.shape == (3, 3, 3, 9)
assert opt.PQ.shape == (3, 3, 3, 3, 9)
check_is_fitted(model)
def test_bad_parameters():
with pytest.raises(ValueError):
PolynomialLibrary(degree=-1)
with pytest.raises(ValueError):
PolynomialLibrary(degree=1.5)
with pytest.raises(ValueError):
PolynomialLibrary(include_interaction=False, interaction_only=True)
with pytest.raises(ValueError):
FourierLibrary(n_frequencies=-1)
with pytest.raises(ValueError):
FourierLibrary(n_frequencies=-1)
with pytest.raises(ValueError):
FourierLibrary(n_frequencies=2.2)
with pytest.raises(ValueError):
FourierLibrary(include_sin=False, include_cos=False)
with pytest.raises(ValueError):
library_functions = [lambda x: x, lambda x: x**2, lambda x: 0 * x]
function_names = [lambda s: str(s), lambda s: "{}^2".format(s)]
CustomLibrary(library_functions=library_functions,
function_names=function_names)
def test_trapping_cubic_library(params):
x = np.random.standard_normal((10, 3))
library_functions = [
lambda x: x,
lambda x, y: x * y,
lambda x: x**2,
lambda x, y, z: x * y * z,
lambda x, y: x**2 * y,
lambda x: x**3,
]
library_function_names = [
lambda x: str(x),
lambda x, y: "{} * {}".format(x, y),
lambda x: "{}^2".format(x),
lambda x, y, z: "{} * {} * {}".format(x, y, z),
lambda x, y: "{}^2 * {}".format(x, y),
lambda x: "{}^3".format(x),
]
sindy_library = CustomLibrary(library_functions=library_functions,
function_names=library_function_names)
with pytest.raises(ValueError):
opt = TrappingSR3(**params)
model = SINDy(optimizer=opt, feature_library=sindy_library)
model.fit(x)
def compressible_Framework(inner_prod, time, poly_order, threshold, r, tfac,
SR3Enhanced, make_3Dphaseplots):
"""
Performs the entire vector_POD + SINDy framework for a given polynomial
order and thresholding for the SINDy method.
Parameters
----------
inner_prod: 2D numpy array of floats
(M = number of time samples, M = number of time samples)
The scaled matrix of inner products X*X
time: numpy array of floats
(M = number of time samples)
Time in microseconds
poly_order: int
(1)
Highest polynomial order to use in the SINDy library
threshold: float
(1)
Threshold in the SINDy algorithm, below which coefficients
will be zeroed out.
r: int
(1)
Truncation number of the SVD
tfac: float
(1)
Fraction of the data to treat as training data
SR3Enhanced: SINDy optimizer object
(1)
The SR3 optimizer with linear equality constraints
make_3Dphaseplots: bool
(1)
Flag to make 3D phase plots or not
Returns
-------
t_test: numpy array of floats
(M_test = number of time samples in the test data region)
Time in microseconds in the test data region
x_true: 2D numpy array of floats
(M_test = number of time samples in the test data region,
r = truncation number of the SVD)
The true evolution of the temporal BOD modes
x_sim: 2D numpy array of floats
(M_test = number of time samples in the test data region,
r = truncation number of the SVD)
The model evolution of the temporal BOD modes
S2: 2D numpy array of floats
(M = number of time samples, M = number of time samples)
The singular value matrix
"""
plt.clf()
plt.close('all')
M_train = int(len(time) * tfac)
t_train = time[:M_train]
t_test = time[M_train:]
x, feature_names, S2, Vh, = vector_POD(inner_prod, time, r)
print('Now fitting SINDy model')
if poly_order == 1:
library_functions = [lambda x: x]
library_function_names = [lambda x: x]
if poly_order == 2:
library_functions = [lambda x: x, lambda x, y: x * y, lambda x: x**2]
library_function_names = [
lambda x: x, lambda x, y: x + y, lambda x: x + x
]
if poly_order == 3:
library_functions = [
lambda x: x, lambda x, y: x * y, lambda x: x**2,
lambda x, y, z: x * y * z, lambda x, y: x**2 * y,
lambda x, y: x * y**2, lambda x: x**3
]
library_function_names = [
lambda x: x, lambda x, y: x + y, lambda x: x + x,
lambda x, y, z: x + y + z, lambda x, y: x + x + y,
lambda x, y: x + y + y, lambda x: x + x + x
]
if poly_order == 4:
library_functions = [
lambda x: x, lambda x, y: x * y, lambda x: x**2,
lambda x, y, z: x * y * z, lambda x, y: x**2 * y,
lambda x, y: x * y**2, lambda x: x**3,
lambda x, y, z, w: x * y * z * w, lambda x, y, z: x * y * z**2,
lambda x, y: x**2 * y**2, lambda x, y: x**3 * y, lambda x: x**4
]
library_function_names = [
lambda x: x, lambda x, y: x + y, lambda x: x + x,
lambda x, y, z: x + y + z, lambda x, y: x + x + y,
lambda x, y: x + y + y, lambda x: x + x + x,
lambda x, y, z, w: x + y + z + w, lambda x, y, z: x + y + z + z,
lambda x, y: x + x + y + y, lambda x, y: x + x + x + y,
lambda x: x + x + x + x
]
sindy_library = CustomLibrary(library_functions=library_functions, \
function_names=library_function_names)
constraint_zeros = np.zeros(int(r * (r + 1) / 2))
if poly_order == 1:
constraint_matrix = np.zeros((int(r * (r + 1) / 2), r**2))
for i in range(r):
constraint_matrix[i, i * (r + 1)] = 1.0
q = r
for i in range(r):
counter = 1
for j in range(i + 1, r):
constraint_matrix[q, i * r + j] = 1.0
constraint_matrix[q, i * r + j + counter * (r - 1)] = 1.0
counter = counter + 1
q = q + 1
else:
if poly_order == 2:
#constraint_zeros = np.zeros(6+int(r*(r+1)/2))
#constraint_matrix = np.zeros((6+int(r*(r+1)/2),int(r*(r**2+3*r)/2)))
constraint_matrix = np.zeros(
(int(r * (r + 1) / 2), int(r * (r**2 + 3 * r) / 2)))
if poly_order == 3:
#constraint_matrix = np.zeros((int(r*(r+1)/2),int(r*(r**2+3*r)/2)+336))
constraint_matrix = np.zeros(
(int(r * (r + 1) / 2),
int(r * (r**2 + 3 * r) / 2) + 588)) # 30
if poly_order == 4:
constraint_matrix = np.zeros(
(int(r * (r + 1) / 2), int(r * (r**2 + 3 * r) / 2) + 60))
for i in range(r):
constraint_matrix[i, i * (r + 1)] = 1.0
q = r
for i in range(r):
counter = 1
for j in range(i + 1, r):
constraint_matrix[q, i * r + j] = 1.0
constraint_matrix[q, i * r + j + counter * (r - 1)] = 1.0
counter = counter + 1
q = q + 1
# linear_r4_mat or linear_r12_mat are initial guesses
# for the optimization
linear_r4_mat = np.zeros((r, r))
linear_r4_mat[0, 1] = 0.091
linear_r4_mat[1, 0] = -0.091
linear_r4_mat[2, 3] = 0.182
linear_r4_mat[3, 2] = -0.182
linear_r4_mat[5, 4] = -3 * 0.091
linear_r4_mat[4, 5] = 3 * 0.091
#linear_r4_mat[8,7] = -4*0.091
#linear_r4_mat[7,8] = 4*0.091
#linear_r4_mat[6,7] = 4*0.091
#linear_r4_mat[7,6] = -4*0.091
linear_r12_mat = np.zeros((12, 90))
linear_r12_mat[0, 1] = 0.089
linear_r12_mat[1, 0] = -0.089
linear_r12_mat[2, 3] = 0.172
linear_r12_mat[3, 2] = -0.172
linear_r12_mat[2, 5] = 0.03
linear_r12_mat[5, 2] = -0.03
linear_r12_mat[2, 6] = 0.022
linear_r12_mat[6, 2] = -0.022
linear_r12_mat[6, 4] = 0.022
linear_r12_mat[4, 6] = 0.023
linear_r12_mat[7, 5] = -0.023
linear_r12_mat[5, 7] = -0.123
linear_r12_mat[7, 5] = 0.123
sindy_opt = SR3Enhanced(threshold=threshold, nu=1, max_iter=20000, \
constraint_lhs=constraint_matrix,constraint_rhs=constraint_zeros, \
tol=1e-6,thresholder='l0',initial_guess=linear_r4_mat)
model = SINDy(optimizer=sindy_opt, \
feature_library=sindy_library, \
differentiation_method=FiniteDifference(drop_endpoints=True), \
feature_names=feature_names)
x_train = x[:M_train, :]
x0_train = x[0, :]
x_true = x[M_train:, :]
x0_test = x[M_train, :]
model.fit(x_train, t=t_train, unbias=False)
t_cycle = np.linspace(time[M_train], time[M_train] * 1.3,
int(len(time) / 2.0))
print(model.coefficients())
x_sim,output = model.simulate(x0_test,t_test, \
integrator=odeint,stop_condition=None,full_output=True, \
rtol=1e-20,h0=1e-5) #h0=1e-20
x_sim1,output = model.simulate(-0.4*np.ones(r),t_cycle, \
integrator=odeint,stop_condition=None,full_output=True, \
rtol=1e-20,h0=1e-5)
x_sim2,output = model.simulate(0.15*np.ones(r),t_cycle, \
integrator=odeint,stop_condition=None,full_output=True, \
rtol=1e-20,h0=1e-5)
x_dot = model.differentiate(x, t=time)
x_dot_train = model.predict(x_train)
x_dot_sim = model.predict(x_true)
print('Model score: %f' % model.score(x, t=time))
make_evo_plots(x_dot,x_dot_train, \
x_dot_sim,x_true,x_sim,time,t_train,t_test)
make_table(model, feature_names)
# Makes 3D phase space plots
if make_3Dphaseplots:
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 2)
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 3)
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 4)
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 5)
make_3d_plots(x_true, x_sim, t_test, 'sim', 0, 1, 6)
make_3d_plots(x_true, x_sim, t_test, 'sim', 3, 4, 5)
make_3d_plots(x_true, x_sim, t_test, 'sim', 4, 5, 6)
make_3d_plots(x_sim1, x_sim2, t_cycle, 'limitcycle')
for i in range(r):
x_sim[:, i] = x_sim[:, i] * sum(np.amax(abs(Vh), axis=1)[0:r])
x_true[:, i] = x_true[:, i] * sum(np.amax(abs(Vh), axis=1)[0:r])
return t_test, x_true, x_sim, S2
# In[2]:
import pysindy as ps
import numpy as np
import matplotlib.pyplot as plt
from pysindy.feature_library import ConcatLibrary, CustomLibrary
x = np.load('t_earth_pos.npy')
v = np.load('t_earth_vel.npy')
a = np.load('t_earth_acc.npy')
t = np.arange(0, x.shape[0], 1) # timesteps in days
functions = [lambda x,y : x/(x**2+y**2)**(3/2), lambda x,y : y/(x**2+y**2)**(3/2)] # The specific functions we're looking for
lib_custom = CustomLibrary(library_functions=functions) # defines the custom library we want to use
# ## Model identification
#
# The following cell includes the model optimization and model identification.
# In[6]:
optimizer = ps.STLSQ(threshold=1)
model = ps.SINDy(
feature_library = lib_custom,
optimizer=optimizer,
feature_names = ['x', 'y'])