siconos.modeling module

Siconos modeling library

class siconos.modeling.BoundaryCondition(*args, **kwargs)

Bases: pybind11_object

Overloaded function.

1. __init__(self: siconos.modeling.BoundaryCondition, Indices: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex]) -> None

2. __init__(self: siconos.modeling.BoundaryCondition, Indices: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], prescribedVelocities: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]) -> None

computePrescribedVelocity(*args, **kwargs)

Overloaded function.

1. computePrescribedVelocity(self: siconos.modeling.BoundaryCondition, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None

Compute velocity values on prescribed indices

2. computePrescribedVelocity(self: siconos.modeling.BoundaryCondition, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None

compute boundary conditions

property prescribedVelocity

values applied on constrained indices

setComputePrescribedVelocityFunction(self: siconos.modeling.BoundaryCondition, arg0: collections.abc.Callable) → None

How to compute boundary conditions

property size

property velocityIndices

indices where conditions apply

class siconos.modeling.ComplementarityConditionNSL(self: siconos.modeling.ComplementarityConditionNSL, arg0: SupportsInt | SupportsIndex)

Bases: NonSmoothLaw

class siconos.modeling.DynamicalSystem

Bases: pybind11_object

property dimension

dimension of the system

display(self: siconos.modeling.DynamicalSystem, arg0: bool) → None

number(self: siconos.modeling.DynamicalSystem) → int

r(self: siconos.modeling.DynamicalSystem) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

resetCount(self: SupportsInt | SupportsIndex) → int

resetToInitialState(self: siconos.modeling.DynamicalSystem) → None

setNumber(self: siconos.modeling.DynamicalSystem, arg0: SupportsInt | SupportsIndex) → int

swapInMemory(self: siconos.modeling.DynamicalSystem) → None

x(self: siconos.modeling.DynamicalSystem) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

class siconos.modeling.EqualityConditionNSL(self: siconos.modeling.EqualityConditionNSL, arg0: SupportsInt | SupportsIndex)

Bases: NonSmoothLaw

class siconos.modeling.FirstOrderLinearDS(*args, **kwargs)

Bases: FirstOrderNonLinearDS

Overloaded function.

1. __init__(self: siconos.modeling.FirstOrderLinearDS, x0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

2. __init__(self: siconos.modeling.FirstOrderLinearDS, x0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

3. __init__(self: siconos.modeling.FirstOrderLinearDS, x0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], A: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.writeable”, “flags.f_contiguous”], b: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

4. __init__(self: siconos.modeling.FirstOrderLinearDS, x0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], A: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, n]”], b: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

property A

A matrix

property b

computeb(self: siconos.modeling.FirstOrderLinearDS, arg0: SupportsFloat | SupportsIndex) → None

compute b(t)

setComputebVectorFunction(self: siconos.modeling.FirstOrderLinearDS, arg0: collections.abc.Callable) → None

How to compute b(t)

setConstantA(*args, **kwargs)

Overloaded function.

1. setConstantA(self: siconos.modeling.FirstOrderLinearDS, A: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, n]”], copy_t: siconos.modeling.copy_t) -> None

To define a constant A matrix (copy).

2. setConstantA(self: siconos.modeling.FirstOrderLinearDS, A: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.writeable”, “flags.f_contiguous”], alias_t: siconos.modeling.alias_t) -> None

To define a constant A matrix (alias).

setConstantbVector(*args, **kwargs)

Overloaded function.

