Sei sulla pagina 1di 8

Elaborato finale per il conseguimento

della Laurea in Ingegneria meccanica

Simulazione Dinamica 3D mediante l’utilizzo di


software Open Source

Candidato: Carlo Alberto Marino


Matricola: 1593455

Relatore: prof. Nicola Pio Belfiore


SSD: ING-IND 13

Abstract. L’esigenza dello sviluppo di un codice Multi-Body dedicato di semplice


utilizzazione e di immediata comprensione da parte dell’utente, ha portato alla
scelta di Python, un linguaggio di programmazione Open Source, che ben si presta
al calcolo scientifico in generale grazie all’ampia disponibilità di librerie apposite.
Al fine di mostrarne le possibilità di applicazione, tale codice è stato utilizzato per la
simulazione, e relativa rappresentazione 3D, di un semplice sistema composto da
due corpi rigidi collegati tramite una cerniera cilindrica.
Questo lavoro mette in luce la grande duttilità del linguaggio di programmazione
scelto, in termini sia di immediatezza della stesura dei comandi che delle notevoli
possibilità di espansione, nonché l’opportunità di poter essere utilizzato in ambito
didattico come esempio delle potenzialità offerte da questo tipo di linguaggio.

1. Introduzione cosiddetta prototipazione fisica, ossia a


quell’insieme di tecniche industriali volte alla
realizzazione di un modello fisico; il risultato è un
Codici di calcolo volti all’Analisi Dinamica e alla accorciamento e una minimizzazione dei costi di
simulazione di sistemi dinamici Multi-Body progettazione.
permettono di poter testare sistemi anche molto
complessi sottoposti a forze e momenti esterni in Al desiderio di sviluppare un algoritmo che
maniera facile, veloce e economica. Ciò ha reso permettesse, appunto, di condurre una simulazione
questi codici, soprattutto in ambito progettuale, in tre dimensioni di un qualunque sistema Multi-
essenziali al progettista, che può sviluppare un Body, si è affiancata la volontà dello sviluppo di un
qualsiasi modello senza dover ricorrere alla codice sfruttando un linguaggio di programmazione

1
open source; la scelta è ricaduta su Python, un con
linguaggio ad alto livello, caratterizzato dalla
elevatissima disponibilità di librerie volte all’analisi { γ }=([ ψq ] ⋅ {q̇ }) q ⋅ { q̇ } −2 [ψq , t ] ⋅ {q̇ } − { ψt t }
numerica, simbolica e alla simulazione fisica in
generale.
Il sistema (2.4) può essere facilmente ricondotto a
Si è cercato quindi di ottenere una procedura di un sistema del tipo:
analisi il più generale possibile basata su un
modello fisico-matematico sistematico, in modo da [ A ] ⋅{x} = {b} (2.3)
poter essere applicato il più agevolmente possibile.
Infine, avvalendoci di una libreria volta alla

[ ]
realizzazione di grafici in Python, si è riusciti a T

fornire una rappresentazione 3D del fenomeno


fisico simulato.
[ A ] = [ M ] [ ψq ]
[ψq ] [0 ] , { }
{ x } = { q̈ }
{λ}

2. Metodo Matematico
{ }
{b } = {F }
{γ} .

In questo modo è possibile costruire il vettore { x }


In generale lo svolgimento di un’Analisi Dinamica e, di conseguenza, mediante un’integrazione
Diretta di un sistema Multi-Body consiste nella passo-passo, ricavare le velocità e le posizioni dei
risoluzione del sistema algebrico-differenziale: vari corpi ad ogni istante.

[ M ] ⋅{q̈ } + [ ψq ]T ⋅ { λ } = { F } Fissato il procedimento generale, si iniziano a


{ ψ(q , t) } = 0 (2.1) scrivere le equazioni di vincolo commentando le
varie scelte adottate.

