NodePoint

A 3D point node for point masses or solid finite elements which has 3 displacement degrees of freedom for ODE2.

Interface

Python names: NodePoint or Point, and VPoint for its visualization
Provides: Position
Node markers that can be attached: MarkerNodePosition
Objects that take this node: ObjectMassPoint

Parameters

The parameters of the item; in a dictionary, its type is ‘Point’:

name	type	size	default	description
name	String		‘’	node’s unique name
referenceCoordinates	Vector3D	3	[0.,0.,0.]	(symbol: \(\qv\cRef = [q_0,\,q_1,\,q_2]\tp\cRef = \pv\cRef = [r_0,\,r_1,\,r_2]\tp\)) reference coordinates of node, e.g. ref. coordinates for finite elements; global position of node without displacement
initialCoordinates	Vector3D	3	[0.,0.,0.]	(symbol: \(\qv\cIni = [q_0,\,q_1,\,q_2]\cIni\tp = \uv\cIni = [u_0,\,u_1,\,u_2]\cIni\tp\)) initial displacement coordinate
initialVelocities	Vector3D	3	[0.,0.,0.]	(symbol: \(\dot\qv\cIni = \vv\cIni = [\dot q_0,\,\dot q_1,\,\dot q_2]\cIni\tp\)) initial velocity coordinate
visualization	VNodePoint			parameters for visualization of item

Visualization parameters

The parameters of VNodePoint, given as visualization:

name	type	size	default	description
show	Bool		True	set true, if item is shown in visualization and false if it is not shown
drawSize	float		-1.	drawing size (diameter, dimensions of underlying cube, etc.) for item; size == -1.f means that default size is used
color	Float4	4	[-1.,-1.,-1.,-1.]	Default RGBA color for nodes; 4th value is alpha-transparency; R=-1.f means, that default color is used

Drawing

Drawn as all nodes.

Output variables

Available as OutputVariableType in sensors, Get...Output() and other functions:

output variable	symbol	description
Position	\(\pv\cConfig = [p_0,\,p_1,\,p_2]\cConfig\tp= \uv\cConfig + \pv\cRef\)	global 3D position vector of node; \(\uv\cRef=0\)
Displacement	\(\uv\cConfig = [q_0,\,q_1,\,q_2]\cConfig\tp\)	global 3D displacement vector of node
Velocity	\(\vv\cConfig = [\dot q_0,\,\dot q_1,\,\dot q_2]\cConfig\tp\)	global 3D velocity vector of node
Acceleration	\(\av\cConfig = \ddot \qv\cConfig = [\ddot q_0,\,\ddot q_1,\,\ddot q_2]\cConfig\tp\)	global 3D acceleration vector of node
CoordinatesTotal	\(\cv\cConfig = \uv\cConfig + \pv\cRef\)	displacement plus reference coordinates of node
Coordinates	\(\cv\cConfig = \uv\cConfig = [q_0,\,q_1,\,q_2]\tp\cConfig\)	coordinate vector of node
Coordinates_t	\(\dot\cv\cConfig = \vv\cConfig = [\dot q_0,\,\dot q_1,\,\dot q_2]\tp\cConfig\)	velocity coordinates vector of node
Coordinates_tt	\(\ddot\cv\cConfig = \av\cConfig = [\ddot q_0,\,\ddot q_1,\,\ddot q_2]\tp\cConfig\)	acceleration coordinates vector of node
RotationMatrix		identity matrix (only for completeness)
Rotation	\([0,0,0]\)	(only for completeness)
AngularVelocity	\([0,0,0]\)	(only for completeness)
AngularVelocityLocal	\([0,0,0]\)	(only for completeness)

Detailed description

Coordinates

index	symbol	kind	meaning	frame
0, 1, 2	\(q_0,\,q_1,\,q_2\)	ODE2	displacement of the node in \(x\), \(y\) and \(z\)	the frame of the object, usually global

Configuration

In any configuration, the position of the node is its reference position plus its displacement,

\[ \pv\cConfig = \pv\cRef + \uv\cConfig, \quad \uv\cConfig = [q_0,\,q_1,\,q_2]\cConfig\tp . \]

The coordinates are the displacements themselves, and their time derivatives are the velocity and the acceleration of the node.

Frame and interpretation

The node defines no frame; the object that uses it does. ObjectMassPoint reads the coordinates in the global frame. ObjectFFRF uses points as the nodes of its finite element mesh and reads their coordinates in the frame of its rigid body node (node 0): there, the global position of a mesh node follows from the object, not from the node alone.

Action on the equations of motion

The three coordinates lead to three ODE2 equations, which the object provides; for ObjectMassPoint they are the residuals of the forces in the global frame. A force \(\fv\) acting on the node through MarkerNodePosition enters them with the position Jacobian \(\partial \pv / \partial \qv = \ImThree\), that is, as it is.

Example: see ObjectMassPoint

Mini example

#a point mass moving freely: reference position, initial displacement and initial velocity
node = mbs.AddNode(NodePoint(referenceCoordinates=[1,0,0],
                             initialCoordinates=[0,0.5,0],   #displacement from the reference
                             initialVelocities=[2,0,0]))
mbs.AddObject(ObjectMassPoint(nodeNumber=node, mass=1))

mbs.Assemble()
mbs.SolveDynamic() #default: 1 second

#position = reference + displacement: [1+0+2*1, 0.5, 0]
exu.sys['testResult'] = sum(mbs.GetNodeOutput(node, exu.OutputVariableType.Position)) #3.5

Examples (Ex) and TestModels (TM) that show this item, with weblink to github: basicTutorial2024.py (Ex), tutorialSpringDamper.py (Ex), tutorialSpringDamperCreate.py (Ex), cartesianSpringDamper.py (Ex), coordinateSpringDamper.py (Ex)