def test_first_order_ltids():
"""Build and test first order linear
and time-invariant coeff. ds
"""
time = 1.2
ds_list = []
b_vec = np.random.random((nn, ))
ds_list.append(sk.FirstOrderLinearTIDS(x0, a_mat))
ds_list.append(sk.FirstOrderLinearTIDS(x0, a_mat, b_vec))
for ds in ds_list:
assert ds.isLinear()
assert ds.dimension() == nn
assert np.allclose(ds.x0(), x0)
assert np.allclose(ds.x(), x0)
assert np.allclose(ds.r(), 0.)
rhs = np.dot(a_mat, ds.x())
if ds.b() is not None:
rhs += ds.b()
ds.initRhs(time)
assert np.allclose(rhs, ds.rhs())
assert np.allclose(ds.jacobianRhsx(), a_mat)
assert np.allclose(ds.jacobianRhsx(), ds.jacobianfx())
def compute_dt_matrices(A, B, h, TV=False):
# variable declaration
t0 = 0.0 # start time
T = 1 # end time
n, m = B.shape
# Matrix declaration
x0 = np.random.random(n)
Csurface = np.random.random((m, n))
# Declaration of the Dynamical System
if TV:
process_ds = SK.FirstOrderLinearDS(x0, A)
else:
process_ds = SK.FirstOrderLinearTIDS(x0, A)
# Model
process = SK.Model(t0, T)
process.nonSmoothDynamicalSystem().insertDynamicalSystem(process_ds)
# time discretisation
process_time_discretisation = SK.TimeDiscretisation(t0, h)
# Creation of the Simulation
process_simu = SK.TimeStepping(process_time_discretisation, 0)
process_simu.setName("plant simulation")
# Declaration of the integrator
process_integrator = SK.ZeroOrderHoldOSI()
process_integrator.insertDynamicalSystem(process_ds)
process_simu.insertIntegrator(process_integrator)
rel = SK.FirstOrderLinearTIR(Csurface, B)
nslaw = SK.RelayNSL(m)
inter = SK.Interaction(m, nslaw, rel)
#process.nonSmoothDynamicalSystem().insertInteraction(inter, True)
process.nonSmoothDynamicalSystem().link(inter, process_ds)
process.nonSmoothDynamicalSystem().setControlProperty(inter, True)
# Initialization
process.initialize(process_simu)
# Main loop
process_simu.computeOneStep()
Ad = SK.getMatrix(process_integrator.Ad(process_ds)).copy()
Bd = SK.getMatrix(process_integrator.Bd(process_ds)).copy()
return (Ad, Bd)
h = 0.05 # time step xFinal = 0.0 # target position theta = 0.5 N = int((T - t0) / h + 10) # number of time steps outputSize = 5 # number of variable to store at each time step # Matrix declaration A = zeros((2, 2)) A[0, 1] = 1 B = [[0], [1]] x0 = [10., 10.] C = [[1., 0]] # we have to specify ndmin=2, so it's understood as K = [.25, .125, 2] # Declaration of the Dynamical System doubleIntegrator = sk.FirstOrderLinearTIDS(x0, A) # Model process = sk.Model(t0, T) process.nonSmoothDynamicalSystem().insertDynamicalSystem(doubleIntegrator) # Declaration of the integrator OSI = sk.EulerMoreauOSI(theta) # time discretisation t = sk.TimeDiscretisation(t0, h) tSensor = sk.TimeDiscretisation(t0, h) tActuator = sk.TimeDiscretisation(t0, h) s = sk.TimeStepping(t, 0) s.insertIntegrator(OSI) # Actuator, Sensor & ControlManager control = ControlManager(s) sens = LinearSensor(doubleIntegrator, C)
A[ndof - 1, ndof - 1] *= 0.5
# extra-diag values
for i in xrange(1, number_of_cars):
A[i, i - 1] = A[i - 1, i] = 1. / (R * C)
A[i, i + number_of_cars - 1] = A[i - 1, i + number_of_cars] = 1. / (R * C)
A[i + number_of_cars, i - 1] = A[i + number_of_cars - 1, i] = 1. / (R * D)
A[i + number_of_cars, i + number_of_cars - 1] = 1. / (R * D)
A[i + number_of_cars - 1, i + number_of_cars] = 1. / (R * D)
b = np.zeros(ndof, np.float64)
b[0] = w0 / (R * C)
b[number_of_cars - 1] = -jn / C
b[number_of_cars] = w0 / (R * D)
b[ndof - 1] = -jn / D
RC = sk.FirstOrderLinearTIDS(q0, A, b)
# -- Interaction --
# *** Linear time invariant relation (LTIR) ***
# y = N.q + M.x and r = B.x
# y = [ -h_1 ... -h_n ]
# x = [ k_1 ... k_n ]
# + complementarity(x,y)
ninter = number_of_cars
B = np.zeros((ndof, ninter), dtype=np.float64)
np.fill_diagonal(B[number_of_cars:, :number_of_cars], -1. / D)
M = np.zeros((ninter, ninter), dtype=np.float64)
np.fill_diagonal(M[:number_of_cars, :number_of_cars], S)