Molto spesso a questa viene preferita la cosiddetta Dal punto di vista del modello matematico, un corpo
formulazione di indice differenziale I, la quale rigido è assimilabile a una terna di assi ortonormali
consiste nella risoluzione di un sistema di equazioni mobile, avente origine nel centro di massa del
differenziali ordinarie, ottenuta derivando due volte corpo e solidale al corpo rigido.
rispetto al tempo le equazioni di vincolo:
Per descrivere l’orientamento della terna mobile
solidale col corpo rigido j-esimo si utilizzano gli
[ M ] ⋅{q̈ } + [ψq ]T ⋅ { λ } = { F } angoli di Tait-Bryan, anche detti angoli Roll-Pitch-
[ ψq ] ⋅ { q̈ } = { γ } (2.2) Yaw (Rollio, Imbardata, Beccheggio),

2
comunemente utilizzati in robotica o in applicazioni asse, vincolando quindi la traslazione e due
relative a veicoli. rotazioni del secondo corpo (5 gradi di vincolo).

La scelta delle coordinate lagrangiane ricade sulle


coordinate dei sistemi di riferimento locali, per le
quali si hanno n=12 coordinate lagrangiane
sovrabbondanti (6 per ogni corpo) , F=7 coordinate
indipendenti, pari al numero dei gradi di libertà del
sistema, e quindi p=5 coordinate dipendenti.
Considero un sistema di riferimento fisso R0 = (O,
e1, e2 ,e3), e i due sistemi mobili R1 = (O’, u1, u2 ,u3)
e R2 = (O’’, w1, w2 ,w3) solidali rispettivamente con i
corpi 1 e 2.

Il vettore delle coordinate lagrangiane sarà


Ogni rotazione è composizione, in questo caso, di {q}={u ∣v } , con:
una rotazione intorno al versore ^x , pari a ψ, di una
intorno a ^y , pari a ϑ, e di una intorno a ^z , pari a
{u}={x 2 , y 2 , z2 , ψ2 , ϕ2 } (2.5)
φ.
{v }={θ 2 , x 1 , y 1 , z 1 , ψ1 , θ1 , ϕ1}
La matrice di rotazione finale sarà data dal prodotto
delle tre singole matrici di rotazione. Dato che il
prodotto matriciale non gode della proprietà x1, y1, z1 e x2, y2, z2 sono le componenti dei vettori
commutativa, l’ordine con cui si prescrivono le posizione O’ e O’’ in R0 ; ψ1, ϑ1, φ1 e ψ2, ϑ2, φ2
rotazioni finite influenza in generale la posizione del sono le rotazioni di R1 intorno a e1, e2 ,e3 e di R2
corpo. Si considera, nella fattispecie, la sequenza intorno a u1, u2 ,u3 .
di rotazioni ψ, ϑ, φ; essa genera la seguente
matrice di trasformazione: R1 si muove liberamente rispetto al sistema fisso e
R2 ruota rispetto a R1 intorno all’asse u2 di angolo
ϑ2. Il punto O’’ è solidale al sistema mobile R1

[ ]
cϕ cθ c ϕ sθ s ψ −s ϕ c ψ c ϕ sθ c ψ + sϕ s ψ (cerniera cilindrica); esso avrà coordinate nel
[ R(ψ , θ , ϕ)] = s ϕ c θ s ϕ s θ s ψ +c ϕ c ψ s ϕ s θ c ψ −c ϕ s ψ sistema fisso:
−s ϕ cθ s ψ cθ c ψ
O ' '= O ' + ( 0 , d , 0 ) ⋅[ R (ψ1 , θ1 , ϕ1) ] =
(2.4)

{ }
x 1 + d sin ϕ1 cos θ1
Il sistema che si vuole rappresentare è composto,
= y1 + d (sin ϕ1 sin θ 1 sin ψ1 + cos ϕ1 cos ψ1)
come detto, da due corpi rigidi connessi tramite una
z 1 + d (sin ϕ1 sinθ 1 cos ψ1 −cos ϕ1 sin ψ1 )
cerniera cilindrica. Essa, nello spazio, permette
solamente la rotazione relativa intorno al proprio