1. setConstantbVector(self: siconos.modeling.FirstOrderLinearDS, b: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

Set constant b (copy).

2. setConstantbVector(self: siconos.modeling.FirstOrderLinearDS, b: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

Set constant b (alias).

class siconos.modeling.FirstOrderLinearR(self: siconos.modeling.FirstOrderLinearR)

Bases: FirstOrderR

setConstantBAlias(self: siconos.modeling.FirstOrderLinearR, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.writeable', 'flags.f_contiguous']) → None

To define a constant B operator

setConstantCAlias(self: siconos.modeling.FirstOrderLinearR, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.writeable', 'flags.f_contiguous']) → None

To define a constant C operator

class siconos.modeling.FirstOrderLinearTIR(self: siconos.modeling.FirstOrderLinearTIR, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.writeable', 'flags.f_contiguous'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.writeable', 'flags.f_contiguous'])

Bases: FirstOrderR

display(self: siconos.modeling.FirstOrderLinearTIR) → None

setConstantD(self: siconos.modeling.FirstOrderLinearTIR, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.writeable', 'flags.f_contiguous']) → None

To define a constant D operator

class siconos.modeling.FirstOrderNonLinearDS(*args, **kwargs)

Bases: DynamicalSystem

Overloaded function.

1. __init__(self: siconos.modeling.FirstOrderNonLinearDS, x0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

2. __init__(self: siconos.modeling.FirstOrderNonLinearDS, x0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

property MMatrix

M matrix

setConstantMMatrix(*args, **kwargs)

Overloaded function.

1. setConstantMMatrix(self: siconos.modeling.FirstOrderNonLinearDS, M: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, n]”], copy_t: siconos.modeling.copy_t) -> None

To define a constant M matrix (copy).

2. setConstantMMatrix(self: siconos.modeling.FirstOrderNonLinearDS, M: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.writeable”, “flags.f_contiguous”], alias_t: siconos.modeling.alias_t) -> None

To define a constant M matrix (alias).

class siconos.modeling.FirstOrderR

Bases: Relation

class siconos.modeling.FremondImpactFrictionNSL(*args, **kwargs)

Bases: NonSmoothLaw

Overloaded function.

1. __init__(self: siconos.modeling.FremondImpactFrictionNSL, size: typing.SupportsInt | typing.SupportsIndex = 1) -> None

2. __init__(self: siconos.modeling.FremondImpactFrictionNSL, en: typing.SupportsFloat | typing.SupportsIndex = 0.0, et: typing.SupportsFloat | typing.SupportsIndex = 0.0, mu: typing.SupportsFloat | typing.SupportsIndex = 0.0, size: typing.SupportsInt | typing.SupportsIndex = 1) -> None

class siconos.modeling.HarmonicBC(*args, **kwargs)

Bases: BoundaryCondition

Overloaded function.

1. __init__(self: siconos.modeling.HarmonicBC, Indices: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], a: typing.SupportsFloat | typing.SupportsIndex, b: typing.SupportsFloat | typing.SupportsIndex, omega: typing.SupportsFloat | typing.SupportsIndex, phi: typing.SupportsFloat | typing.SupportsIndex) -> None

2. __init__(self: siconos.modeling.HarmonicBC, Indices: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], a: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], b: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], omega: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], phi: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]) -> None

class siconos.modeling.Interaction(self: siconos.modeling.Interaction, arg0: siconos.modeling.NonSmoothLaw, arg1: siconos.modeling.Relation)

Bases: pybind11_object

computeInput(self: siconos.modeling.Interaction, arg0: SupportsFloat | SupportsIndex, arg1: SupportsInt | SupportsIndex) → None

Computes input lambda

computeOutput(self: siconos.modeling.Interaction, arg0: SupportsFloat | SupportsIndex, arg1: SupportsInt | SupportsIndex) → None

Computes output y

lambda_python(self: siconos.modeling.Interaction, arg0: SupportsInt | SupportsIndex) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

relation(self: siconos.modeling.Interaction) → siconos.modeling.Relation

y(self: siconos.modeling.Interaction, arg0: SupportsInt | SupportsIndex) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

class siconos.modeling.Lagrangian2d1DR

Bases: LagrangianScleronomousR

distance(self: siconos.modeling.Lagrangian2d1DR) → float

distance between contact points 1 and 2, with sign according to normal

class siconos.modeling.Lagrangian2d2DR

Bases: LagrangianScleronomousR

distance(self: siconos.modeling.Lagrangian2d2DR) → float

distance between contact points 1 and 2, with sign according to normal

class siconos.modeling.Lagrangian2d3DR

Bases: LagrangianScleronomousR

distance(self: siconos.modeling.Lagrangian2d3DR) → float

distance between contact points 1 and 2, with sign according to normal

