Printable View
I tried smth like:
a = -r^-2;
v += a * dt;
x += v * dt;
but, major problem with this is when particles go close to each other they gain a LOT of speed.
I tried constrain acceleration like:
a = -Math.max (const, r)^-2
But this does not help much. I was thinking about advanced integration like RK etc, but does it really help in this situation? Anyone with experience in this please comment.
so I thought maybe limit the speed then? smth like:Quote:
Originally Posted by realMakc
a = -r^-2;
v + a * dt < v_max => dt;
I will try and come back.
I played with foam gravity demo to see how RK4 actually behaves and, while it does extremely well, it also has it's limits. Up to source mass 1e5 it works without notable error, but higher mass starts to suck planet into tighter orbits, until ~6.1651e5 where it has bifurcation point (planet gets thrown out).
This, one would think, can be ignored, but when you have 9000 particles interacting with two masses, chances for some of them to come close enough to masses are almost 100% :(
EDIT: I just re-wrote foam Euler integrator with solution loop that looks like this:
Its accuracy easily outperforms RK4 at mass 5e5, but the number of sub-iterations that it takes makes player freeze when orbiter get very close to mass, so this is not feasible solution. So I keep thinking... where is newblack when one needs him?Code:override public function step( dt:Number ) : void
{
//get the original state
var state:Array = _ode.state;
//get the derivative based on that state
_ode.getDerivative( state, derivative );
// here is where things get different - get max d state[i]
var ds:Number, max_ds:Number = -1; var i:int = -1;
for (i = 0; i < state.length; i++)
{
ds = derivative[ i ] * dt;
max_ds = Math.max (max_ds, Math.abs (ds));
}
// force state variables to change in amounts comparable to dt
var N:int = Math.ceil (max_ds / Math.abs (dt));
for (var k:int = 0; k < N; k++)
{
// derivative
_ode.getDerivative( state, derivative );
// advance the state by the derivative
for (i = 0; i < state.length; i++)
{
state[ i ] += derivative[ i ] * dt / N;
}
}
}
Your demo looks really cool.
By "outperforms" do you mean in terms of execution speed? This augmentation should not be more accurate than an rk4 solver...
The problem is easily identifiable in the gravitational equation (f = g * (m1m1 / r^2))- the right-hand side denominator represents the distance between the 2 objects and as it gets smaller, the force gets larger- as it approaches zero, the force nears infinity.
I unfortunately don't have a good solution for you... A good solver can keep the illusion of orbit up much longer. Try higher initial tangential velocity for objects closer to the gravitational source.
And if you do stick with your carefully stepping Euler, I could help you improve performance if you're interested.
neverless it is, check attached swf... however, cpu freeze-ups make this impractical. I tried to do same thing with RK4 but it was even worse.Quote:
Originally Posted by newblack
Arent you working with electromagnetic fields, there things should behave quite similar, no?Quote:
Originally Posted by newblack
Yep, I just do not really see how would I write one... I read quite a few pages since yesterday on subject, where it says that it is possible to construct solver adapted for specific type of equation, but unfortunately I haven't found detailed "how to"-s.Quote:
Originally Posted by newblack
If you think you can, please do.Quote:
Originally Posted by newblack
My mistake, I was thinking about this guy.Quote:
Originally Posted by realMakc