3
essendo O'= ( x 1 , y 1 , z1 ) (2.6) moltiplicato per la matrice di rotazione di Rj rispetto
a Rj-1.
Per quanto riguarda le rotazioni invece, avrò che
ψ2, e φ2 sono costantemente zero, per il fatto che Una volta scritta quest’ultima matrice, si hanno tutte
R2 ruota rispetto a R1 solamente intorno all’asse u2 le informazioni necessarie per descrivere come è
di angolo ϑ2 . vincolato il corpo j al corpo j-1 .

Fatte queste considerazioni, si possono scrivere le Infine, occorre indicare un metodo di integrazione
p=5 equazioni di vincolo: numerica passo-passo per passare dalle
accelerazioni alle velocità e quindi alle posizioni.
Data la non elevatissima accuratezza richiesta dal
{ ψ(q )} = {0 } (2.7) codice in questione, si è optato per l’utilizzo del
Metodo di Eulero, per cui:
con:
q i+1 = qi + q̇ i ⋅( t i +1 −t i) (2.9)

{ }
x 1 − x2 + d sin ϕ1 cos θ 1
y 1 − y 2 + d (sin ϕ1 sin θ 1 sin ψ1 + cos ϕ1 cos ψ1) In alternativa, è possibile implementare agilmente
{ ψ(q) } = z − z + d (sin ϕ sin θ cos ψ −cos ϕ sin ψ ) metodi più raffinati di ordini superiori come quello di
1 2 1 1 1 1 1
ψ2 Heun o il Runge-Kutta classico.
ϕ2

Potenzialmente la pratica adottata per la stesura


3. Installazione software
delle equazioni di vincolo è applicabile per un
qualsiasi sistema di corpi collegati fra loro con giunti
o coppie cinematiche: per il corpo j-esimo si
Il primo passo è l’installazione di Python [1] e delle
scrivono le coordinate del centro di massa, al quale
sue più famose librerie scientifiche sul proprio
faremo coincidere l’origine O( j ) del sistema di
computer.
riferimento mobile Rj , in R0 , che avranno questa
Per utenti Windows o Mac il modo più veloce è
forma:
l’installazione di una distribuzione di Python che
comprenda, oltre al linguaggio, anche utili librerie e
{O (0j) }T ={O ( j0−1) }T + {O ((jj)−1) }T [R jj −1 ] (2.8)
ambienti di sviluppo per l’editing, il testing e altro
ancora.
La più famosa è Anaconda, una distribuzione
cioè il centro di massa del corpo j rispetto al
scientifica nella quale troviamo:
sistema di riferimento fisso è pari alla somma
vettoriale del centro di massa del corpo j-1 rispetto
- Python (si può scegliere tra la versione 2.7 e la
al sistema di riferimento fisso più il centro di massa
3.5, preferita nello specifico);
del corpo j rispetto al sistema di riferimento di j-1

4
- Spyder, un editor multilingua con caratteristiche È possibile ottenere l’eseguibile all’indirizzo [2],
quali, ad esempio, analisi del codice o console dove si può scegliere l’installer preferito per
interattive; Windows, Mac od anche Linux (in quest’ultimo caso
una volta scaricato l’installer si deve scrivere nel
- IPython, una potente console interattiva che terminale “bash Anaconda3-4.2.0-Linux-x86_64.sh“
supporta anche la visualizzazione di dati; e seguire le istruzioni a schermo).

- SciPy, una collezione di librerie e softwares per il


calcolo scientifico, comprendente a sua volta:
• NumPy, per quanto riguarda l’analisi
numerica;
• Matplotlib, per il plotting soprattutto 2D, ma
con supporto anche per il 3D;
• SymPy; per il calcolo simbolico;
• molte altre.

Sito Web Anaconda Distribution

4. Pseudo-codice