class siconos.modeling.LagrangianDS(*args, **kwargs)

Bases: SecondOrderDS

Overloaded function.

1. __init__(self: siconos.modeling.LagrangianDS, q0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], v0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

2. __init__(self: siconos.modeling.LagrangianDS, q0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], v0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

computeFext(self: siconos.modeling.LagrangianDS, arg0: SupportsFloat | SupportsIndex) → None

compute external forces

computeFgyr(self: siconos.modeling.LagrangianDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → None

compute gyroscopic forces

computeFint(self: siconos.modeling.LagrangianDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg2: SupportsFloat | SupportsIndex) → None

compute internal forces

computeJacobianTotalForcesOver_q(self: siconos.modeling.LagrangianDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg2: SupportsFloat | SupportsIndex) → None

compute total forces

computeJacobianTotalForcesOver_velocity(self: siconos.modeling.LagrangianDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg2: SupportsFloat | SupportsIndex) → None

compute total forces

computeKineticEnergy(self: siconos.modeling.LagrangianDS) → float

computeMass(self: siconos.modeling.LagrangianDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → None

compute total forces

computeTotalForces(self: siconos.modeling.LagrangianDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]'], arg2: SupportsFloat | SupportsIndex) → None

compute total forces

property fext

current values of the external forces vector

property fgyr

gyroscopic forces current values

property fint

internal forces current values

property jacobianTotalForcesOver_q

jacobian of the internal forces over q

property jacobianTotalForcesOver_velocity

jacobian of the internal forces over velocity

property mass

mass matrix

property mass_alias

View (shared memory) on the mass (scipy.sparse.csc_array).

q(self: siconos.modeling.LagrangianDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

property q0

current values of the initial state

resetToInitialState(self: siconos.modeling.LagrangianDS) → None

reset the system to the current saved initial state

reset_q0(self: siconos.modeling.LagrangianDS, q0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]']) → None

Reset initial state (q0).

reset_velocity0(self: siconos.modeling.LagrangianDS, q0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]']) → None

Reset initial state (v0).

setComputeFextFunction(self: siconos.modeling.LagrangianDS, arg0: collections.abc.Callable) → None

How to compute external forces

setComputeFgyrFunction(self: siconos.modeling.LagrangianDS, arg0: collections.abc.Callable) → None

How to compute gyroscopic forces

setComputeFintFunction(self: siconos.modeling.LagrangianDS, arg0: collections.abc.Callable) → None

How to compute internal forces

setComputeMassFunction(self: siconos.modeling.LagrangianDS, arg0: collections.abc.Callable) → None

How to compute mass matrix

setConstantFext(*args, **kwargs)

Overloaded function.

1. setConstantFext(self: siconos.modeling.LagrangianDS, fext: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

Set constant external forces (copy).

2. setConstantFext(self: siconos.modeling.LagrangianDS, fext: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

Set constant external forces (alias).

setConstantMass(*args, **kwargs)

Overloaded function.

1. setConstantMass(self: siconos.modeling.LagrangianDS, mass: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, n]”], copy_t: siconos.modeling.copy_t) -> None

To define a constant mass matrix (copy).

2. setConstantMass(self: siconos.modeling.LagrangianDS, mass: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.writeable”, “flags.f_contiguous”], alias_t: siconos.modeling.alias_t) -> None

To define a constant mass matrix (alias).

property totalForces

internal forces current values

velocity(self: siconos.modeling.LagrangianDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

property velocity0

current values of the initial velocity state

class siconos.modeling.LagrangianLinearDiagonalDS(*args, **kwargs)

Bases: LagrangianDS

Overloaded function.

1. __init__(self: siconos.modeling.LagrangianLinearDiagonalDS, q0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], v0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], stiffness_diag: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

2. __init__(self: siconos.modeling.LagrangianLinearDiagonalDS, q0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], v0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], stiffness_diag: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

property dampingMatrix

damping matrix

property massMatrix

mass matrix

setDampingMatrix(*args, **kwargs)

Overloaded function.

1. setDampingMatrix(self: siconos.modeling.LagrangianLinearDiagonalDS, damping: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

To define a constant damping matrix (copy).

2. setDampingMatrix(self: siconos.modeling.LagrangianLinearDiagonalDS, damping: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

To define a constant damping matrix (alias).

setMassMatrix(*args, **kwargs)

Overloaded function.

1. setMassMatrix(self: siconos.modeling.LagrangianLinearDiagonalDS, mass: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

To define a constant damping matrix (copy).

2. setMassMatrix(self: siconos.modeling.LagrangianLinearDiagonalDS, mass: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

To define a constant damping matrix (alias).

setStiffnessMatrix(*args, **kwargs)

Overloaded function.

1. setStiffnessMatrix(self: siconos.modeling.LagrangianLinearDiagonalDS, stiffness: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

To define a constant stiffness matrix (copy).

2. setStiffnessMatrix(self: siconos.modeling.LagrangianLinearDiagonalDS, stiffness: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

To define a constant stiffness matrix (alias).

property stiffnessMatrix

stiffness matrix

class siconos.modeling.LagrangianLinearTIDS(*args, **kwargs)

Bases: LagrangianDS

Overloaded function.

1. __init__(self: siconos.modeling.LagrangianLinearTIDS, q0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], v0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], mass: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, n]”], copy_t: siconos.modeling.copy_t) -> None

   constructor from initial state and mass matrix only. warning: q0, v0, M will be copied into class attributes.

2. __init__(self: siconos.modeling.LagrangianLinearTIDS, q0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], v0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], mass: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.writeable”, “flags.f_contiguous”], alias_t: siconos.modeling.alias_t) -> None

