Newsgroup: it.comp.programmare
Titolo: Creare un simulatore

Ciao a tutti,
mentre progettavo un simulatore corpi celesti mi sono imbattuto in
problema: il tempo.
Il mio simulatore partendo dai valori di massa e distanza dei vari corpi
celesti si calcola la forza e di conseguenza  velocita ed accelerazioni.
Nella realta' ad ogni istante, dato che i corpi si spostano e quindi
cambia la distanza tra loro, cambiano la forza e la velocita con cui si
spostano e le distanze tra loro. Nel simulatore dato la velocita dipende
dall'accelerazione e dal tempo il mio problema e' quanti piccolo
dev'essere la differenza di tempo tra una ciclo di simulazione e l'altro.
Se scelgo un deltaT troppo grande la precisione va a farsi friggere con la
conseguenza che la simulazione potrebbe risultare del tutto sbagliata. Se
scelgo un deltaT troppo piccolo la simulazione potrebbe essere lunghissima.
Cosa devo fare? Il mio approccio e' giusto?
Grazie!
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 lunghissima.
Non me ne intendo molto di astrofisica ma ho l'impressione che tu abbia 
scoperto l'acqua calda.
Tra l'altro oltre alla fisica classica, forse dovresti anche considerare la 
relativita' ?
Comunque sono curioso, se trovi una soluzione postala per favore.
 
-- 
Stefano L.

Stefano L. ha scritto:




Il mio problema non e' come simulare i pianeti ma risolvere la questione
del tempo nelle simulazioni.


 Cosa devo fare? Il mio approccio e' giusto?
Qualche tempo fa ho avuto lo stesso problema scrivendo un simulatore
gravitazionale in OpenGL.
Inizialmente il mio scopo era costruire un simulatore scriptabile piuttosto
realistico, non un semplice arcade approssimativo, quindi ho tenuto in
considerazione come te velocità, masse, direzioni, accelerazioni etc etc.
Alla fine ho notato anche io che variando lo step temporale anche di poco da
valori molto piccoli, si va in contro ad una deriva piuttosto grande dopo
pochi minuti proprio a causa dell'insufficiente quantizzazione.
Volevo inserire un timer interno al sistema in modo che reimpostasse
proporzionalmente la quantizzazione in funzione del frame rate, in modo che
la simulazione girasse alla stessa velocità in tutte le macchine.
Questo però ha peggiorato la situazione perché risultava praticamente
impossibile calcolare a priori l'errore del sistema, avendo di frame in
frame uno step temporale diverso dal precedente, ed inoltre su macchine poco
potenti lo step era troppo grande e la simulazione sballava.
Alla fine, fedele all'idea iniziale di costruire un motore il + possibile
fedele alla realtà, ho deciso di impostare uno step statico come variabile
globale, che ho tarato dopo qualche prova.
Se ti interessa qualche dettaglio in +, ho scritto un tutorial completo
comprensivo di sorgenti VC++ 6.0.
Puoi trovare il pdf del tutorial ed i sorgenti VC++ su GPI
http://www.gameprog.it/index.php?action=search&id=443
Oppure direttamente nel mio sito
http://www.ninjacross.it/pagina32.htm
Spero di esserti stato utile :D
Saluti
--
NinjaCross
 
www.ninjacross.it
Membro dell'Italian Agile Movement.
www.agilemovement.it
Sconnetti il chip isolineare per contattarmi
ninjacross_CH...@yahoo.it

 del tempo nelle simulazioni.
A quello mi riferivo, ripeto non me ne intendo ma credo che, per esempio, 
alla NASA abbiano il tuo stesso problema:
O lunghi tempi di calcolo oppure calcoli approssimativi.
Penso che loro risolvano unsando computer _parecchio_ veloci.
-- 
Stefano L.

 Cosa devo fare? Il mio approccio e' giusto?
