HOTINT Intensivkurs

HOTINT Intensivkurs
Chief Developer:
Johannes Gerstmayr
Program Manager:
Daniel Reischl
Core Developers:
GUI, Interfaces, IO:
FE, Solver:
MBS, Modal Reduction, FE:
Mechatronic Systems:
TCP/IP, FSI:
Testing, Software Architecture:
Alexander Dorninger
Peter Gruber
Alexander Humer
Daniel Reischl
Markus Schörgenhumer
Simon Weitzhofer
AD, JG, PG, AH, SW
HOTINT Kurs
1/2
HOTINT Intensivkurs
Agenda und geplanter Ablauf
09:00 – 10:00: Installation von HOTINT auf den Rechnern der
Teilnehmer
10:00 – 10:45: Begrüßung und Einführung in HOTINT; Übersicht
und Vorstellung der wichtigsten Features
10:45 – 11:30: HOTINT Skript-Sprache
11:30 – 12:00: Bedienung und GUI von HOTINT
12:00 – 13:00: Mittagspause
13:00 – 13:30: HOTINT Solver & Einstellungen
13:30 – 14:15: Beispiel 1: 2-Massenschwinger & Parametervariation
14:15 – 15:00: Beispiel 2: Rotordynamik
15:00 – 15:30: Kaffeepause
15:30 – 16:30: HOTINT C++: Struktur von Elementen & Beispiele
(Platten, Fluid-Struktur Interaktion)
AD, JG, PG, AH, SW
HOTINT Kurs
2/2
HOTINT Intensivkurs: Skriptsprache
Chief Developer:
Johannes Gerstmayr
Program Manager:
Daniel Reischl
Core Developers:
GUI, Interfaces, IO:
FE, Solver:
MBS, Modal Reduction, FE:
Mechatronic Systems:
TCP/IP, FSI:
Testing, Software Architecture:
Alexander Dorninger
Peter Gruber
Alexander Humer
Daniel Reischl
Markus Schörgenhumer
Simon Weitzhofer
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
1 / 38
HOTINT Skriptsprache
Überblick
1 HOTINT Skriptsprache: Einführung
2 Daten, Datenstrukturen, Operationen, Funktionen, ...
3 Erstellen von Elementen und Knoten
4 Hinzufügen eines Verbindungselements
5 Aufbringen von Lasten
6 Hinzufügen von Sensoren
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
2 / 38
HOTINT Skriptsprache: Einführung
HOTINT verfügt über Skript-Parser zur parametrischen Erstellung
von Simulationsmodellen (Dateierweiterung *.hid)
Features der Skript Sprache
• Möglichst simple und intuitive Modellierungssprache
• Definition von Variablen und Datenstrukturen
• Mathematische Operatoren und Funktionen
• Bedingungen und Schleifen (if, for)
• Funktionen zum Hinzufügen von Elementen, Lasten, Sensoren, ...
• Ausblick: Skript-gesteuerte Simulation
Notepad++ Plugin für Syntax-Highlighting und Auto-Completion ist
Bestandteil der Freeware-Version
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
3 / 38
Variablen und Datenstrukturen
Struktur, Kommentare und einfache Variablen
• Textfiles werden zeilenweise geparst; Semikolon (;) nicht nötig
• Zuweisungen mittels linke Seite = rechte Seite
• Zulässige Bezeichner: alphanumerische Zeichen & underscore ( )
• Implizite Variablen-Deklaration
• Kommentare beginnen mit Prozentzeichen (%)
% Beispiel einer einfachen Variablen-Definition
a = 3.0
% Zuweisung eines double Wertes
b = a
% b hat jetzt den Wert 3.0
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
4 / 38
Variablen und Datenstrukturen
Daten-Container
• Daten-Anordnung in Baum-Strukturen
• Beginn und Ende mit geschwungenen
Klammern ({,})
• Zugriff mittels “.”-Operator
• Schachtelung möglich
• Zuweisung ganzer Container erlaubt
Elemente werden mittels Daten-Container
initialisiert
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
mat
{
steel
{
E = 2.1e11
nu = 0.3
}
alu
{
E = 7e10
nu = 0.34
}
}
my_mat = mat.steel
my_E = mat.steel.E
5 / 38
Variablen und Datenstrukturen
Mögliche Datentypen:
bool = yes
integer = 1
float = 0.628e1
string = "text"
vector = [1.,2.,3.,4.]
matrix = [1.1,1.2;2.1,2.2]
%
%
%
%
%
%
%
boolean can be ’yes’ or ’no’
integer
floating point (double)
string
vector, with ’,’ as separator
matrix, with ’,’ and ’;’ as
separators
Initialisieren leerer Matrizen und Vektoren:
matrix = zeros(4,2)
vector = zeros(3,1)
% number of colums is required!
Zugriff auf Vektor- und Matrix-Komponenten:
a = vector[2]
matrix[3,1] = 3.1412
% als lvalue erlaubt!
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
6 / 38
Operatoren und Funktionen
Skalare Operatoren und Funktionen
• Binäre Operatoren: +,-,*,/,^,>,<,>=,<=,==,!=
• Potenzen und Wurzeln: sqr(), sqrt()
• Trigonometrische und Hyperbel-Funktionen: sin(), cos(),
tan(), asin(), acos(), atan(), sinh(), cosh(), tanh()
• Exponentialfunktion und Logarithmen: exp(), ln(), log(),
log10()
• weitere Funktionen: fact(), abs(), fabs(), round(),
floor(), ceil(), heaviside(), sgn()
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
7 / 38
Operatoren und Funktionen
Vektor-Operatoren und Funktionen
• Addition und Subtraktion: +,- oder Sum(vec1,vec2)
• Multiplikation mit Skalar: Product(vector,scalar) oder
Product(scalar,vector)
• Skalarprodukt:
Product(vec1,vec2)
• Kreuzprodukt:
CrossProduct(vec1,vec2)
• Norm eines Vektors: vabs(vector)
Matrix-Operatoren und Funktionen
• Addition und Subtraktion: +,- oder Sum(mat1,mat2)
• Multiplikation mit Skalar: Product(matrix,scalar) oder
Product(scalar,matrix)
• Matrizenprodukt:
Product(mat1,mat2)
auf Vektoren und Matrizen anwendbar:
Transpose(matrix), rows(vector), cols(matrix)
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
8 / 38
Bedingungen und Schleifen
Skriptsprache verfügt über folgenden Kontrollstrukturen:
if – Bedingung
• kein Leerzeichen zwischen if und (bedingung) erlaubt
• kein else if oder else möglich
if(bedingung)
{
% Anweisungen
}
for – Schleife
• Inkrement- und Dekrement-Operatoren (++,--) existieren nicht!
for(start,bedingung,weiter)
{
% Anweisungen
}
AD, JG, PG, AH, SW
% kein Leerzeichen nach for!
HOTINT Intensivkurs: Skriptsprache
9 / 38
weitere Funktionen (Auswahl)
• Include(filename): Inkludiert ein Skript-file; Parameter ist
absoluter oder relativer Pfad zur einzubindenden Datei
• Print(string), Print(variable), Print(tree): Schreibt
String, Variable oder ganzen Baum ins Ausgabefenster
• LoadVectorFromFile(filename, column): Liest einen Vektor
aus einem Textfile (absoluter oder relativer Pfad); column
bezeichnet die zu lesende Spalte der Textdatei; z.B.:
sol = LoadVectorFromFile("solution.txt",2)
• ReadSTLFile(filename): Liest ein STL-Netz aus Datei und gibt
einen Container mit Punkten und Dreiecken zurück; z.B.:
STL = ReadSTLFile("mesh.stl")
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
10 / 38
Hinzufügen von Elementen
Elemente werden mittels des Befehls AddElement(elemData) zum
System hinzugefügt.
Parameter: Als Parameter wird ein Element Daten Container
übergeben, der das Element beschreibt. Abgesehen vom Eintrag
element type, der existieren muss, werden Defaultwerte verwendet,
falls Einträge nicht überschrieben werden.
Rückgabewert: Nummer des Elementes im MBS.
myMass3D
{
element_type = "Mass3D"
% muss gesetzt werden!
Physics.mass = 1
Initialization.initial_position = [1.,0,0] % Anfangsposition
}
nElement = AddElement(myMass3D)
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
11 / 38
Hinzufügen von Elementen
Auswahl verfügbarer Elemente:
• Mass1D, Mass2D, Mass3D: Massenpunkt mit 1–3 Freiheitsgraden
• Rigid2D, Rigid3D, Rigid3DKardan: Starrkörper in 2D und 3D
• LinearBeam3D, ANCFBeam3DTorsion: 3D Bernoulli-Euler Balken
(kein Schub) für kleine bzw. große Deformationen
• ANCFBeamShear3DLinear, ANCFBeamShear3DQuadratic: 3D
Timoshenko-Balken für große Deformationen (lineare bzw.
quadratische Ansatzfunktionen)
• RotorBeamXAxis: Balken-Element für große Rotationen um
(lokale) x-Achse; speziell für Rotordynamik-Anwendungen
• NodalDiskMass3D: Scheibenelement für RotordynamikAnwendungen in Verbindung mit RotorBeamXAxis
in zukünftigem Release: ANCFCable2D, ANCFThinPlate3D,
ANCFBeamShearFE2DLinear/Quadratic
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
12 / 38
Hinzufügen von Elementen
Typischer Element-Daten Aufbau
element_root
{
... % grundlegende Eigenschaften wie element_type, name, ...
Graphics
{
% Darstellungsoptionen (Farbe, Größe, ...)
}
Initialization
{
% Anfangswerte der Element-Freiheitsgrade
}
Physics
{
% physikalische Eigenschaften (Masse, Material, ...)
}
Geometry
{
% Elementgröße, Knotennummern, ...
}
}
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
13 / 38
Hinzufügen von Elementen
Standard Einträge der Elemente:
element root
• element type: legt das zu erstellende Element fest
• name: frei wählbarer Name; erleichtert Editieren im GUI
• loads: Vektor mit Nummern der aufzubringenden Lasten
element root.Graphics
• RGB color: Farbe des Elements (RGB-Werte 0..1)
• use alternative shape: alternative Darstellung des Elements
• geom elements: Vektor mit GeomElements zur alt. Darstellung
• show element: soll Element gezeichnet werden?
Element-spezifische Einstellungen → siehe Dokumentation!
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
14 / 38
Hinzufügen von Elementen
Beispiel Rigid3DKardan: beschreibt räumliche Bewegung eines
Starrkörpers; Rotationsparametrisierung mit 3 Winkeln (Singularität!)
%%% Beispiel Rigid3DKardan
% Abmessungen und Dichte des Körpers
lx = 0.4
ly = 0.1
lz = 0.2
rho = 7850
myRigid3D
{
element_type = "Rigid3DKardan"
name = "myRigid3D"
Graphics
{
body_dimensions = [lx, ly, lz]
}
...
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
15 / 38
Hinzufügen von Elementen
...
Physics
{
volume = lx*ly*lz
mass = rho*volume
moment_of_inertia = [ mass*(ly*ly+lz*lz)/12, 0., 0.
0., mass(lx*lx+lz*lz)/12, 0.
0., 0., mass(ly*ly+lz*lz)/12 ]
}
Initialization
{
initial_position = [0., 0., 1.]
% pos_X, pos_Y, pos_Z
initial_velocity = [0., 0., 0.]
% vel_X, vel_Y, vel_Z
initial_rotation = [0., pi/4, pi/4]
% rot3_X, rot2_Y, rot1_Z
initial_angular_velocity = [2*pi, 0., 0.] % in global coords
}
}
nRigidElem = AddElement(myRigid3D)
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
16 / 38
Hinzufügen von Elementen
Finite Elemente sind im Gegensatz zu Starrkörpern Knoten-basiert
1 Knoten erstellen und initialisieren
2 Geometrie und Materialeigenschaften definieren
3 Finite Elemente mit jeweiligen Knoten und Material erstellen
Unterschiedliche DOFs → unterschiedliche Knotentypen!
• Node3DRxyz: 3 Verschiebungen + 3 Winkel bzgl. globalem
Koordinatensystem; für LinearBeam3D
• Node3DR123: 3 Verschiebungen + 3 Winkel bzgl. lokalem
Koordinatensystem; für RotorBeamXAxis
• Node3DS2S3: 3 Verschiebungen + 2 Vektoren im Querschnitt; für
ANCFBeamShear3DLinear / ANCFBeamShear3DQuadratic
• Node3DS1rot1: 3 Verschiebungen + 1 Tangentialvektor +
1 Winkel; für ANCFBeam3DTorsion
Mesh-Generator zur einfachen Erstellung & Geometrie-Import möglich!
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
17 / 38
Hinzufügen von Elementen
Beispiel LinearBeam3D: Auszug aus Dokumentation
3.2.9
LinearBeam3D
Short description
The Beam3D element is a three dimensional elastic beam element which is aligned along the local x axis. It provides a decoupled calculation of bending in y and z direction, axial deformation
in x direction and torsion about the x axis. Shear deformation is not considered. The decoupled
calculation is a simplification of the real, nonlinear problem, but for small deformations the
results coincidence highly with the exact solution.
Degrees of freedom
Bending is described by 4 DOF, the number of DOF for axial deformation as well as torsion is
2. These 12 DOF are stored in two nodes i and j. The DOF vector of the LinearBeam3D read
as follows
(i)
(i)
(j) (j) (j)
(j)
(j)
(j) T
q(i) = [q(i) , q(j) ] = [x(i) , y (i) , z (i) , φ(i)
x , φy , φz , x , y , z , φ x , φ y , φ z ] .
(3.7)
Nodes
To create a new beam element the user has to define two ’Node3DRxyz’ nodes i and j. Every
node of this type has 6 DOF. The first 3 DOF describe the node displacement (x, y, z) w.r.t
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
18 / 38
Hinzufügen von Elementen
1 Knoten erstellen und initialisieren: 2 Knoten vom Typ Node3DRxyz
Data objects of Node3DRxyz:
Data name
node type
type
string
name
node number
Geometry
Geometry.
reference position
Geometry.
reference rot angles
Initialization
Initialization.
node initial values
Graphics
Graphics.RGB color
Graphics.visible
string
integer
”Node3DRxyz”
1
description
specification of node type. Once the node is
added to the mbs, you MUST NOT change this
type anymore!
Node identifier.
Node Number.
vector
[0, 0, 0]
Position (2D/3D) in reference configuration.
vector
[0, 0, 0]
Kardan rotation angles (X,Y,Z) in rad in global
frame of node in reference configuration.
vector
[0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0]
initial values for all degrees of freedom of node
[0.4, 0.4, 0.1]
1
[red, green, blue] color of element, range = 0..1,
Visibility of node.
vector
integer
R
default
”Node3DRxyz”
Knoten werden mit dem Befehl AddNode(nodeData) zum System
hinzugefügt.
Rückgabewert: Nummer des Knoten im MBS
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
19 / 38
Hinzufügen von Elementen
Anlegen der Knoten:
lx = 1
% Länge des Balkenelements
node1
{
node_type = "Node3DRxyz"
name = "Node1"
node2
{
node_type = "Node3DRxyz"
name = "Node2"
Geometry
{
reference_position = [0.,0.,0.]
reference_rot_angles= [0.,-pi/2,0.]
}
}
nNode1 = AddNode(node1)
AD, JG, PG, AH, SW
Geometry
{
reference_position = [0.,0.,lx]
reference_rot_angles= [0.,-pi/2,0.]
}
}
nNode2 = AddNode(node2)
HOTINT Intensivkurs: Skriptsprache
20 / 38
Hinzufügen von Elementen
2 Geometrie und Materialeigenschaften definieren: werden mittels
Beam3DProperties bzw. Beam2DProperties festgelegt und durch
AddMaterial(materialData) dem System hinzugefügt.
ly = 0.01
lz = 0.05
Em = 2.1e11
rho = 7850
% E-Modul
% Dichte
myBeamProperties
{
material_type = "Beam3DProperties"
cross_section_type = 1
% 1... rectangular, 2... circular
cross_section_size = [ly, lz] % Querschnittsabmessungen
EA = Em * ly*lz
EIy = Em * ly*lz*lz*lz / 12
EIz = Em * lz*ly*ly*ly / 12
GJkx = Em/2 * lz*ly*ly*ly / 3
density = rho
% Biegesteifigkeit um y-Achse
% Biegesteifigkeit um z-Achse
% Drillwiderstand für schmale Rechtecke
}
nBeamProperties = AddBeamProperties(myBeamProperties)
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
21 / 38
Hinzufügen von Elementen
3 LinearBeam3D erstellen: Auszug aus Dokumentation
Data objects of LinearBeam3D:
Data name
element type
type
string
name
element number
loads
string
integer
vector
Graphics
Graphics.RGB color
vector
[0.1, 0.1, 0.8]
Graphics.geom elements
vector
[]
Graphics.
use alternative shape
Graphics.show element
Geometry
Geometry.node 1
Geometry.node 2
Physics
Physics.axial deformation
Physics.material number
bool
0
bool
1
[red, green, blue] color of element, range = 0..1,
use default color:[-1,-1,-1]
Set Geometric elements to represent body ’geomelem1, geomelem2, ...’ or empty
Graphical representation of element with geomobjects that are attached to the element
Flag to draw element
integer
integer
1
2
number of Node 1
number of Node 2
bool
integer
1
1
include effect of axial deformation
material number which contains the main material properties of the beam
AD, JG, PG, AH, SW
R
R
default
description
”LinearBeam3D” specification of element type. Once the element
is added to the mbs, you MUST NOT change this
type anymore!
”LinearBeam3D” name of the element
1
number of the element in the mbs
[]
Set loads attached to this element: ’nr load1,
nr load2, ...’ or empty
HOTINT Intensivkurs: Skriptsprache
22 / 38
Hinzufügen von Elementen
myBeam
{
element_type = "LinearBeam3D"
name = "myBeam"
Geometry
{
node_1 = nNode1
% Nummer des 1. Knoten
node_2 = nNode2
% Nummer des 2. Knoten
}
Physics.material_number = nBeamProperties
}
nBeamElement = AddElement(myBeam)
Knoten und Elemente in for-Schleifen erstellen:
for(i=1,i<=nelems,i=i+1)
{
myBeam.Geometry.node_1 = i
myBeam.Geometry.node_2 = i+1
AddElement(myBeam)
}
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
23 / 38
Hinzufügen von Verbindungselementen
Elemente können in HOTINT über eine Vielzahl von Gelenken und
Verbindungselementen (engl. kinematic pairs) gekoppelt werden.
Verbindungselementen werden mit AddConnector(constraintData)
zum System hinzugefügt.
Rückgabewert: Nummer des Connectors im MBS
Zwei “typische” Verbindungsmöglichkeiten
1 Element-zu-Element: lokale Position oder Knoten eines Elements
zu lokaler Position oder Knoten des zweiten Elements
2 Element-zu-Ground: lokale Position oder Knoten eines Elements
zu globaler Position
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
24 / 38
Hinzufügen von Verbindungselementen
Auswahl verfügbarer Gelenke:
•
•
•
•
•
•
•
•
PointJoint
RevoluteJoint
PrismaticJoint
CylindricalJoint
UniversalJoint
RigidJoint
RigidLink
GenericBodyJoint
•
•
•
•
•
•
•
•
•
CoordinateConstraint
VelocityCoordinateConstraint
SlidingPointJoint
SlidingPrismaticJoint
SpringDamperActuator
RotarySpringDamperActuator
Rope3D
Contact1D
FrictionConstraint
in zukünftigem Release: RollingJoint3D, MultiNodalConstraint,
AverageConstraint, ...
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
25 / 38
Hinzufügen von Verbindungselementen
Die (meisten) Verbindungselemente unterscheiden zwei Modi:
Harte vs. weiche Constraints
• Harte Constraints: realisiert mittels algebraischer Gleichungen
und Lagrange-Multiplikatoren → führt auf DAEs; kinematische
Zwangsbedingungen werden exakt erfüllt
• Weiche Constraints: Penalty-Formulierung basierend auf
Ersatz-Steifigkeiten und Dämpfungsparametern → keine
zusätzlichen Gleichungen, jedoch evtl. schlechte Konditionierung;
ermöglicht Abbildung realer Gelenkseigenschaften
Automatische Konsistenzprüfung: Elemente und Gelenke wissen“ um
”
ihre Kopplungsmöglichkeiten (→ Dokumentation)
Eigenwertanalyse momentan nur mit Penalty-Formulierung möglich!
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
26 / 38
Hinzufügen von Verbindungselementen
Beispiel PointJoint: verbindet zwei Elemente an einer Positionen
oder Knoten bzw. fixiert ein Element an globalem Punkt (ground).
Data objects of PointJoint:
Data name
element type
type
string
name
element number
Graphics
Graphics.RGB color
string
integer
vector
[0.3, 0.8, 0.3]
Graphics.show connector
Graphics.draw size
bool
double
1
-1
Graphics.
double
draw size joint local frame
Geometry
Geometry.
use joint local frame
Geometry.
joint local frame
R
default
”PointJoint”
”PointJoint”
2
0
bool
0
matrix
[0, 0, 0; 0, 0, 0;
0, 0, 0]
Geometry.
bool
use local coordinate system
AD, JG, PG, AH, SW
R
0
description
specification of element type. Once the element
is added to the mbs, you MUST NOT change this
type anymore!
name of the element
number of the element in the mbs
[red, green, blue] color of element, range = 0..1,
use default color:[-1,-1,-1]
Flag to draw connector
drawing dimensions of constraint. If set to -1,
than global draw scalar size is used.
drawing dimensions of joint local frame. If set to
-1, than global draw scalar size is used. If set to
0, than no joint local frame is drawn.
Use a special joint local frame
Prerotate stiffness vector w.r.t. global coordinate
system or local coordinate system of body 1. Just
used if use joint local frame == 1
0=use global coordinates, 1=use local coordinate
system of Body 1
HOTINT Intensivkurs: Skriptsprache
27 / 38
Hinzufügen von Verbindungselementen
Physics
Physics.
use penalty formulation
bool
0
0 = use lagrange multipliers (index 3 DAE, exact), 1 = use penalty formulation (no additional
equation added, approximate constraint)
double
0
general or penalty stiffness parameter
vector
[0, 0, 0]
double
0
penalty stiffness parameter [kx,ky,kz].
Just
used if scalar spring stiffness == 0, otherwise
kx=ky=kz=spring stiffness
damping coefficient for viscous damping (F =
d*v), applied in all constrained directions
vector
[1, 1, 1]
[x,y,z]...(1 = constrained, 0 = free), can be defined
as local or global directions (see Geometry)
integer
vector
integer
1
[0, 0, 0]
0
Number of constrained element
local position. Only used if node number == 0!
local or global (if element number == 0) node
number.
Position2
Position2.element number
Position2.position
integer
vector
0
[0, 0, 0]
Position2.node number
integer
0
Number of constrained element
local or global (if element number == 0) position.
Only used if node number == 0!
local or global (if element number == 0) node
number.
Physics.Penalty
Physics.Penalty.
spring stiffness
Physics.Penalty.
spring stiffness vector
Physics.Penalty.damping
Physics.Lagrange
Physics.Lagrange.
constrained directions
Position1
Position1.element number
Position1.position
Position1.node number
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
28 / 38
Hinzufügen von Verbindungselementen
myPointJoint
{
element_type = "PointJoint"
name = "myPointJoint"
Physics
{
use_penalty_formulation = 1
Penalty.spring_stiffness = 1e3
%
}
Position1
{
element_number = nBeamElement
%
node_number = 1
%
}
Position2
{
element_number = 0
%
position = [0.,0.,0.]
%
}
}
nPointJoint = AddConnector(myPointJoint)
AD, JG, PG, AH, SW
Gelenksteifigkeit kg/s^2
Elementnummer
lokale Knotennummer
0 = ground
globale Position
HOTINT Intensivkurs: Skriptsprache
29 / 38
Hinzufügen von Verbindungselementen
Beispiel RigidJoint: realisiert starre Verbindung des Starrkörpers
mit dem Balkenelement.
myRigidJoint
{
element_type = "RigidJoint"
name = "myRigidJoint"
Position1
{
element_number = nRigidElement
position = [0.,0.,0.]
}
Position2
{
element_number = nBeamElement
position = [lx/2,0.,0.]
}
% Schwerpunkt des Starrkörpers
% Ende des Balkenelements
}
nRigidJoint = AddConnector(myRigidJoint)
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
30 / 38
Aufbringen von Lasten
HOTINT erlaubt das Aufbringen vielfältiger Typen von Belastungen
mittels des Befehls AddLoad(loadData).
Rückgabewert: Nummer der Load im MBS
Lasten müssen bereits beim Erstellen der Elemente festgelegt sein:
elemData.loads = [load1, load2, load3, ...]
Verfügbare Lasten:
• GCLoad: Last auf eine generalisierte Koordinate
• ForceVector2D/3D: Kraftvektor auf lokalen Punkt oder Knoten
• MomentVector3D: Momentenvektor in lokalen Punkt oder Knoten
• BodyLoad: verteilte Volumenkraft; wird über Körper integriert
• Gravity: wie BodyLoad; Dichte wird zur Berechnung verwendet
• SurfacePressure: verteilte Kraft normal auf Körperoberfläche
in zukünftigem Release: RotatingForce, CentrifugalForce,
SurfaceLoad, DistributedMoment
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
31 / 38
Aufbringen von Lasten
Zeitlicher Verlauf der Kräfte und Momente
• konstanter Wert
• MathFunction: erlaubt Ausdrücke wie in Skriptsprache sowie
Interpolation von Punkten
• IOElement: freie Veränderung der Werte durch IOElemente
MathFunction
MathFunction.
piecewise mode
MathFunction.
piecewise points
MathFunction.
piecewise values
MathFunction.
piecewise diff values
MathFunction.
parsed function
MathFunction.
parsed function parameter
IOElement
IOElement.
input element number
IOElement.
input local number
AD, JG, PG, AH, SW
integer
-1
modus for piecewise interpolation: -1=not piecewise, 0=constant, 1=linear, 2=quadratic
supporting points (e.g. time or place) for piecewise interpolation
values at supporting points
vector
[]
vector
[]
vector
[]
string
””
string
””
integer
0
number of IOElement in the mbs
integer
0
number of output of IOElement connected to this
element
differential values at supporting points - for
quadratic interpolation
string representing parsed function,
e.g.
’A*sin(omega*t)’
string representing parameter of parsed function,
e.g. ’t’
HOTINT Intensivkurs: Skriptsprache
32 / 38
Aufbringen von Lasten
Beispiel BodyLoad: harmonische Volumenkraft in z-Richtung
force = 100.
omega = 1.5
myBodyLoad
{
load_type = "BodyLoad"
direction = 2
load_value = force
load_function_type = 1
% Volumenkraft in z-Richtung
% 1.. MathFunction, 2.. IOElement
MathFunction
{
parsed_function = "sin(omega*t)"
parsed_function_parameter = "t"
}
% Ergebnis: val*sin(omega*t)
% unabhängige Variable
}
nLoad = AddLoad(myBodyLoad)
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
33 / 38
Hinzufügen von Sensoren
Neben der 3D-Visualisierung nehmen Sensoren eine wesentliche Rolle
im Auswerten der Lösung ein.
Funktionalität der Sensoren
• Sensoren messen“ den Verlauf gesuchter Größen des mecha”
tronischen Systems während der Simulation
• Online-Darstellung der Größen im PlotTool
• Speichern der Größen in Ausgabe-Dateien
• Eingangsgrößen für IOElemente zur Parametervariation,
Optimierung, Regelung, etc.
Sensoren werden mit AddSensor(sensorData) erstellt. Elemente
müssen beim Erstellen der Sensoren bereits existieren.
Rückgabewert: Nummer des Sensors im MBS
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
34 / 38
Hinzufügen von Sensoren
Verfügbare Sensoren:
• FVElementSensor: speichert eine Feldgröße (field variable) an
lokaler Position oder Knoten eines Elements (Verschiebung,
Winkel, Geschwindigkeit, Spannungskomponenten, ...)
→ Observable FieldVariables in Dokumentation
• ElementSensor: speichert Element-spezifische Größen (Kräfte
im Gelenk, ...) → Observable special values in Dokumentation
• MultipleSensor: wendet mathematische Operationen (sum,
average, minimum, maximum) auf eine Liste von Sensoren an
• LoadSensor: momentaner Wert der MathFunction einer Last
• SystemSensor: speichert spezielle Werte des Systems bzw. des
Solvers (DOF, EV, jacobians, newton iterations, ...)
→ siehe Dokumentation
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
35 / 38
Hinzufügen von Sensoren
Beispiel FVElementSensor: Misst gewünschte Feldgröße eines
Elements an lokaler Position oder Elementknoten
Data objects of FVElementSensor:
Data name
sensor number
name
type
integer
string
sensor type
string
element number
integer
node number
integer
local position
vector
field variable
string
component
string
AD, JG, PG, AH, SW
R
R
default
1
”sensor”
description
number of the sensor in the mbs
name of the sensor for the output files and for the
plot tool
”FVElementSensor”
specification of sensor type. Once the sensor is
added to the mbs, you MUST NOT change this
type anymore!
1
number of the element, to which the sensor is
applied
0
local node number. If ¿ 0, then the position of
this node is used.
[0, 0, 0]
local position at which the field variable is evaluated.
”position”
name of the field variable, e.g. ’position’, see the
documentation of the elements for the available
field variables
”x”
component of the field variable, e.g. ’x’
HOTINT Intensivkurs: Skriptsprache
36 / 38
Hinzufügen von Sensoren
myFVSensor
{
sensor_type = "FVElementSensor"
name = "tip displacement"
element_number = nBeamElement
local_position = [lx/2.,0.,0.]
field_variable = "displacement"
component = "x"
}
nFVSensor = AddSensor(myFVSensor)
AD, JG, PG, AH, SW
%
%
%
%
Nummer des Balkenelements
lokale Position
Verschiebung ist Messgröße
x-Komponente
HOTINT Intensivkurs: Skriptsprache
37 / 38
Ausblick
Zukünftige Features der Skriptsprache
• Skriptsprachen-gesteuerte Simulation, Post-Processing, ...
• Integration der Mesh-Funktionalität: FE-Mesh & Struktur-Mesh
• Vollständige Abbildung des Workflows zur Simulation modal
reduzierter Mehrkörpersysteme in der Skriptsprache
• Verfügbarkeit weiterer Elemente: Solid-FE, Schalen, ...
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Skriptsprache
38 / 38
HOTINT Intensivkurs: Solver-Options
Chief Developer:
Johannes Gerstmayr
Program Manager:
Daniel Reischl
Core Developers:
GUI, Interfaces, IO:
FE, Solver:
MBS, Modal Reduction, FE:
Mechatronic Systems:
TCP/IP, FSI:
Testing, Software Architecture:
Alexander Dorninger
Peter Gruber
Alexander Humer
Daniel Reischl
Markus Schörgenhumer
Simon Weitzhofer
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
1 / 10
Übersicht
1 Übersicht Berechnungsmodi
2 Dynamische Simulation
3 Statische Rechnung
4 Eigenwertanalyse
5 Newton Solver
6 Lineare Gleichungssysteme
7 Beispiel: Kragbalken
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
2 / 10
Übersicht Berechnungsmodi
HOTINT Solver unterscheidet 3 unterschiedliche Berechnungsmodi:
• Dynamische Simulation: transiente Analyse mechatronischer
Mehrkörpersysteme
• Statische Rechnung: Lösung statischer Probleme
• Eigenwertanalyse: Berechnung von Eigenwerten und -vektoren
Die dynamischen und statischen Simulationen erfordern meist die
Lösung nichtlinearer Gleichungssysteme → Newton Solver
Newton-Verfahren und Eigenwertanalyse erfordert wiederum eine
effiziente Lösung linearer Gleichungssysteme
Solver Einstellungen können im GUI bzw. in der Skriptsprache über
den Container SolverOptions gesetzt werden.
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
3 / 10
Dynamische Simulation
Dynamischer Solver
• Gewöhnlichen Differentialgleichungen (ODEs) bzw. DifferentialAlgebraische Gleichungen (DAEs) erster und zweiter Ordnung
• Mehrstufige implizite Runge-Kutta Verfahren: Gauss, Radau und
Lobatto Schemata
• Index 2 Formulierung für algabraische Zwangsbedingungen
• Automatische adaptive Schrittweitensteuerung
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
4 / 10
Dynamische Simulation
Generelle Solver-Einstellungen: SolverOptions
• start time: Startzeit der Simulation
• end time: Endzeit der Simulation
• do static computation: 1 für statische Berechnung
Einstellungen für Dynamischen Solver: SolverOptions.Timeint
• max step size: maximale Zeitschrittweite
• min step size: minimale Zeitschrittweite
• init step size: Anfangs-Zeitschrittweite
• max index: maximaler Index der DAEs (2 oder 3)
• tableau name: Runge-Kutta Schema; siehe tableaus.txt
• assume constant mass matrix: 1, falls Massenmatrix konstant
Weitere Options → siehe Dokumentation
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
5 / 10
Statische Rechnung
Statischer Solver
• Lastschritte als virtuelle Zeitschritte
• Automatische Lastinkrementsteuerung
Einstellungen für Statischen Solver: SolverOptions.Static
• max load inc: maximales Lastinkrement
• min load inc: minimale Lastinkrement
• init load inc: Anfangs-Inkrement
• increase load inc steps: 1 für adaptives Inkrement
• load inc up: Vergrößerungsfaktor für Inkrement
• load inc down: Verkleinerungsfaktor für Inkrement
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
6 / 10
Eigenwertanalyse
Eigenwert Solver
• Berechnung der Eigenwerte und Eigenvektoren (Resonanzen,
modale Reduktion)
• Gyroskopische Terme in Rotordynamik
• Linearisierung um deformierten Zustand
• 3 unterschiedliche Solver verfügbar
• Zwangsbedingungen in Penalty-Formulierung
Verfügbare Solver:
1 Direkter Solver: LAPACK dsysgv
2 Iterativer Solver (Arnoldi): MATLAB eig bzw. eigs
3 Iterativer Solver (LOBPCG): in HOTINT implementiert;
Vorkonditionierung möglich
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
7 / 10
Eigenwertanalyse
Einstellungen der Eigenwert Solver: SolverOptions.Eigensolver
• do eigenmode computation: 1 für Eigenwertanalyse
• reuse last eigenvectors: 1 zum Laden gespeicherter
Eigenwerte und -vektoren
• solver type: 0.. LAPACK, 1.. MATLAB, 2.. HOTINT
• n eigvals: Anzahl der Eigenwerte/-vektoren (iterative Solver)
• accuracy: relative Genauigkeit der Lösung (iterative Solver)
• max iterations: Anzahl der Iterationen (iterative Solver)
• use n zero modes: 1 für Konvergenzprüfung der Nullmoden
(Starrkörpermoden) (iterative Solver)
• n zero modes: Anzahl der Nullmoden (iterative Solver)
• use gyroscopic terms: 1 für gyroskopische Terme
• linearize about actual solution: 1 für Linearisierung um
deformierten Zustand
Weitere Options (z.B. Vorkonditionierung) → siehe Dokumentation
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
8 / 10
Newton-Verfahren
Newton Solver
• Lösung nichtlinearer algebraischer Gleichungssysteme
• Lokal quadratische Konvergenz
• Modifiziertes Newton-Verfahren
Einstellungen der Eigenwert Solver: SolverOptions.Newton
• relative accuracy: relative Genauigkeit der Newton-Iteration
• absolute accuracy: absolute Genauigkeit
• use modified newton: 1 für approximierten Jacobian
• max modified newton steps: max. Anzahl Iteration mit
genähertem Jacobian vor Umschalten auf Full Newton
• max full newton steps: max. Anzahl Iteration Newton
Iteration vor Abbruch
• use central diff quotient: 1 für zentralen Differenzenquotienten bei numerischer Differentiation
• num diff parameter: Inkrement bei numerischer Differentiation
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
9 / 10
Lineare Gleichungssysteme
Linearer Solver
• Solver für vollbesetzte und Sparse-Matrizen
• Volle Matrizen: LAPACK dgesv
• Sparse-Matrizen: SuperLU (open source), Pardiso (Intel MKL)
• Solver für über-/unterbestimmte Gleichungssysteme: LAPACK
Einstellungen der Eigenwert Solver: SolverOptions.Linalg
• use sparse solver: 1 für Sparse-Matrizen
• underdetermined system: 1 für über-/unterbestimmte
Gleichungssysteme
AD, JG, PG, AH, SW
HOTINT Intensivkurs: Solver-Options
10 / 10
HOTINT Intensivkurs
Alexander Dorninger1 , Johannes Gerstmayr1 , Peter Gruber1 ,
Alexander Humer1,2 , Simon Weitzhofer1
2
1
Linz Center of Mechatronics GmbH, Linz, Austria
Institute of Technical Mechanics, Johannes Kepler University, Linz, Austria
25. Februar 2014
The support of the Comet K2 Austrian Center of Competence in Mechatronics (ACCM)
is gratefully acknowledged
AD, JG, PG, AH, SW
HOTINT Kurs
1/9
HOTINT C++: Struktur von Elementen & Beispiele
(Platten, Fluid-Struktur Interaktion)
AD, JG, PG, AH, SW
HOTINT Kurs
2/9
Linking between Kernel and Elements
HOTINT is composed into:
• KERNEL WorkingModule.dll
• CLIENT MBSElementsAndModels.dll
• GUI hotint.exe (by now only MS Windows is supported)
Additional functionality collected in static libs
math, parser, string and file manipulation, . . .
AD, JG, PG, AH, SW
HOTINT Kurs
3/9
Responsibilities
Kernel (WorkingModule.dll)
• multibody system management (access to elements, joints, etc.)
• assembling and storage of system matrices & vectors
• time integrator (explicit/implicit Runge Kutta schemes)
• static integrator
• solver for nonlinear systems (classical/modified Newton method)
• Eigenmodes solver
• optimization (parameter variation, evolutionary algorithms)
. . . utilizing linear algebra libraries such as SuperLU, Lapack/BLAS
Client (MBSElementsAndModels.dll)
• definitions of MBS Objects (elements, loads, materials, . . . )
• definitions of Models (via parsed script or coded in cpp)
AD, JG, PG, AH, SW
HOTINT Kurs
4/9
MBS Objects
ElementsLib
• all elements (mass, rigid, beam, shell, CMS, ...)
• all connectors (joints, contact, control, ...)
ServiceObjectsLib
Geometrical Elements, Material, Loads, Nodes, Sensors,
Simulink2HotintConversion, TCP/IP-Routines
FEMesh
FEMesh, FEMesh generator
AD, JG, PG, AH, SW
HOTINT Kurs
5/9
ElementsLib: Implemented Classes
Element
Body2D
Body3D
Mass2D
Constraint
Mass3D
Rigid2D
NodalMass3D
ANCFCable2D
Rigid3D
Rigid3DKardan
ANCFAxMovBeam2D
ANCFPipe2D
Plate2D
RevoluteJoint
InertialLinearSpringDamper2D
LinearRotationalSpringDamper
SphericalJoint
SpringDamperActor
ANCFBeam3DTorsion
GravityConstraint
PrismaticJoint2D
InputOutputElement
NodalConstraintCMS
CylindricalPointJoint
IODeadZone
RollingJoint3D
IOMathFunction
ANCFCable3D
RollingJoint2D
ANCFPlate3D
SlidingJoint
IOTime
ANCFThinPlate3D
SlidingJoint2D
IOLinearODE
FiniteElementGeneric<Body3D>
UniversalJoint
IOLinearTransformation
GeneralContact2D
IOQuantizer
ANCFBeam2Dlin
ANCFBeamShear2D
ReferenceFrame2D
CMSElement2D
FiniteElementGeneric<Body2D>
FiniteElement2D
SpringDamperBearing
CoordConstraint
RigidJoint
Rigid3DMinCoord
ANCFBeam2D
PrismaticJoint
Angle2DConstraint
Plate2Dquad
Trig2Dquad
RigidLinkConstraint
GeneralizedAngleConstraint
ANCFBeamShear3D
Trig2Dlin
CylindricalJoint
Beam3D
Plate2Dlin
Plate2DquadFFRF
InertialLinearSpringDamper
Pos2DConstraint
FiniteElement3D
Tetrahedral=TetrahedalGeneric<FiniteElement3D>
GeneralContact3D
IOSaturate
IOSTransferFunction
Hexahedral=HexahedalGeneric<FiniteElement3D>
AngSpringDamperActor
FiniteElement3DFFRF
KardanSDRotActor
HexahedralFFRF=HexahedalGeneric<FiniteElement3DFFRF>
SDRotActor2D
TetrahedralFFRF=TetrahedalGeneric<FiniteElement3DFFRF>
HydraulicActor
Quadrilateral
HydraulicActorDA
HydraulicActorDA2D
HydraulicActorDA2Dh
AD, JG, PG, AH, SW
HOTINT Kurs
6/9
Example Element: Mass2D
class Mass2D: public Body2D
{
Mass2D(MBS* mbsi, const Vector& x0, double radi, double massi,
const Vector3D& coli) : Body2D(mbsi)
{
ElementDefaultConstructorInitialization();
mass=massi;
size.X()=radi;
size.Y()=radi;
size.Z()=radi;
x_init = x0;
col = coli;
}
virtual void Initialize()
{
Body2D::Initialize();
}
// return 0: OK, 1: can not compute, 2: can not draw or compute
virtual int CheckConsistency(mystr& errorstr);
AD, JG, PG, AH, SW
HOTINT Kurs
7/9
Example Element: Mass2D
// for consistency check with constraints
virtual TKinematicsAccessFunctions GetKinematicsAccessFunctions(int mode = 1)
{
TKinematicsAccessFunctions kaf =
Body2D::GetKinematicsAccessFunctions(mode);
return TKinematicsAccessFunctions(
kaf+TKAF_position_2D+TKAF_velocity_2D+TKAF_D_pos_D_q_2D);
}
// for load/save/edit:
virtual const char* GetElementSpec() const {return "Mass2D";}
virtual void GetElementData(ElementDataContainer& edc);
virtual int SetElementData(ElementDataContainer& edc);
virtual void GetElementDataAuto(ElementDataContainer& edc);
virtual int SetElementDataAuto(ElementDataContainer& edc);
//for visualization and sensoring of displacements and velocities:
virtual void DrawElement();
virtual double GetFieldVariableValue(const FieldVariableDescriptor & fvd,
const Vector2D & local_position, bool flagD);
AD, JG, PG, AH, SW
HOTINT Kurs
8/9
Example Element: Mass2D
M(q, t) q̈ + GTq λ
=
G(q, q̇, t)
=
F2 (q, q̇, t)
| {z }
=F−C q̇+Qv
0
virtual void EvalM(Matrix& m, double t)
{
m(1,1) = mass; m(2,2) = mass;
}
virtual void EvalF2(Vector& f, double t)
{
Body2D::EvalF2(f,t);
if (GetMassDamping() != 0)
{
f(1) -= GetMassDamping()*mass*XGP(1);
f(2) -= GetMassDamping()*mass*XGP(2);
}
}
};
AD, JG, PG, AH, SW
HOTINT Kurs
9/9