No, that is not correct. Consider Newton's law of Gravitation,bkelly said:
Hoot, that is exactly what the OP has. He is correct.Hootenanny said:
As Hoot mentioned, the gravitational accelerations of A toward B and B toward A as seen by an inertial observer arebkelly said:
D H said:
You can verify this via the SI version of Newton's second law, F=ma. The units of force in SI units is kg-m/sec2.bkelly said:
Your error was using little g, Earth standard gravitational acceleration, as a force. g is 9.803 m/sec2. It is not just 9.803 (it has units), and it is not a force (it is an acceleration).
That is one of two reasons I said "(nearly) constant". Another reason is that larger masses do accelerate toward the surface of the Earth slightly faster than do smaller ones. Think of Newton's third law. Gravity makes the object accelerate toward the Earth and the Earth accelerate toward the object. The relative acceleration of an object with mass m toward the surface of the Earth is
Here is an even better way:bkelly said:
bkelly said:
Oops. I wrote too quickly writing and spent even less time reviewing what I wrote.VelocityVerlet::integrate (
double dt,
Star * stars,
int nstars)
{
compute_accelerations (stars, nstars);
for (int ii = 0; ii < nstars; ii++) {
delta_v1[ii] = dt * stars[ii].acceleration;
stars[ii].position += deltat *(stars[ii].velocity + 0.5*delta_v1[ii]);
}
compute_accelerations (stars, nstars);
for (int ii = 0; ii < nstars; ii++) {
delta_v2[ii] = dt * stars[ii].acceleration;
stars[ii].velocity += 0.5*deltat *(delta_v1[ii] + delta_v2[ii]);
}
}That is correct.bkelly said:
This is where I am having an issue. Developing your simulation in this way will inherently constrain you to using a propagator with low accuracy.
The "derivative function" to which I referred is that function which calculates the accelerations of each star due to gravitational attraction to all of the other stars.
class Star {
public:
double mass;
double position[3];
double velocity[3];
double acceleration[3];
};
class Stars {
Star * stars; // Or some other mechanism (e.g. vector) for storing star data
int nstars;
// Initializer function. This function allocates data for the stars and sets each star's
// mass, initial position, and initial velocity.
void compute_accelerations();
// The derivative function. This function computes accelerations for all of the stars.
void compute_accelerations();
};
class Propagator {
void initialize (Stars & stars);
void update (Stars & stars);
};
void simulation_driver (void)
{
Stars stars;
Propagator propagator;
Graphics graphics;
double deltat;
double time;
// Initialize the system.
time = 0.0;
deltat = ...;
stars.initialize ();
propagator.initialize (stars);
graphics.initialize (stars);
// Main loop. This loop propagates the stars to the next time step and portrays the
// updated star positions graphically.
while (! finished) {
propagator.update (stars, deltat);
time += deltat;
graphics.update (stars);
}
// Cleanup code. You should play nice and free memory and other resources.
}Star_Pointer->Set_X_Pos( Value );code ...I know about object oriented programming. Unfortunately, it like many other programming paradigms, has a religious aspect to it. The debate over public/private is, to some extent, just religion. We don't condone religious debates at this forum.bkelly said:
Consider reading the star specifications from a file. The dialog box mechanism is not very good if you want to have more than a handful of stars in the system or if you want to explore variations on a theme (e.g., Monte-Carlo analyses).
I mentioned this in my previous post. See the hyperlinks I posted there. Regarding code boxes, the user doesn't have control over the presence of scroll bars. The user specifies the content of a code box. The display software determines whether scroll bars need to be used. It adds horizontal scroll bars if the basic code box is too wide, vertical scroll bars if the basic code box is too tall.
So, let's back it up.bkelly said:
while (! finished) {
galaxy.compute_acceleration();
galaxy.update_positions_and_velocities(deltat);
time += deltat;
graphics.update(galaxy);
}Do
{
// stage 1
// get the first body in the list
Star_pointer = link_root->next;
Do
{
Star_pointer->Traverse_List_For_Gravity();
Star_pointer = star_pointer->get_next_body();
}(until end of list )
// stage 2
// get the first body in the list
Star_pointer = link_root->next;
Do
{
Star_pointer->Integrate_Acceleration_into_Next_Position();
Star_pointer = Star_pointer->get_next_body();
}(until end of list )
// insert code for housekeeping, update time, iteration counts, etc.
// insert code to check for operator input, maybe several places
}(until done);Void Traverse_List_For_Gravity()
{
Other_pointer = link_root->next;
Do
{
If( Other_pointer == me) continue;
// structure Other_body is a local structure for temporary storage of the values
// retrieved from the other body.
Other_body.mass = Other_pointer->query_mass();
Other_body.position = Other_pointer->query_position();
Calculate_gravitational_effect();
Other_pointer = Other_pointer->next;
}(until end of list);
} // end of function Star_pointer->Integrate_Acceleration_into_Next_Position();This is exactly what I suggested you not to do. Dang. Frustrated.bkelly said:
You are correct in that you need to calculate all of the accelerations before you update any of positions. The problem is that some propagators need to perform a bunch of mini-steps for each simulation step. For example, fourth-order Runge-Kutta method computes the derivatives four times per simulation step. The updated state is based on a weighted average of these four derivatives.bkelly said:
I think you should separate state propagation from everything else. I also think you should read up on techniques for solving initial value problems.
do {
do {
system.compute_derivatives ();
propagation_finished = system.propagate_state (deltat);
} until (propagation_finished);
time += deltat;
system.do_something_with_new_state ();
} until (simulation_finished);Gravitation attraction proportioned, also known as the law of universal gravitation, is a physical law formulated by Sir Isaac Newton. It states that every particle in the universe attracts every other particle with a force that is directly proportional to the product of their masses and inversely proportional to the square of the distance between them.
Gravitation attraction proportioned is responsible for the force of gravity that keeps us grounded on Earth, as well as the motion of objects in our solar system. It also plays a role in the formation of galaxies, stars, and planets.
The formula for gravitation attraction proportioned, F = G(m1m2)/r^2, helps us understand the relationship between mass, distance, and the force of gravity. It allows us to make predictions and calculations about the motion of objects in the universe.
Gravitation attraction proportioned is closely related to the laws of motion and conservation of energy. It also plays a role in Einstein's theory of general relativity, which explains the behavior of gravity on a larger scale.
While the law of universal gravitation holds true for most objects in our daily lives, it does not accurately describe the behavior of objects at very small or very large scales. In these extreme cases, other forces, such as electromagnetic or nuclear forces, may become more dominant.