# (3) Non smooth problem
aLCP = LCP()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aLCP)
# end of model definition
#
# computation
#
# simulation initialization
CircuitRLCD.setSimulation(aTS)
CircuitRLCD.initialize()
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (T - t0) / h
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import zeros
dataPlot = zeros([N+1, 6])
x = LSCircuitRLCD.x()
processSimulation = TimeStepping(processTD, 0)
processSimulation.setName("plant simulation")
# Declaration of the integrator
processIntegrator = ZeroOrderHoldOSI(processDS)
processSimulation.insertIntegrator(processIntegrator)
# Actuator, Sensor & ControlManager
control = ControlManager(process)
sens = LinearSensor(tSensor, processDS, sensorC)
control.addSensorPtr(sens)
act = LinearSMCOT2(tActuator, processDS)
act.setCsurfacePtr(Csurface)
act.addSensorPtr(sens)
control.addActuatorPtr(act)
# Initialization
process.initialize(processSimulation)
control.initialize()
# This is not working right now
#eventsManager = s.eventsManager()
# Matrix for data storage
dataPlot = empty((N+1, outputSize))
#dataPlot[0, 0] = processDS.t0()
dataPlot[0, 0] = t0
dataPlot[0, 1] = processDS.x()[0]
dataPlot[0, 2] = processDS.x()[1]
dataPlot[0, 3] = processDS.z()[0]
dataPlot[0, 4] = processDS.z()[1]
# Main loop
k = 1
aTiDisc = TimeDiscretisation(t0, h_step)
# (3) Non smooth problem
aLCP = LCP()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aLCP)
# end of model definition
#
# computation
#
# simulation initialization
DiodeBridge.initialize(aTS)
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (T - t0) / h
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import zeros
dataPlot = zeros([N, 10])
x = LSDiodeBridge.x()
aTiDisc = TimeDiscretisation(t0,h_step)
# (3) Non smooth problem
aRelay = Relay()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc,aOSI,aRelay)
# end of model definition
#
# computation
#
# simulation initialization
RelayOscillator.initialize(aTS)
k = 0
h = aTS.timeStep();
print("Timestep : ",h)
# Number of time steps
N = (T-t0)/h
print("Number of steps : ",N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import empty
dataPlot = empty([N+1,8])
x = LSRelayOscillator.x()
def test_bouncing_ball1():
from siconos.kernel import LagrangianLinearTIDS, NewtonImpactNSL, \
LagrangianLinearTIR, Interaction, Model, MoreauJeanOSI, TimeDiscretisation, LCP, TimeStepping
from numpy import array, eye, empty
t0 = 0 # start time
T = 10 # end time
h = 0.005 # time step
r = 0.1 # ball radius
g = 9.81 # gravity
m = 1 # ball mass
e = 0.9 # restitution coeficient
theta = 0.5 # theta scheme
#
# dynamical system
#
x = array([1, 0, 0]) # initial position
v = array([0, 0, 0]) # initial velocity
mass = eye(3) # mass matrix
mass[2, 2] = 3./5 * r * r
# the dynamical system
ball = LagrangianLinearTIDS(x, v, mass)
# set external forces
weight = array([-m * g, 0, 0])
ball.setFExtPtr(weight)
#
# Interactions
#
# ball-floor
H = array([[1, 0, 0]])
nslaw = NewtonImpactNSL(e)
relation = LagrangianLinearTIR(H)
inter = Interaction(1, nslaw, relation)
#
# Model
#
bouncingBall = Model(t0, T)
# add the dynamical system to the non smooth dynamical system
bouncingBall.nonSmoothDynamicalSystem().insertDynamicalSystem(ball)
# link the interaction and the dynamical system
bouncingBall.nonSmoothDynamicalSystem().link(inter, ball)
#
# Simulation
#
# (1) OneStepIntegrators
OSI = MoreauJeanOSI(theta)
OSI.insertDynamicalSystem(ball)
# (2) Time discretisation --
t = TimeDiscretisation(t0, h)
# (3) one step non smooth problem
osnspb = LCP()
# (4) Simulation setup with (1) (2) (3)
s = TimeStepping(t)
s.insertIntegrator(OSI)
s.insertNonSmoothProblem(osnspb)
# end of model definition
#
# computation
#
# simulation initialization
bouncingBall.initialize(s)
#
# save and load data from xml and .dat
#
try:
from siconos.io import save
save(bouncingBall, "bouncingBall.xml")
save(bouncingBall, "bouncingBall.bin")
except:
print("Warning : could not import save from siconos.io")
# the number of time steps
N = (T-t0)/h+1
# Get the values to be plotted
# ->saved in a matrix dataPlot
dataPlot = empty((N, 5))
#
# numpy pointers on dense Siconos vectors
#
q = ball.q()
v = ball.velocity()
p = ball.p(1)
lambda_ = inter.lambda_(1)
#
# initial data
#
dataPlot[0, 0] = t0
dataPlot[0, 1] = q[0]
dataPlot[0, 2] = v[0]
dataPlot[0, 3] = p[0]
dataPlot[0, 4] = lambda_[0]
k = 1
# time loop
while(s.hasNextEvent()):
s.computeOneStep()
dataPlot[k, 0] = s.nextTime()
dataPlot[k, 1] = q[0]
dataPlot[k, 2] = v[0]
dataPlot[k, 3] = p[0]
dataPlot[k, 4] = lambda_[0]
k += 1
#print(s.nextTime())
s.nextStep()
#
# comparison with the reference file
#
from siconos.kernel import SimpleMatrix, getMatrix
from numpy.linalg import norm
ref = getMatrix(SimpleMatrix(os.path.join(working_dir, "data/result.ref")))
assert (norm(dataPlot - ref) < 1e-12)
# (3) Non smooth problem
aLCP = LCP()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aLCP)
# end of model definition
#
# computation
#
# simulation initialization
DiodeBridge.setSimulation(aTS)
DiodeBridge.initialize()
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = int((T - t0) / h)
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import zeros
dataPlot = zeros([N, 10])
x = LSDiodeBridge.x()
s = TimeStepping(td)
myIntegrator = EulerMoreauOSI(theta)
myIntegrator.insertDynamicalSystem(process)
s.insertIntegrator(myIntegrator)
#TODO python <- SICONOS_RELAY_LEMKE
# access dparam
osnspb = Relay()
s.insertNonSmoothProblem(osnspb)
s.setComputeResiduY(True)
s.setComputeResiduR(True)
filippov.initialize(s);
# matrix to save data
dataPlot = empty((N+1,5))
control = empty((N+1,))
dataPlot[0, 0] = t0
dataPlot[0, 1:3] = process.x()
dataPlot[0, 3] = myProcessInteraction.lambda_(0)[0]
dataPlot[0, 4] = myProcessInteraction.lambda_(0)[1]
# time loop
k = 1
while(s.hasNextEvent()):
s.newtonSolve(1e-14, 30)
dataPlot[k, 0] = s.nextTime()
dataPlot[k, 1] = process.x()[0]
dataPlot[k, 2] = process.x()[1]
def test_smc1():
from siconos.kernel import FirstOrderLinearDS, Model, TimeDiscretisation, \
TimeStepping, ZeroOrderHoldOSI, TD_EVENT
from siconos.control.simulation import ControlManager
from siconos.control.sensor import LinearSensor
from siconos.control.controller import LinearSMCOT2
from numpy import eye, empty, zeros
import numpy as np
from math import ceil, sin
# Derive our own version of FirstOrderLinearDS
class MyFOLDS(FirstOrderLinearDS):
def computeb(self, time):
t = sin(50*time)
# XXX fix this !
u = [t, -t]
self.setb(u)
# variable declaration
ndof = 2 # Number of degrees of freedom of your system
t0 = 0.0 # start time
T = 1 # end time
h = 1.0e-4 # time step for simulation
hControl = 1.0e-2 # time step for control
Xinit = 1.0 # initial position
N = ceil((T-t0)/h + 10) # number of time steps
outputSize = 4 # number of variable to store at each time step
# Matrix declaration
A = zeros((ndof, ndof))
x0 = [Xinit, -Xinit]
Brel = np.array([[0], [1]])
sensorC = eye(ndof)
sensorD = zeros((ndof, ndof))
Csurface = [[0, 1.0]]
# Simple check
if h > hControl:
print("hControl must be bigger than h")
exit(1)
# Declaration of the Dynamical System
processDS = MyFOLDS(x0, A)
# XXX b is not automatically created ...
# processDS.setb([0, 0])
# Model
process = Model(t0, T)
process.nonSmoothDynamicalSystem().insertDynamicalSystem(processDS)
# time discretization
processTD = TimeDiscretisation(t0, h)
tSensor = TimeDiscretisation(t0, hControl)
tActuator = TimeDiscretisation(t0, hControl)
# Creation of the Simulation
processSimulation = TimeStepping(processTD, 0)
processSimulation.setName("plant simulation")
# Declaration of the integrator
processIntegrator = ZeroOrderHoldOSI()
process.nonSmoothDynamicalSystem().setOSI(processDS, processIntegrator)
processSimulation.insertIntegrator(processIntegrator)
# Actuator, Sensor & ControlManager
control = ControlManager(processSimulation)
sens = LinearSensor(processDS, sensorC, sensorD)
control.addSensorPtr(sens, tSensor)
act = LinearSMCOT2(sens)
act.setCsurface(Csurface)
act.setB(Brel)
control.addActuatorPtr(act, tActuator)
# Initialization.
process.initialize(processSimulation)
control.initialize(process)
# This is not working right now
# eventsManager = s.eventsManager()
# Matrix for data storage
dataPlot = empty((3*(N+1), outputSize))
dataPlot[0, 0] = t0
dataPlot[0, 1] = processDS.x()[0]
dataPlot[0, 2] = processDS.x()[1]
dataPlot[0, 3] = act.u()[0]
# Main loop
k = 1
while processSimulation.hasNextEvent():
if processSimulation.eventsManager().nextEvent().getType() == TD_EVENT:
processSimulation.computeOneStep()
dataPlot[k, 0] = processSimulation.nextTime()
dataPlot[k, 1] = processDS.x()[0]
dataPlot[k, 2] = processDS.x()[1]
dataPlot[k, 3] = act.u()[0]
k += 1
processSimulation.nextStep()
# print processSimulation.nextTime()
# Resize matrix
dataPlot.resize(k, outputSize)
aTiDisc = TimeDiscretisation(t0, h_step)
# (3) Non smooth problem
aLCP = LCP()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aLCP)
# end of model definition
#
# computation
#
# simulation initialization
CircuitRLCD.initialize(aTS)
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (T - t0) / h
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import zeros
dataPlot = zeros([N + 1, 6])
x = LSCircuitRLCD.x()
def run(self,
with_timer=False,
time_stepping=None,
space_filter=None,
body_class=None,
shape_class=None,
face_class=None,
edge_class=None,
length_scale=1,
t0=0,
T=10,
h=0.0005,
multipoints_iterations=True,
theta=0.50001,
Newton_max_iter=20,
set_external_forces=None,
solver=Numerics.SICONOS_FRICTION_3D_NSGS,
itermax=100000,
tolerance=1e-8):
"""
Run a simulation from inputs in hdf5 file.
parameters are:
with_timer : use a timer for log output (default False)
length_scale : gravity is multiplied by this factor.
1. for meters (default).
1./100 for centimeters.
This parameter may be needed for small
objects because of Bullet collision margin (0.04).
t0 : starting time (default 0)
T : end time (default 10)
h : timestep (default 0.0005)
multiPointIterations : use bullet "multipoint iterations"
(default True)
theta : parameter for Moreau-Jean OSI (default 0.50001)
Newton_max_iter : maximum number of iterations for
integrator Newton loop (default 20)
set_external_forces : method for external forces
(default earth gravity)
solver : default Numerics.SICONOS_FRICTION_3D_NSGS
itermax : maximum number of iteration for solver
tolerance : friction contact solver tolerance
"""
from siconos.kernel import \
Model, MoreauJeanOSI, TimeDiscretisation,\
GenericMechanical, FrictionContact, NewtonImpactFrictionNSL
from siconos.numerics import SICONOS_FRICTION_3D_ONECONTACT_NSN_AC
from siconos.mechanics.contact_detection.bullet import \
btConvexHullShape, btCollisionObject, \
btBoxShape, btQuaternion, btTransform, btConeShape, \
BulletSpaceFilter, cast_BulletR, \
BulletWeightedShape, BulletDS, BulletTimeStepping
if set_external_forces is not None:
self._set_external_forces = set_external_forces
if time_stepping is None:
time_stepping = BulletTimeStepping
if space_filter is None:
space_filter = BulletSpaceFilter
# Model
#
model = Model(t0, T)
# (1) OneStepIntegrators
joints = list(self.joints())
self._osi = MoreauJeanOSI(theta)
# (2) Time discretisation --
timedisc = TimeDiscretisation(t0, h)
if len(joints) > 0:
osnspb = GenericMechanical(SICONOS_FRICTION_3D_ONECONTACT_NSN_AC)
else:
osnspb = FrictionContact(3, solver)
osnspb.numericsSolverOptions().iparam[0] = itermax
osnspb.numericsSolverOptions().dparam[0] = tolerance
osnspb.setMaxSize(16384)
osnspb.setMStorageType(1)
#osnspb.setNumericsVerboseMode(False)
# keep previous solution
osnspb.setKeepLambdaAndYState(True)
# (5) broadphase contact detection
self._broadphase = space_filter(model)
if not multipoints_iterations:
print("""
ConvexConvexMultipointIterations and PlaneConvexMultipointIterations are unset
""")
else:
if hasattr(self._broadphase, 'collisionConfiguration'):
self._broadphase.collisionConfiguration().\
setConvexConvexMultipointIterations()
self._broadphase.collisionConfiguration().\
setPlaneConvexMultipointIterations()
# (6) Simulation setup with (1) (2) (3) (4) (5)
simulation = time_stepping(timedisc)
simulation.insertIntegrator(self._osi)
simulation.insertNonSmoothProblem(osnspb)
simulation.setNewtonMaxIteration(Newton_max_iter)
k = 1
self.importScene(body_class, shape_class, face_class, edge_class)
model.initialize(simulation)
self.outputStaticObjects()
self.outputDynamicObjects()
while simulation.hasNextEvent():
print ('step', k)
log(self._broadphase.buildInteractions, with_timer)\
(model.currentTime())
log(simulation.computeOneStep, with_timer)()
log(self.outputDynamicObjects, with_timer)()
log(self.outputVelocities, with_timer)()
log(self.outputContactForces, with_timer)()
log(self.outputSolverInfos, with_timer)()
log(simulation.nextStep, with_timer)()
log(self._out.flush)()
print ('')
k += 1
# (3) Non smooth problem
aRelay = Relay()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc,aOSI,aRelay)
# end of model definition
#
# computation
#
# simulation initialization
RelayOscillator.setSimulation(aTS)
RelayOscillator.initialize()
k = 0
h = aTS.timeStep();
print("Timestep : ",h)
# Number of time steps
N = (T-t0)/h
print("Number of steps : ",N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import empty
dataPlot = empty([N+1,8])
x = LSRelayOscillator.x()
# (3) Non smooth problem
aRelay = Relay()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aRelay)
# end of model definition
#
# computation
#
# simulation initialization
RelayOscillator.setSimulation(aTS)
RelayOscillator.initialize()
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (int)((T - t0) / h)
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import empty
dataPlot = empty([N + 1, 8])
broadphase.collisionConfiguration().setPlaneConvexMultipointIterations() # The ground is a static object # we give it a group contactor id : 0 broadphase.addStaticObject(ground, 0) # (6) Simulation setup with (1) (2) (3) (4) (5) simulation = BulletTimeStepping(timedisc) #simulation.setNewtonOptions(1) simulation.insertIntegrator(osi) simulation.insertNonSmoothProblem(osnspb) # simulation initialization bouncingBox.setSimulation(simulation) bouncingBox.initialize() # Get the values to be plotted # ->saved in a matrix dataPlot N = (T - t0) / h dataPlot = zeros((N+1, 4)) # # numpy pointers on dense Siconos vectors # q = body.q() v = body.velocity() # # initial data
def test_diodebridge1():
from siconos.kernel import FirstOrderLinearDS, FirstOrderLinearTIR, \
ComplementarityConditionNSL, Interaction,\
Model, EulerMoreauOSI, TimeDiscretisation, LCP, \
TimeStepping
from numpy import empty
from siconos.kernel import SimpleMatrix, getMatrix
from numpy.linalg import norm
t0 = 0.0
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 = [[0, -1.0/Cvalue],
[1.0/Lvalue, 0 ]]
LSDiodeBridge=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=FirstOrderLinearTIR(C, B)
LTIRDiodeBridge.setDPtr(D)
LTIRDiodeBridge.display()
nslaw=ComplementarityConditionNSL(4)
InterDiodeBridge=Interaction(4, nslaw, LTIRDiodeBridge, 1)
#
# Model
#
DiodeBridge=Model(t0, T, Modeltitle)
# add the dynamical system in the non smooth dynamical system
DiodeBridge.nonSmoothDynamicalSystem().insertDynamicalSystem(LSDiodeBridge)
# link the interaction and the dynamical system
DiodeBridge.nonSmoothDynamicalSystem().link(InterDiodeBridge, LSDiodeBridge)
#
# Simulation
#
# (1) OneStepIntegrators
theta = 0.5
aOSI = EulerMoreauOSI(LSDiodeBridge, theta)
# (2) Time discretisation
aTiDisc = TimeDiscretisation(t0, h_step)
# (3) Non smooth problem
aLCP = LCP()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aLCP)
# end of model definition
#
# computation
#
# simulation initialization
DiodeBridge.initialize(aTS)
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (T-t0)/h
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
dataPlot = empty([N, 8])
x = LSDiodeBridge.x()
print("Initial state : ", x)
y = InterDiodeBridge.y(0)
print("First y : ", y)
lambda_ = InterDiodeBridge.lambda_(0)
# For the initial time step:
# time
dataPlot[k, 0] = t0
# inductor voltage
dataPlot[k, 1] = x[0]
# inductor current
dataPlot[k, 2] = x[1]
# diode R1 current
dataPlot[k, 3] = y[0]
# diode R1 voltage
dataPlot[k, 4] = - lambda_[0]
# diode F2 voltage
dataPlot[k, 5] = - lambda_[1]
# diode F1 current
dataPlot[k, 6] = lambda_[2]
# resistor current
dataPlot[k, 7] = y[0] + lambda_[2]
k += 1
while (k < N):
aTS.computeOneStep()
#aLCP.display()
dataPlot[k, 0] = aTS.nextTime()
# inductor voltage
dataPlot[k, 1] = x[0]
# inductor current
dataPlot[k, 2] = x[1]
# diode R1 current
dataPlot[k, 3] = y[0]
# diode R1 voltage
dataPlot[k, 4] = - lambda_[0]
# diode F2 voltage
dataPlot[k, 5] = - lambda_[1]
# diode F1 current
dataPlot[k, 6] = lambda_[2]
# resistor current
dataPlot[k, 7] = y[0] + lambda_[2]
k += 1
aTS.nextStep()
#
# comparison with the reference file
#
ref = getMatrix(SimpleMatrix(os.path.join(working_dir,"data/diode_bridge.ref")))
print(norm(dataPlot - ref))
assert (norm(dataPlot - ref) < 1e-12)
return ref, dataPlot
# (3) Non smooth problem
aLCP = LCP()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aLCP)
# end of model definition
#
# computation
#
# simulation initialization
DiodeBridge.setSimulation(aTS)
DiodeBridge.initialize()
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (T - t0) / h
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import zeros
dataPlot = zeros([N, 8])
x = LSDiodeBridge.x()
def test_diode_bridge():
"""Build diode bridge model"""
# dynamical system
bridge_ds = FirstOrderLinearDS(init_state, A)
# interaction
diode_bridge_relation = FirstOrderLinearTIR(C, B)
diode_bridge_relation.setDPtr(D)
nslaw = ComplementarityConditionNSL(4)
bridge_interaction = Interaction(4, nslaw, diode_bridge_relation, 1)
# Model
diode_bridge = Model(t0, total_time, model_title)
# add the dynamical system in the non smooth dynamical system
diode_bridge.nonSmoothDynamicalSystem().insertDynamicalSystem(bridge_ds)
# link the interaction and the dynamical system
diode_bridge.nonSmoothDynamicalSystem().link(bridge_interaction, bridge_ds)
# Simulation
# (1) OneStepIntegrators
theta = 0.5
integrator = EulerMoreauOSI(theta)
integrator.insertDynamicalSystem(bridge_ds)
# (2) Time discretisation
time_discretisation = TimeDiscretisation(t0, time_step)
# (3) Non smooth problem
non_smooth_problem = LCP()
# (4) Simulation setup with (1) (2) (3)
bridge_simulation = TimeStepping(time_discretisation, integrator,
non_smooth_problem)
# simulation initialization
diode_bridge.initialize(bridge_simulation)
k = 0
h = bridge_simulation.timeStep()
# Number of time steps
N = (total_time - t0) / h
# Get the values to be plotted
# ->saved in a matrix dataPlot
data_plot = empty([N, 8])
x = bridge_ds.x()
print("Initial state : ", x)
y = bridge_interaction.y(0)
print("First y : ", y)
lambda_ = bridge_interaction.lambda_(0)
# For the initial time step:
# time
data_plot[k, 0] = t0
# inductor voltage
data_plot[k, 1] = x[0]
# inductor current
data_plot[k, 2] = x[1]
# diode R1 current
data_plot[k, 3] = y[0]
# diode R1 voltage
data_plot[k, 4] = -lambda_[0]
# diode F2 voltage
data_plot[k, 5] = -lambda_[1]
# diode F1 current
data_plot[k, 6] = lambda_[2]
# resistor current
data_plot[k, 7] = y[0] + lambda_[2]
k += 1
while k < N:
bridge_simulation.computeOneStep()
#non_smooth_problem.display()
data_plot[k, 0] = bridge_simulation.nextTime()
# inductor voltage
data_plot[k, 1] = x[0]
# inductor current
data_plot[k, 2] = x[1]
# diode R1 current
data_plot[k, 3] = y[0]
# diode R1 voltage
data_plot[k, 4] = -lambda_[0]
# diode F2 voltage
data_plot[k, 5] = -lambda_[1]
# diode F1 current
data_plot[k, 6] = lambda_[2]
# resistor current
data_plot[k, 7] = y[0] + lambda_[2]
k += 1
bridge_simulation.nextStep()
#
# comparison with the reference file
#
ref = getMatrix(
SimpleMatrix(os.path.join(working_dir, "data/diode_bridge.ref")))
assert norm(data_plot - ref) < 1e-12
return ref, data_plot
aTiDisc = TimeDiscretisation(t0, h_step) # (3) Non smooth problem aLCP = LCP() # (4) Simulation setup with (1) (2) (3) aTS = TimeStepping(aTiDisc, aOSI, aLCP) # end of model definition # # computation # # simulation initialization CircuitRLCD.initialize(aTS) k = 0 h = aTS.timeStep() print "Timestep : ", h # Number of time steps N = (T - t0) / h print "Number of steps : ", N # Get the values to be plotted # ->saved in a matrix dataPlot from numpy import zeros dataPlot = zeros([N+1, 6]) x = LSCircuitRLCD.x()
def test_diode_bridge():
"""Build diode bridge model"""
# dynamical system
bridge_ds = FirstOrderLinearDS(init_state, A)
# interaction
diode_bridge_relation = FirstOrderLinearTIR(C, B)
diode_bridge_relation.setDPtr(D)
nslaw = ComplementarityConditionNSL(4)
bridge_interaction = Interaction(4, nslaw, diode_bridge_relation, 1)
# Model
diode_bridge = Model(t0, total_time, model_title)
# add the dynamical system in the non smooth dynamical system
diode_bridge.nonSmoothDynamicalSystem().insertDynamicalSystem(bridge_ds)
# link the interaction and the dynamical system
diode_bridge.nonSmoothDynamicalSystem().link(bridge_interaction, bridge_ds)
# Simulation
# (1) OneStepIntegrators
theta = 0.5
integrator = EulerMoreauOSI(theta)
# (2) Time discretisation
time_discretisation = TimeDiscretisation(t0, time_step)
# (3) Non smooth problem
non_smooth_problem = LCP()
# (4) Simulation setup with (1) (2) (3)
bridge_simulation = TimeStepping(time_discretisation,
integrator, non_smooth_problem)
# simulation initialization
diode_bridge.setSimulation(bridge_simulation)
diode_bridge.initialize()
k = 0
h = bridge_simulation.timeStep()
# Number of time steps
N = (total_time - t0) / h
# Get the values to be plotted
# ->saved in a matrix dataPlot
data_plot = empty([N, 8])
x = bridge_ds.x()
print("Initial state : ", x)
y = bridge_interaction.y(0)
print("First y : ", y)
lambda_ = bridge_interaction.lambda_(0)
# For the initial time step:
# time
data_plot[k, 0] = t0
# inductor voltage
data_plot[k, 1] = x[0]
# inductor current
data_plot[k, 2] = x[1]
# diode R1 current
data_plot[k, 3] = y[0]
# diode R1 voltage
data_plot[k, 4] = - lambda_[0]
# diode F2 voltage
data_plot[k, 5] = - lambda_[1]
# diode F1 current
data_plot[k, 6] = lambda_[2]
# resistor current
data_plot[k, 7] = y[0] + lambda_[2]
k += 1
while k < N:
bridge_simulation.computeOneStep()
#non_smooth_problem.display()
data_plot[k, 0] = bridge_simulation.nextTime()
# inductor voltage
data_plot[k, 1] = x[0]
# inductor current
data_plot[k, 2] = x[1]
# diode R1 current
data_plot[k, 3] = y[0]
# diode R1 voltage
data_plot[k, 4] = - lambda_[0]
# diode F2 voltage
data_plot[k, 5] = - lambda_[1]
# diode F1 current
data_plot[k, 6] = lambda_[2]
# resistor current
data_plot[k, 7] = y[0] + lambda_[2]
k += 1
bridge_simulation.nextStep()
#
# comparison with the reference file
#
ref = getMatrix(SimpleMatrix(os.path.join(working_dir,
"data/diode_bridge.ref")))
assert norm(data_plot - ref) < 1e-12
return ref, data_plot
s = TimeStepping(td)
myIntegrator = EulerMoreauOSI(theta)
s.insertIntegrator(myIntegrator)
#TODO python <- SICONOS_RELAY_LEMKE
# access dparam
osnspb = Relay()
s.insertNonSmoothProblem(osnspb)
s.setComputeResiduY(True)
s.setComputeResiduR(True)
filippov.setSimulation(s)
filippov.initialize()
# matrix to save data
dataPlot = empty((N+1,5))
control = empty((N+1,))
dataPlot[0, 0] = t0
dataPlot[0, 1:3] = process.x()
dataPlot[0, 3] = myProcessInteraction.lambda_(0)[0]
dataPlot[0, 4] = myProcessInteraction.lambda_(0)[1]
# time loop
k = 1
while(s.hasNextEvent()):
s.newtonSolve(1e-14, 30)
dataPlot[k, 0] = s.nextTime()
dataPlot[k, 1] = process.x()[0]
dataPlot[k, 2] = process.x()[1]
broadphase.collisionConfiguration().setConvexConvexMultipointIterations() broadphase.collisionConfiguration().setPlaneConvexMultipointIterations() # The ground is a static object # we give it a group contactor id : 0 broadphase.addStaticObject(ground, 0) # (6) Simulation setup with (1) (2) (3) (4) (5) simulation = BulletTimeStepping(timedisc) #simulation.setNewtonOptions(1) simulation.insertIntegrator(osi) simulation.insertNonSmoothProblem(osnspb) # simulation initialization bouncingBox.initialize(simulation) # Get the values to be plotted # ->saved in a matrix dataPlot N = (T - t0) / h dataPlot = zeros((N+1, 4)) # # numpy pointers on dense Siconos vectors # q = body.q() v = body.velocity() # # initial data
aTiDisc = TimeDiscretisation(t0, h_step)
# (3) Non smooth problem
aLCP = LCP()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aLCP)
# end of model definition
#
# computation
#
# simulation initialization
DiodeBridge.initialize(aTS)
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (T - t0) / h
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import zeros
dataPlot = zeros([N, 10])
x = LSDiodeBridge.x()
# (4) Simulation setup with (1) (2) (3) s = TimeStepping(t) #s.setDisplayNewtonConvergence(True) s.setNewtonTolerance(1e-10) #s.setNewtonMaxIteration(1) s.insertIntegrator(OSI) s.insertNonSmoothProblem(osnspb) model.setSimulation(s) # end of model definition # # computation # # simulation initialization model.initialize() # Get the values to be plotted # ->saved in a matrix dataPlot dataPlot = np.empty((N + 1, 26)) # # numpy pointers on dense Siconos vectors # q = ds.q() v = ds.twist() p = ds.p(1) # # initial data #
td = TimeDiscretisation(t0, h)
s = TimeStepping(td)
myIntegrator = EulerMoreauOSI(process, theta)
s.insertIntegrator(myIntegrator)
#TODO python <- SICONOS_RELAY_LEMKE
# access dparam
osnspb = Relay()
s.insertNonSmoothProblem(osnspb)
s.setComputeResiduY(True)
s.setComputeResiduR(True)
filippov.initialize(s);
# matrix to save data
dataPlot = empty((N+1,5))
control = empty((N+1,))
dataPlot[0, 0] = t0
dataPlot[0, 1:3] = process.x()
dataPlot[0, 3] = myProcessInteraction.lambda_(0)[0]
dataPlot[0, 4] = myProcessInteraction.lambda_(0)[1]
# time loop
k = 1
while(s.hasNextEvent()):
s.newtonSolve(1e-14, 30)
dataPlot[k, 0] = s.nextTime()
dataPlot[k, 1] = process.x()[0]
dataPlot[k, 2] = process.x()[1]
aTiDisc = TimeDiscretisation(t0, h_step)
# (3) Non smooth problem
aLCP = LCP()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aLCP)
# end of model definition
#
# computation
#
# simulation initialization
DiodeBridgeCapFilter.initialize(aTS)
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (T - t0) / h
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import zeros
dataPlot = zeros([N - 1, 10])
x = LS1DiodeBridgeCapFilter.x()
# we give it a group contactor id : 0 scs = SiconosContactorSet() scs.append(SiconosContactor(ground)) broadphase.insertStaticContactorSet(scs, groundOffset) # (6) Simulation setup with (1) (2) (3) (4) (5) simulation = TimeStepping(timedisc) simulation.insertInteractionManager(broadphase) simulation.insertIntegrator(osi) simulation.insertNonSmoothProblem(osnspb) # simulation initialization bouncingBox.setSimulation(simulation) bouncingBox.initialize() # Get the values to be plotted # ->saved in a matrix dataPlot N = int((T - t0) / h) dataPlot = zeros((N + 1, 4)) # # numpy pointers on dense Siconos vectors # q = body.q() v = body.velocity() # # initial data
aTiDisc = TimeDiscretisation(t0, h_step) # (3) Non smooth problem aLCP = LCP() # (4) Simulation setup with (1) (2) (3) aTS = TimeStepping(aTiDisc, aOSI, aLCP) # end of model definition # # computation # # simulation initialization DiodeBridgeCapFilter.initialize(aTS) k = 0 h = aTS.timeStep() print "Timestep : ", h # Number of time steps N = (T - t0) / h print "Number of steps : ", N # Get the values to be plotted # ->saved in a matrix dataPlot from numpy import zeros dataPlot = zeros([N-1, 10]) x = LS1DiodeBridgeCapFilter.x()
def test_serialization4():
from siconos.kernel import LagrangianLinearTIDS, NewtonImpactNSL, \
LagrangianLinearTIR, Interaction, Model, MoreauJeanOSI, TimeDiscretisation, LCP, TimeStepping
from numpy import array, eye, empty
t0 = 0 # start time
T = 10 # end time
h = 0.005 # time step
r = 0.1 # ball radius
g = 9.81 # gravity
m = 1 # ball mass
e = 0.9 # restitution coeficient
theta = 0.5 # theta scheme
#
# dynamical system
#
x = array([1, 0, 0]) # initial position
v = array([0, 0, 0]) # initial velocity
mass = eye(3) # mass matrix
mass[2, 2] = 3./5 * r * r
# the dynamical system
ball = LagrangianLinearTIDS(x, v, mass)
# set external forces
weight = array([-m * g, 0, 0])
ball.setFExtPtr(weight)
#
# Interactions
#
# ball-floor
H = array([[1, 0, 0]])
nslaw = NewtonImpactNSL(e)
relation = LagrangianLinearTIR(H)
inter = Interaction(1, nslaw, relation)
#
# Model
#
first_bouncingBall = Model(t0, T)
# add the dynamical system to the non smooth dynamical system
first_bouncingBall.nonSmoothDynamicalSystem().insertDynamicalSystem(ball)
# link the interaction and the dynamical system
first_bouncingBall.nonSmoothDynamicalSystem().link(inter, ball)
#
# Simulation
#
# (1) OneStepIntegrators
OSI = MoreauJeanOSI(theta)
# (2) Time discretisation --
t = TimeDiscretisation(t0, h)
# (3) one step non smooth problem
osnspb = LCP()
# (4) Simulation setup with (1) (2) (3)
s = TimeStepping(t)
s.insertIntegrator(OSI)
s.insertNonSmoothProblem(osnspb)
# end of model definition
#
# computation
#
# simulation initialization
first_bouncingBall.setSimulation(s)
first_bouncingBall.initialize()
#
# save and load data from xml and .dat
#
from siconos.io.io_base import save, load
save(first_bouncingBall, "bouncingBall.xml")
bouncingBall = load("bouncingBall.xml")
# the number of time steps
N = (T-t0)/h+1
# Get the values to be plotted
# ->saved in a matrix dataPlot
dataPlot = empty((N, 5))
#
# numpy pointers on dense Siconos vectors
#
q = ball.q()
v = ball.velocity()
p = ball.p(1)
lambda_ = inter.lambda_(1)
#
# initial data
#
dataPlot[0, 0] = t0
dataPlot[0, 1] = q[0]
dataPlot[0, 2] = v[0]
dataPlot[0, 3] = p[0]
dataPlot[0, 4] = lambda_[0]
k = 1
# time loop
while(s.hasNextEvent()):
s.computeOneStep()
dataPlot[k, 0] = s.nextTime()
dataPlot[k, 1] = q[0]
dataPlot[k, 2] = v[0]
dataPlot[k, 3] = p[0]
dataPlot[k, 4] = lambda_[0]
k += 1
print(s.nextTime())
s.nextStep()
#
# comparison with the reference file
#
from siconos.kernel import SimpleMatrix, getMatrix
from numpy.linalg import norm
ref = getMatrix(SimpleMatrix(os.path.join(working_dir,
"data/result.ref")))
assert (norm(dataPlot - ref) < 1e-12)
s = TimeStepping(td)
myIntegrator = EulerMoreauOSI(theta)
s.insertIntegrator(myIntegrator)
#TODO python <- SICONOS_RELAY_LEMKE
# access dparam
osnspb = Relay()
s.insertNonSmoothProblem(osnspb)
s.setComputeResiduY(True)
s.setComputeResiduR(True)
filippov.setSimulation(s)
filippov.initialize()
# matrix to save data
dataPlot = empty((N+1,5))
dataPlot[0, 0] = t0
dataPlot[0, 1:3] = process.x()
dataPlot[0, 3] = myProcessInteraction.lambda_(0)[0]
dataPlot[0, 4] = myProcessInteraction.lambda_(0)[1]
# time loop
k = 1
while(s.hasNextEvent()):
s.newtonSolve(1e-12, 40)
dataPlot[k, 0] = s.nextTime()
dataPlot[k, 1] = process.x()[0]
dataPlot[k, 2] = process.x()[1]
dataPlot[k, 3] = myProcessInteraction.lambda_(0)[0]
# (3) one step non smooth problem osnspb = LCP() # (4) Simulation setup with (1) (2) (3) s = TimeStepping(t, OSI, osnspb) # end of model definition # # computation # # simulation initialization bouncingBall.initialize(s) # the number of time steps N = (T - t0) / h # Get the values to be plotted # ->saved in a matrix dataPlot dataPlot = empty((N+1, 5)) # # numpy pointers on dense Siconos vectors # q = ball.q() v = ball.velocity()
aTiDisc = TimeDiscretisation(t0, h_step)
# (3) Non smooth problem
aRelay = Relay()
# (4) Simulation setup with (1) (2) (3)
aTS = TimeStepping(aTiDisc, aOSI, aRelay)
# end of model definition
#
# computation
#
# simulation initialization
RelayOscillator.initialize(aTS)
k = 0
h = aTS.timeStep()
print("Timestep : ", h)
# Number of time steps
N = (T - t0) / h
print("Number of steps : ", N)
# Get the values to be plotted
# ->saved in a matrix dataPlot
from numpy import empty
dataPlot = empty([N + 1, 8])