1. INIZIO
Interfaccia grafica Spyder 1.1 importa numpy, matplotlib
1.2 # imposto intervallo temporale
dt, tfin
t = da 0 a tfin con passo dt
1.3 # Costanti del problema, [m]
m1, m2, alt_1, larg_1, prof_1, alt_2, larg_2, prof_2, d
# Inerzie, [kg*m^2]
I1_x, I1_y, I1_z, I2_x, I2_y, I2_z
1.4 # Definizione funzioni, verranno riempite
# nel ciclo di integrazione
X_p_1, Y_p_1, Z_p_1, X_1, Y_1, Z_1,
Omegax_1, Omegay_1, Omegaz_1, Thetax_1,
Esempio di un'animazione con Matplotlib
Thetay_1, Thetaz_1 → vettore nullo della dimensione di t
X_p_2, Y_p_2, Z_p_2, X_2, Y_2, Z_2,

5
Omegax_2, Omegay_2, Omegaz_2, Thetax_2, 2.5 # Vettore b
Thetay_2, Thetaz_2 → vettore nullo della dimensione di t b = composizione Q, gama
1.5 # Condizioni iniziali 2.6 # Ricavo accelerazioni
X_p_1 [0], Y_p_1 [0], Z_p_1 [0], Omegax_1 [0], x = (inv(A))*(b)
Omegay_1 [0], Omegaz_1 [0], X_1 [0], Y_1 [0], 2.7 # Metodo di Eulero
Z_1 [0], Thetax_1 [0], Thetay_1 [0], Thetaz_1 [0], Integrazione numerica passo-passo
X_p_2 [0], Y_p_2 [0], Z_p_2 [0], Omegax_2 [0], # q(i+1) = q(i) + q_punto(i) * dt
Omegay_2 [0], Omegaz_2 [0], X_2 [0], Y_2 [0], end for
Z_2 [0], Thetax_2 [0], Thetay_2 [0], Thetaz_2 [0]
#
# Si impongono le condizioni al primo istante; 3. DEFINIZIONE POSIZIONI PUNTI
# X_p_2 [0], Y_p_2 [0], Z_p_2 [0], Omegax_2 [0], 3.1 # Definizione funzioni dei vertici, si rappresentano
# Omegaz_2 [0], X_2 [0], Y_2 [0], Z_2 [0], # i due corpi come parallelepipedi
# Thetax_2 [0], Thetaz_2 [0] scelti in modo che rispettino pnt1_1, pnt2_1, pnt3_1, pnt4_1, pnt5_1, pnt6_1,
# Psi(q) = 0 e pnt7_1, pnt8_1 → array nullo (dimens.(t),3)
# [PsiQ](dq) = 0 pnt1_2, pnt2_2, pnt3_2, pnt4_2, pnt5_2, pnt6_2,
pnt7_2, pnt8_2 → array nullo (dimens(t),3)
2. INTEGRAZIONE EQUAZIONI MOTO 3.2 # Vertici (no rototraslazioni)
for i in lista tra 0 e (dimens.(t) – 1): p1_1, p2_1, p3_1, p4_1, p5_1, p6_1, p7_1, p8_1
# Ricavo vettori e matrici per ogni istante #
# di tempo p1_2, p2_2, p3_2, p4_2, p5_2, p6_2, p7_2, p8_2
2.1 # Matrice delle masse 3.3 # Ciclo identificazione punti
Muu = diagonale con m2, m2, m2, I2_x, I2_z for i in lista tra 0 e dimens.(t) :
Mvv = diagonale con I2_y, m1, m1, m1, I1_x, I1_y, I1_z pos1 = [X_1[i], Y_1[i], Z_1[i]]
Mvu = matrice nulla di dimens. (7,5) pos2 = [X_2[i], Y_2[i], Z_2[i]]
Muv = matrice nulla di dimens. (5,7) ROTAZ_1 → ROTAZ_1[i]
M = composizione di Muu, Muv, ROTAZ_2 → ROTAZ_2[i]
Mvu, Mvv #
2.2 # Componente lagrangiana della sollecitazione ruoto i punti dei vari corpi moltiplicandoli
Qu = array ([0], [0], [-m2*g], [0], [0] ) per le matrici rotazione e li traslo sommando
Qv = array ([Mmotore], [0], [0], [-m1*g], le coordinate dei centri di massa
[0], [-Mmotore], [0]) # pnt[i] = pos[i] + p * rotaz[i]
Q = composizione di Qu, Qv end for