constructor from initial state only.

warning: alias (shared memory) between input q0/v0 and internal attributes

property dampingMatrix

damping matrix

setDampingMatrix(*args, **kwargs)

Overloaded function.

1. setDampingMatrix(self: siconos.modeling.LagrangianLinearTIDS, damping: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, n]”], copy_t: siconos.modeling.copy_t) -> None

To define a constant damping matrix (copy).

2. setDampingMatrix(self: siconos.modeling.LagrangianLinearTIDS, damping: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.writeable”, “flags.f_contiguous”], alias_t: siconos.modeling.alias_t) -> None

To define a constant damping matrix (alias).

setStiffnessMatrix(*args, **kwargs)

Overloaded function.

1. setStiffnessMatrix(self: siconos.modeling.LagrangianLinearTIDS, stiffness: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, n]”], copy_t: siconos.modeling.copy_t) -> None

To define a constant stiffness matrix (copy).

2. setStiffnessMatrix(self: siconos.modeling.LagrangianLinearTIDS, stiffness: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.writeable”, “flags.f_contiguous”], alias_t: siconos.modeling.alias_t) -> None

To define a constant stiffness matrix (alias).

property stiffnessMatrix

stiffness matrix

class siconos.modeling.LagrangianLinearTIR(self: siconos.modeling.LagrangianLinearTIR, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.writeable', 'flags.f_contiguous'])

Bases: LagrangianR

display(self: siconos.modeling.LagrangianLinearTIR) → None

class siconos.modeling.LagrangianR

Bases: Relation

class siconos.modeling.LagrangianScleronomousR

Bases: LagrangianR

class siconos.modeling.LagrangianSparseDS(*args, **kwargs)

Bases: SecondOrderDS

Overloaded function.

1. __init__(self: siconos.modeling.LagrangianSparseDS, q0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], v0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

2. __init__(self: siconos.modeling.LagrangianSparseDS, q0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], v0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

computeFext(self: siconos.modeling.LagrangianSparseDS, arg0: SupportsFloat | SupportsIndex) → None

compute external forces

computeJacobianFgyrOver_q(self: siconos.modeling.LagrangianSparseDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]', 'flags.writeable'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]', 'flags.writeable']) → None

computeJacobianFgyrOver_velocity(self: siconos.modeling.LagrangianSparseDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]', 'flags.writeable'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]', 'flags.writeable']) → None

computeJacobianFintOver_q(self: siconos.modeling.LagrangianSparseDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]', 'flags.writeable'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]', 'flags.writeable'], arg2: SupportsFloat | SupportsIndex) → None

