def test_autocast():
dsA = sk.LagrangianDS([0], [0], [[1]])
dsB = sk.FirstOrderLinearDS([0], [[1]])
nsds = sk.NonSmoothDynamicalSystem(0, 0)
nsds.insertDynamicalSystem(dsA)
nsds.insertDynamicalSystem(dsB)
assert (type(nsds.dynamicalSystem(dsA.number())) == sk.LagrangianDS)
assert (type(nsds.dynamicalSystem(dsB.number())) == sk.FirstOrderLinearDS)
def test_autocast():
dsA = K.LagrangianDS([0],[0],[[1]])
dsB = K.FirstOrderLinearDS([0],[[1]])
model = K.Model(0, 0)
model.nonSmoothDynamicalSystem().insertDynamicalSystem(dsA)
model.nonSmoothDynamicalSystem().insertDynamicalSystem(dsB)
assert(type(model.nonSmoothDynamicalSystem().dynamicalSystem(dsA.number())) == K.LagrangianDS)
assert(type(model.nonSmoothDynamicalSystem().dynamicalSystem(dsB.number())) == K.FirstOrderLinearDS)
def test_first_order_lds():
"""Build and test first order linear
and time-invariant coeff. ds
"""
ndof = 3
x0 = np.random.random(ndof)
time = 1.2
ds_list = []
a_mat = np.random.random((ndof, ndof))
b_vec = np.random.random((ndof, ))
ds_list.append(sk.FirstOrderLinearDS(x0))
ds_list.append(sk.FirstOrderLinearDS(x0, a_mat))
ds_list.append(sk.FirstOrderLinearDS(x0, a_mat, b_vec))
for ds in ds_list:
assert ds.isLinear()
assert ds.dimension() == ndof
assert np.allclose(ds.x0(), x0)
assert np.allclose(ds.x(), x0)
assert np.allclose(ds.r(), 0.)
rhs = np.zeros_like(ds.x())
jac_ref = np.zeros((ndof, ndof), dtype=np.float64)
if isinstance(ds.A(), np.ndarray):
jac_ref += a_mat
rhs += np.dot(a_mat, ds.x())
if isinstance(ds.b(), np.ndarray):
rhs += ds.b()
ds.computef(time, ds.x())
if ds.f() is not None:
assert np.allclose(rhs, ds.f())
ds.initRhs(time)
assert np.allclose(rhs, ds.rhs())
if ds.A() is not None:
assert np.allclose(ds.jacobianRhsx(), jac_ref)
assert np.allclose(ds.jacobianRhsx(), ds.jacobianfx())
def test_autocast():
dsA = sk.LagrangianDS([0], [0], [[1]])
dsB = sk.FirstOrderLinearDS([0], [[1]])
nsds = sk.NonSmoothDynamicalSystem(0, 0)
nsds.insertDynamicalSystem(dsA)
nsds.insertDynamicalSystem(dsB)
failed=0
if not isinstance(nsds.dynamicalSystem(dsA.number()), sk.LagrangianDS):
failed = 1
if not isinstance(nsds.dynamicalSystem(dsB.number()), sk.FirstOrderLinearDS):
failed = 1
return failed
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)
t0 = 0.0 # start time
T = 1.0 # end time
h = 1.0e-3 # time step
Vinit = 1.0
theta = 0.5
N = int((T - t0) / h)
# Dynamical systems
A = np.zeros((2, 2))
x0 = np.array([Vinit, -Vinit])
B = 2.0 * np.eye(2)
C = np.eye(2)
D = np.zeros((2, 2))
process = sk.FirstOrderLinearDS(x0, A)
process.setComputebFunction('plugins', 'computeB')
# Interactions
myNslaw = sk.RelayNSL(2)
myProcessRelation = sk.FirstOrderLinearR(C, B)
myProcessRelation.setComputeEFunction('plugins', 'computeE')
# myProcessRelation.setDPtr(D)
myProcessInteraction = sk.Interaction(myNslaw, myProcessRelation)
# NSDS
simplerelay = sk.NonSmoothDynamicalSystem(t0, T)
simplerelay.insertDynamicalSystem(process)
simplerelay.link(myProcessInteraction, process)
withPlot = True
if (withPlot):
import matplotlib
matplotlib.use('Agg')
from matplotlib.pyplot import subplot, title, plot, grid, savefig, show
#
# dynamical system
#
init_state = [-1, 0]
A = np.zeros((2, 2), dtype=np.float64)
A.flat[...] = [0., -1.0 / Cvalue, 1.0 / Lvalue, 0.]
LSCircuitRLCD = sk.FirstOrderLinearDS(init_state, A)
#
# Interactions
#
C = [[-1., 0.]]
D = [[Rvalue]]
B = [[-1. / Cvalue], [0.]]
LTIRCircuitRLCD = sk.FirstOrderLinearTIR(C, B)
LTIRCircuitRLCD.setDPtr(D)
nslaw = sk.ComplementarityConditionNSL(1)
T = 5.0e-3 # Total simulation time
h_step = 1.0e-6 # Time step
Lvalue = 1e-2 # inductance
Cvalue = 1e-6 # capacitance
Rvalue = 1e3 # resistance
Vinit = 10.0 # initial voltage
Modeltitle = "DiodeBridge"
#
# dynamical system
#
init_state = [Vinit, 0]
A = np.zeros((2, 2), dtype=np.float64)
A.flat[...] = [0., -1.0 / Cvalue, 1.0 / Lvalue, 0.]
LSDiodeBridge = sk.FirstOrderLinearDS(init_state, A)
#
# Interactions
#
C = [[0., 0.], [0, 0.], [-1., 0.], [1., 0.]]
D = [[1. / Rvalue, 1. / Rvalue, -1., 0.], [1. / Rvalue, 1. / Rvalue, 0., -1.],
[1., 0., 0., 0.], [0., 1., 0., 0.]]
B = [[0., 0., -1. / Cvalue, 1. / Cvalue], [0., 0., 0., 0.]]
LTIRDiodeBridge = sk.FirstOrderLinearTIR(C, B)
LTIRDiodeBridge.setDPtr(D)
rho = 10.0 x00 = rho # Initial position x01 = rho x02 = 0.0 alpha = 0.05 # angle of the square helical beta = 0.01 # thread of the helical gamma = 0. # thread variation # -- Dynamical system -- # dx / dt = A.x + b + r A = np.zeros((ndof, ndof), dtype=np.float64) x0 = np.zeros(3, dtype=np.float64) x0.flat[...] = [x00, x01, x02] b = np.zeros_like(x0) b[2] = beta particle = sk.FirstOrderLinearDS(x0, A, b) # -- Interaction -- # y = C.x + D.lambda # r = B.lambda ninter = 2 B = np.zeros((ndof, ninter), dtype=np.float64) B[0, 0] = -alpha * 0.5 B[0, 1] = 1 + alpha * 0.5 B[1, 0] = -B[0, 1] B[1, 1] = B[0, 0] B[2, 0] = gamma * 0.5 B[2, 1] = gamma * 0.5 C = np.zeros((ninter, ndof), dtype=np.float64) C[0, 0] = C[1, 1] = -1.