2.3 # Scrivo Jacobiano vincoli e vettore gama 4. ANIMAZIONE GRAFICA


PsiQ→ PsiQ[i] 4.1 # Creazione assi e linee
gama → gama[i] limite assi x, y, z → (0,100)
2.4 # Matrice A #
A = composizione M, trasposta(PsiQ), etichette assi x, y, z
PsiQ, matr. nulla (5,5) #

6
griglia assi → (True) poly1 = Poligono(verts1)
4.2 # Creazione corpi e linee poly2 = Poligono(verts2)
verts1 = array (ogni riga contiene i vertici delle aggiorno indicazione tempo → (i * dt)
superfici laterali del corpo) return line, poly, time
# 4.4 # Animazione
# Sfrutto delle funzioni di matplotlib che dato un ani(animate, n°frames → dimens( t ),
# array di vertici mi restituisce una superficie 3D funz. iniz. → init, intervallo → 1)
poly1 = Poligono(verts1) mostra figura
poly2 = Poligono(verts2)
aggiungi (poly1) FINE PROGRAMMA
aggiungi (poly2)
# Disegno linee che descrivono la traiettoria
# dei centri di massa dei corpi
line1, = ([ ], [ ], zs = [ ])
line2, = ([ ], [ ], zs = [ ])
aggiungi (line1)
aggiungi (line2)
4.3 # Funzioni init e animate.
# La funzione di animazione necessita di una
# funzione INIT che sarà chiamata per creare il
# frame base su cui l'animazione si sviluppa, e
# di una funzione ANIMATE, che al variare
# del parametro 'i' disegna i frame dell'animazione.
# Entrambe restituiranno le varie figure, aggiornate
# al frame i-esimo, in modo che il programma
# riconosca quale parte del disegno aggiornare.
def init():
verts1 → verts1[i]
verts2 → verts2[i]
line1, = (X_1[i] , Y_1[i], Z_1[i])
line2, = (X_2[i] , Y_2[i], Z_2[i])
poly1 = Poligono(verts1)
poly2 = Poligono(verts2)
return line, poly
#
def animate( ):
verts1 → verts1[i]
verts2 → verts2[i]
line1, = (X_1[i] , Y_1[i], Z_1[i])
line2, = (X_2[i] , Y_2[i], Z_2[i])

7
5. Conclusioni

Questo lavoro ha messo in luce la grande duttilità


del linguaggio di programmazione scelto; oltre
all’immediatezza della stesura dei comandi, si dà
risalto alle notevoli possibilità di espansione, grazie
alla presenza di un’importante comunità di
sviluppatori che rende disponibili sempre più
pacchetti per ogni utilizzo, accademico e non.

Inoltre, esso ha anche intento didattico; le


semplificazioni adottate nella stesura del codice
permettono una più facile comprensione da parte
dello studente delle possibilità offerte da questo tipo
di linguaggio.

Infine è da considerare che, per coloro che si


approcciano allo studio di sistemi dinamici Multi-
Body, l’utilizzo di un codice semplice come quello
oggetto di questo lavoro, permette di ottenere buoni
risultati coniugando la semplicità di utilizzo alla
possibilità di essere esteso a simulazioni di sistemi
molto più complessi, senza dover ricorrere a
programmi sicuramente più raffinati, ma
inevitabilmente più costosi, e meno consoni ad un
utilizzo prettamente didattico.

6. Bibliografia

[1] Guido Van Rossum "Programming Python",


O'Reilly 1997, il libro ufficiale sul Python
scritto dall'autore del linguaggio.
[2] Download Anaconda Distribution,
https://www.continuum.io/downloads
consultato il 23.10.2016