computeJacobianFintOver_velocity(self: siconos.modeling.LagrangianSparseDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]', 'flags.writeable'], arg1: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]', 'flags.writeable'], arg2: SupportsFloat | SupportsIndex) → None

computeMass(self: siconos.modeling.LagrangianSparseDS, arg0: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → None

property fext

current values of the external forces vector

hasConstantJacobianTotalForcesOver_q(self: siconos.modeling.LagrangianSparseDS) → bool

hasConstantJacobianTotalForcesOver_velocity(self: siconos.modeling.LagrangianSparseDS) → bool

hasConstantMass(self: siconos.modeling.LagrangianSparseDS) → bool

hasJacobianFgyrOver_q(self: siconos.modeling.LagrangianSparseDS) → bool

hasJacobianFgyrOver_velocity(self: siconos.modeling.LagrangianSparseDS) → bool

hasJacobianFintOver_q(self: siconos.modeling.LagrangianSparseDS) → bool

hasJacobianFintOver_velocity(self: siconos.modeling.LagrangianSparseDS) → bool

hasMass(self: siconos.modeling.LagrangianSparseDS) → bool

property jacobianFgyrOver_q_alias

View (shared memory) on the jacobianFgyrOver_q (scipy.sparse.csc_array).

property jacobianFgyrOver_q_view

Read-only view on the jacobianFgyrOver_q (scipy.sparse.csc_array).

property jacobianFgyrOver_velocity_alias

View (shared memory) on the jacobianFgyrOver_velocity (scipy.sparse.csc_array).

property jacobianFgyrOver_velocity_view

Read-only view on the jacobianFgyrOver_velocity (scipy.sparse.csc_array).

property jacobianFintOver_q_alias

View (shared memory) on the jacobianFintOver_q (scipy.sparse.csc_array).

property jacobianFintOver_q_view

Read-only view on the jacobianFintOver_q (scipy.sparse.csc_array).

property jacobianFintOver_velocity_alias

View (shared memory) on the jacobianFintOver_velocity (scipy.sparse.csc_array).

property jacobianFintOver_velocity_view

Read-only view on the jacobianFintOver_velocity (scipy.sparse.csc_array).

property mass_alias

View (shared memory) on the mass (scipy.sparse.csc_array).

property mass_view

Read-only view on the mass (scipy.sparse.csc_array).

q(self: siconos.modeling.LagrangianSparseDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

property q0

current values of the initial state

resetToInitialState(self: siconos.modeling.LagrangianSparseDS) → None

reset the system to the current saved initial state

reset_q0(self: siconos.modeling.LagrangianSparseDS, q0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]']) → None

Reset initial state (q0).

reset_velocity0(self: siconos.modeling.LagrangianSparseDS, v0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]']) → None

Reset initial state (velocity0).

setComputeFextFunction(self: siconos.modeling.LagrangianSparseDS, arg0: collections.abc.Callable) → None

How to compute external forces

setComputeJacobianFgyrOver_qFunction(self: siconos.modeling.LagrangianSparseDS, arg0: collections.abc.Callable) → None

setComputeJacobianFgyrOver_velocityFunction(self: siconos.modeling.LagrangianSparseDS, arg0: collections.abc.Callable) → None

setComputeJacobianFintOver_qFunction(self: siconos.modeling.LagrangianSparseDS, arg0: collections.abc.Callable) → None

setComputeJacobianFintOver_velocityFunction(self: siconos.modeling.LagrangianSparseDS, arg0: collections.abc.Callable) → None

setComputeMassFunction(self: siconos.modeling.LagrangianSparseDS, arg0: collections.abc.Callable) → None

How to compute mass matrix

setConstantFext(*args, **kwargs)

Overloaded function.

1. setConstantFext(self: siconos.modeling.LagrangianSparseDS, fext: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], copy_t: siconos.modeling.copy_t) -> None

Set constant external forces (copy).

2. setConstantFext(self: siconos.modeling.LagrangianSparseDS, fext: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

Set constant external forces (alias).

setConstantJacobianFgyrOver_q(*args, **kwargs)

Overloaded function.

1. setConstantJacobianFgyrOver_q(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.copy_t) -> None

2. setConstantJacobianFgyrOver_q(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.alias_t) -> None

setConstantJacobianFgyrOver_velocity(*args, **kwargs)

Overloaded function.

1. setConstantJacobianFgyrOver_velocity(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.copy_t) -> None

2. setConstantJacobianFgyrOver_velocity(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.alias_t) -> None

setConstantJacobianFintOver_q(*args, **kwargs)

Overloaded function.

1. setConstantJacobianFintOver_q(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.copy_t) -> None

2. setConstantJacobianFintOver_q(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.alias_t) -> None

setConstantJacobianFintOver_velocity(*args, **kwargs)

Overloaded function.

1. setConstantJacobianFintOver_velocity(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.copy_t) -> None

2. setConstantJacobianFintOver_velocity(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.alias_t) -> None

setConstantMass(*args, **kwargs)

Overloaded function.

1. setConstantMass(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.copy_t) -> None

2. setConstantMass(self: siconos.modeling.LagrangianSparseDS, arg0: object, arg1: siconos.modeling.alias_t) -> None

velocity(self: siconos.modeling.LagrangianSparseDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

property velocity0

current values of the initial velocity state

class siconos.modeling.LagrangianSparseLinearTIDS(*args, **kwargs)

Bases: LagrangianSparseDS

Overloaded function.

1. __init__(self: siconos.modeling.LagrangianSparseLinearTIDS, q0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], v0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[m, 1]”], mass: scipy.sparse.csc_matrix[numpy.float64], copy_t: siconos.modeling.copy_t) -> None

   constructor from initial state and mass matrix only. warning: q0, v0, M will be copied into class attributes.

2. __init__(self: siconos.modeling.LagrangianSparseLinearTIDS, q0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], v0: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

constructor from initial state only.

warning: alias (shared memory) between input q0/v0 and internal attributes

property damping_alias

View (shared memory) on the damping (scipy.sparse.csc_array).

property damping_view

Read-only view on the damping matrix (scipy.sparse.csc_array).

setDampingMatrix(*args, **kwargs)

Overloaded function.

1. setDampingMatrix(self: siconos.modeling.LagrangianSparseLinearTIDS, arg0: object, arg1: siconos.modeling.copy_t) -> None

2. setDampingMatrix(self: siconos.modeling.LagrangianSparseLinearTIDS, arg0: object, arg1: siconos.modeling.alias_t) -> None

setStiffnessMatrix(*args, **kwargs)

Overloaded function.

1. setStiffnessMatrix(self: siconos.modeling.LagrangianSparseLinearTIDS, arg0: object, arg1: siconos.modeling.copy_t) -> None

2. setStiffnessMatrix(self: siconos.modeling.LagrangianSparseLinearTIDS, arg0: object, arg1: siconos.modeling.alias_t) -> None

property stiffness_alias

View (shared memory) on the stiffness (scipy.sparse.csc_array).

property stiffness_view

Read-only view on the stiffness matrix (scipy.sparse.csc_array).

class siconos.modeling.NewtonEuler1DR

Bases: NewtonEulerR

distance(self: siconos.modeling.NewtonEuler1DR) → float

distance between contact points 1 and 2, with sign according to normal

class siconos.modeling.NewtonEuler3DR

Bases: NewtonEuler1DR

class siconos.modeling.NewtonEuler5DR

Bases: NewtonEuler1DR

class siconos.modeling.NewtonEulerDS(self: siconos.modeling.NewtonEulerDS, q0: Annotated[numpy.typing.NDArray[numpy.float64], '[7, 1]', 'flags.writeable'], twist0: Annotated[numpy.typing.NDArray[numpy.float64], '[6, 1]', 'flags.writeable'], mass: SupportsFloat | SupportsIndex, inertia: Annotated[numpy.typing.NDArray[numpy.float64], '[3, 3]', 'flags.writeable', 'flags.f_contiguous'], alias_t: siconos.modeling.alias_t)

Bases: SecondOrderDS

angularVelocity(self: siconos.modeling.NewtonEulerDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[3, 1]']

angularVelocityInBodyFrame(self: siconos.modeling.NewtonEulerDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[3, 1]']

computeKineticEnergy(self: siconos.modeling.NewtonEulerDS) → float

fext(self: siconos.modeling.NewtonEulerDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[3, 1]']

current values of external forces

property fint

wrench vector

linearVelocity(self: siconos.modeling.NewtonEulerDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[3, 1]']

q(self: siconos.modeling.NewtonEulerDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

property q0

current values of the initial state

resetToInitialState(self: siconos.modeling.NewtonEulerDS) → None

reset the system to the current saved initial state

reset_q0(self: siconos.modeling.NewtonEulerDS, q0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[7, 1]']) → None

Reset initial state (q0).

reset_twist0(self: siconos.modeling.NewtonEulerDS, v0: Annotated[numpy.typing.ArrayLike, numpy.float64, '[6, 1]']) → None

Reset initial state (twist).

property scalarMass

setComputeFextFunction(self: siconos.modeling.NewtonEulerDS, arg0: collections.abc.Callable) → None

How to compute external forces

setComputeJacobianMintOver_q_byFD(self: siconos.modeling.NewtonEulerDS, arg0: bool) → None

setComputeMextFunction(self: siconos.modeling.NewtonEulerDS, arg0: collections.abc.Callable) → None

How to compute external torques

setConstantFext(*args, **kwargs)

Overloaded function.

1. setConstantFext(self: siconos.modeling.NewtonEulerDS, fext: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[3, 1]”], copy_t: siconos.modeling.copy_t) -> None

Set constant external forces (copy).

2. setConstantFext(self: siconos.modeling.NewtonEulerDS, fext: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[3, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

Set constant external forces (alias).

setConstantMext(*args, **kwargs)

Overloaded function.

1. setConstantMext(self: siconos.modeling.NewtonEulerDS, mext: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, “[3, 1]”], copy_t: siconos.modeling.copy_t) -> None

Set constant external moment (copy).

2. setConstantMext(self: siconos.modeling.NewtonEulerDS, mext: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[3, 1]”, “flags.writeable”], alias_t: siconos.modeling.alias_t) -> None

Set constant external moment (alias).

setIsMextExpressedInInertialFrame(self: siconos.modeling.NewtonEulerDS, arg0: bool) → None

property totalInertiaMatrix

total Inertia matrix

twist(self: siconos.modeling.NewtonEulerDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

property twist0

current values of the initial twist state

class siconos.modeling.NewtonEulerR(self: siconos.modeling.NewtonEulerR)

Bases: Relation

haseVector(self: siconos.modeling.NewtonEulerR) → bool

class siconos.modeling.NewtonImpactFrictionNSL(*args, **kwargs)

Bases: NonSmoothLaw

Overloaded function.

1. __init__(self: siconos.modeling.NewtonImpactFrictionNSL, size: typing.SupportsInt | typing.SupportsIndex = 1) -> None

2. __init__(self: siconos.modeling.NewtonImpactFrictionNSL, en: typing.SupportsFloat | typing.SupportsIndex = 0.0, et: typing.SupportsFloat | typing.SupportsIndex = 0.0, mu: typing.SupportsFloat | typing.SupportsIndex = 0.0, size: typing.SupportsInt | typing.SupportsIndex = 1) -> None

class siconos.modeling.NewtonImpactNSL(*args, **kwargs)

Bases: NonSmoothLaw

Overloaded function.

1. __init__(self: siconos.modeling.NewtonImpactNSL, arg0: typing.SupportsFloat | typing.SupportsIndex) -> None

2. __init__(self: siconos.modeling.NewtonImpactNSL, size: typing.SupportsInt | typing.SupportsIndex = 1, e: typing.SupportsFloat | typing.SupportsIndex = 0.0) -> None

property e

class siconos.modeling.NewtonImpactRollingFrictionNSL(*args, **kwargs)

Bases: NonSmoothLaw

Overloaded function.

1. __init__(self: siconos.modeling.NewtonImpactRollingFrictionNSL, size: typing.SupportsInt | typing.SupportsIndex = 1) -> None

2. __init__(self: siconos.modeling.NewtonImpactRollingFrictionNSL, en: typing.SupportsFloat | typing.SupportsIndex = 0.0, et: typing.SupportsFloat | typing.SupportsIndex = 0.0, mu: typing.SupportsFloat | typing.SupportsIndex = 0.0, muR: typing.SupportsFloat | typing.SupportsIndex = 0.0, size: typing.SupportsInt | typing.SupportsIndex = 1) -> None

class siconos.modeling.NonSmoothDynamicalSystem(self: siconos.modeling.NonSmoothDynamicalSystem, arg0: SupportsFloat | SupportsIndex, arg1: SupportsFloat | SupportsIndex)

Bases: pybind11_object

displayDynamicalSystems(self: siconos.modeling.NonSmoothDynamicalSystem) → None

Print all dynamical systems infos

dynamicalSystem(self: siconos.modeling.NonSmoothDynamicalSystem, arg0: SupportsInt | SupportsIndex) → siconos.modeling.DynamicalSystem

get the Ds number nb

dynamicalSystemsVector(self: siconos.modeling.NonSmoothDynamicalSystem) → list[siconos.modeling.DynamicalSystem]

get the array of all DSs contained in the NonSmoothDynamicalSystem

getNumberOfDS(self: siconos.modeling.NonSmoothDynamicalSystem) → int

get the number of DS contained in the NonSmoothDynamicalSystem

insertDynamicalSystem(self: siconos.modeling.NonSmoothDynamicalSystem, arg0: siconos.modeling.DynamicalSystem) → None

interaction(self: siconos.modeling.NonSmoothDynamicalSystem, inter_id: SupportsInt | SupportsIndex) → siconos.modeling.Interaction

get interaction by id

link(self: siconos.modeling.NonSmoothDynamicalSystem, inter: siconos.modeling.Interaction, ds1: siconos.modeling.DynamicalSystem, ds2: siconos.modeling.DynamicalSystem = None) → None

link an interaction to two dynamical systems

removeDynamicalSystem(self: siconos.modeling.NonSmoothDynamicalSystem, ds: siconos.modeling.DynamicalSystem) → None

remove the Ds

setName(*args, **kwargs)

Overloaded function.

1. setName(self: siconos.modeling.NonSmoothDynamicalSystem, arg0: siconos.modeling.DynamicalSystem, arg1: str) -> None

set DS name

2. setName(self: siconos.modeling.NonSmoothDynamicalSystem, arg0: siconos.modeling.Interaction, arg1: str) -> None

set Interaction name

setTitle(*args, **kwargs)

Overloaded function.

1. setTitle(self: siconos.modeling.NonSmoothDynamicalSystem, arg0: str) -> None

set DS title

2. setTitle(self: siconos.modeling.NonSmoothDynamicalSystem, arg0: str) -> None

topology(self: siconos.modeling.NonSmoothDynamicalSystem) → siconos::simulation::Topology

display the topology of the system

class siconos.modeling.NonSmoothLaw

Bases: pybind11_object

property size

class siconos.modeling.Relation

Bases: pybind11_object

class siconos.modeling.RelayNSL(self: siconos.modeling.RelayNSL, arg0: SupportsInt | SupportsIndex, arg1: SupportsFloat | SupportsIndex, arg2: SupportsFloat | SupportsIndex)

Bases: NonSmoothLaw

class siconos.modeling.SecondOrderDS

Bases: DynamicalSystem

p(self: siconos.modeling.SecondOrderDS, arg0: SupportsInt | SupportsIndex) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

reactionToBoundaryConditions(self: siconos.modeling.SecondOrderDS) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']

setBoundaryConditions(self: siconos.modeling.SecondOrderDS, arg0: siconos::modeling::BoundaryCondition) → None

siconos.modeling.interactions(graph: siconos::graphs::InteractionsGraph) → list[siconos.modeling.Interaction]

Return a list of Interaction objects from an InteractionsGraph