Devi decidere se ti interessa di più la precisione oppure la velocità, e
trovare un compromesso. Eventualmente puoi cercare di scoprire se esistono
algoritmi ottimizzati o più semplici per effettuare i calcoli (a scapito
della precisione, ovviamente...).
Spesso nei giochi per simulare la fisica vengono usate formule
semplificate che sacrificano un pò la precisione per velocizzare i calcoli.
vedi tu...
bye
Raffaele
-- 
Raffaele Castagno


 ha scritto nel messaggio
news:bflmqr$phu$1...@news.newsland.it...


 problema: il tempo.
[...]
beh, c'e' ben poco da fare: vuoi simulare un sistema continuo
utilizzando una macchina discreta, quindi avrai sempre un errore
introdotto dalla discretizzazione. Da li' non scappi. Visto che devi
convivere con questo problema, non ti resta che decidere qual e' un
margine di errore accettabile e vedere con quale intervallo temporale
riesci a rimanere all'interno di questo margine. In ogni caso piu'
passa il tempo piu' l'errore si accumula.
PS: non e' detto che diminuendo arbitrariamente l'intervallo di
discretizzazione diminuisca anche l'errore introdotto. Se hai delle
buone conoscenze di matematica & informatica, puoi trovare al
riguardo delle informazioni interessanti in qualche libro di calcolo
numerico, in particolare per quanto riguarda la soluzione numerica di
equazioni differenziali. Li' la discretizzazione e' spaziale anziche'
temporale, ma cambia ben poco. La sostanza comunque e' che, al di
sotto di un certo intervallo di discretizzazione, gli errori
algoritmici (quelli dovuti alla finitezza della rappresentazione
dei numeri in un processore) prendono il sopravvento e ti portano a
risultati completamente sballati.
-- 
There are only 10 kinds of people in the world --
Those who understand binary, and those who don't.

 risultati completamente sballati.
risposta molto completa e sintetica,
come vedi non si scappa dall'approssimazione,
potrei suggerirti l'utilizzo di thered come ti hanno consigliato in
precedenza,
ognuno di questi calcola un piccolo passo dell'evoluzione del corpo
nell'ambiente circostante.
ogni corpo si muove in una direzione e su questa vengono espresse
nuove forze,
se vuoi avere un'evoluzione più precisa, ma non assoluta,
approfondisci i calcoli con thered, sui corpi influenzati dagli altri
corpi,
evitando di calcolare in profondità le direzioni che marciano in
traiettorie esterne dalle forze,
risparmierai calcolo per la precisione degli altri.

 problema: il tempo.
Ciao, ma guarda che coincidenza :-)
Anche io avevo avuto a suo tempo l'idea di scrivere
un simulatorino come il tuo e sono inciampato sul tuo
stesso problema. La soluzione che adottai fu duplice:
1) l'algoritmo di calcolo:
invece di usare le equazioni della dinamica nude e crude
(F = M*A; v=a*t ecc. ecc.) ho usato invece un algoritmo
di calcolo dinamico diverso pensato specificamente per
il caso tempo-discreto, che mantiene la proprietà di
conservatività del sistema: cioè per esempio, simulando
l'orbita Terra-Luna non hai la garanzia che l'orbita
simulata sia perfetta (non ce l'avresti comunque) però
sei *sicuro* che sarà sempre un ellisse... e non una
spirale strana :-)
Non mi ricordo più dove l'avevo trovato... sob :-(
Chiedi lumi nel newsgroup it.scienza.matematica, lì
sicuramente sapranno delucidarti.
2) il delta-T variabile: ho preso dT = Cost/MaxAcc:
vale a dire, il sistema salva l'accelerazione massima
fra tutte quelle in gioco ad un certo momento e prende
un passo temporale inversamente proporzionale ad essa.
Cost è una costante che dovrai decidere tu.

Qualche link o parola chiave con la quale approfondire il problema dei
sistemi continui delle macchine discrete.
(non ho studi universitari alle spalle...)
Grazie.