Corso di introduzione al Python

Quinto incontro

rappresentare le affinità
calcoli con i vettori e loro rappresentazione grafica
somma di vettori forza in un campo elettrostatico o gravitazionale
lancio di una moneta

le frazioni come classe in Python

Primi esempi di programmi in Python

affin.py
gravitaz0.py

"""grafico segmenti affini: due clic nel grafico per il segmento iniziale; viene quindi disegnato il
    segmento affine; clic sul bottone stop e poi clic per chiudere"""
from button import Button
from graphics import *

t=GraphWin('simmetrie',600,500,True)
t.setCoords(-20,-15,20,15)
t.setBackground('white')

bo=Button(t,Point(10,12),2,1,'STOP')
bo.activate()

# coeff. affinita'
a, b, e = -1, 2,0
c, d, f = 1, -1 ,0
# a*d-c*b deve essere diverso da zero

def griglia():
    """disegna una griglia """
    for k in range(-19,+20):
        lin=Line(Point(k,-15),Point(k,15))
        #lin.setFill('yellow')
        lin.draw(t)
    for k in range(-14,+15):
        lin=Line(Point(-20,k),Point(20,k))
        #lin.setFill('yellow')
        lin.draw(t)

def affini(p):
    """dato il punto p ritorna il punto con la trasformazione affine"""
    return Point(a*p.getX()+b*p.getY()+e, c*p.getX()+d*p.getY()+f)

def vai():
    while True:
        p1=t.getMouse()
        if bo.clicked(p1):
            break
        p2=t.getMouse()
        p1=Point(round(p1.getX()),round(p1.getY()))
        p2=Point(round(p2.getX()),round(p2.getY()))
        lin=Line(p1,p2)
        lin.setFill('red')
        lin.setWidth(2)
        lin.draw(t)
        lin=Line(affini(p1),affini(p2))
        lin.setWidth(2)
        lin.draw(t)
        griglia()
        assi()

def assi():
        lin=Line(Point(-20,0),Point(20,0))
        lin.setFill('green')
        lin.draw(t)
        lin=Line(Point(0,-15),Point(0,15))
        lin.setFill('green')
        lin.draw(t)

griglia()
assi()

vai()
t.getMouse()
t.close()

""" simulazione dell'orbita della Terra intorno al Sole
    gravitaz2.lancio(1.5E11,0,0,29850,32)
    provare vy molto piccole rispetto 29850 m/s o molto grandi, tempi minori di 32
    """
from graftarta2 import Graf
from graphics import *
import math

def cubod(x,y):
    return (x*x+y*y)*math.sqrt(x*x+y*y)

def lancio(x,y,vx,vy, tempo,sc,traccia=1,multi=0):
    GMS = 1.9991E30*6.6732E-11
# costante di gravitazione universale per massa Sole unita' SI
    k = 3/2E9
# fattore di scala
    tmax = tempo*1E6
# tempo in milioni di secondi
    t = 0
    if traccia==1:
        dt=20000
    else:
        dt=500
    #dt = 5000   5000
    n=0
    Sole=Circle(Point(0,0),8)
    Sole.draw(sc)
    sc.pennasu()
    sc.asPos(k*x,k*y)
    if traccia==1:
        sc.pennagiu()
    sc.destra(-90)
    sc.getMouse()
    while t < tmax:
        ax = -(GMS*x)/cubod(x,y)
        ay = -(GMS*y)/cubod(x,y)
        vx = vx+ax*dt
        vy = vy+ay*dt
        x = x+vx*dt
        y = y+vy*dt
        sc.asPos(k*x,k*y)
        if (n % 800==0) and multi==1:
            pun=Circle(Point(k*x,k*y),4)
            pun.draw(sc)
        t = t +dt
        n=n+1
    print t,' ',n
    sc.getMouse()
    fin.close()

fin=Graf("Orbita Terra",600,400)
fin.coordinate(-500,-470,500,470)
fin.nascondi_tarta()
fin.mostra_palla(4)

#lancio(1.5E11,0,0,29850,32,fin)
lancio(1.5E11,0,0,20000,32,fin,0,1)
#lancio(1.5E11,0,0,100000,10,fin,0,0)

Lavori di gruppo

Con il programma affin.py verificare che una affinità trasforma rette parallele in rette parallele.
disegnare un triangolo o un rettangolo oppure una "lettera" stampatello maiuscola ed osservare le trasformazioni prodotte dalla affinità.
Provare il programma gravitaz0.py modificando le velocità iniziali. Provare velocità piccole e velocità grandi. Modificare il parametro dt per osservare "l'effetto multiflash". Con velocità più piccole rispetto a quella media della Terra è facile verificare (o con l'effetto multiflash oppure con la tartaruga palla senza scia, traccia 0 e multi 0) che la velocità aumenta quando la Terra si avvicina al Sole.
modificare il programma gravitaz0.py per calcolare il minimo ed il massimo valore di x, il minimo ed il massimo valore di y nell'orbita della Terra ovvero i semiassi dell'ellisse dell'orbita.
basandosi sul calcolo ricorrente come esemplificato dal programma gravitaz0.py, simulare l'orbita di un satellite artificiale intorno alla Terra.