Time-step independent friction model

Click For Summary

Discussion Overview

The discussion revolves around the implementation of a time-step independent friction model in a programming project related to physics simulations. Participants explore the calculations involved in modeling friction and motion, addressing potential issues with the current approach.

Discussion Character

  • Technical explanation
  • Debate/contested
  • Mathematical reasoning

Main Points Raised

  • One participant describes their approach to calculating motion and friction in a pseudo-code format, expressing concerns about the time-step independence of their model.
  • Another participant questions the validity of the calculations, specifically pointing out that the method used to calculate position may not yield correct results due to the way acceleration and velocity are combined.
  • A participant acknowledges a potential optimization in their code but admits to a lack of clarity in variable naming and the flow of calculations.
  • There is a mention of a typo in the friction calculation, which raises further questions about the accuracy of the implementation.
  • A participant seeks additional ideas or suggestions from others to improve the model.

Areas of Agreement / Disagreement

Participants do not appear to reach a consensus on the effectiveness of the current friction model, with some expressing skepticism about its time-step independence and others suggesting possible optimizations. The discussion remains unresolved regarding the best approach to achieve the desired outcomes.

Contextual Notes

There are indications of missing assumptions related to the definitions of variables and the mathematical steps involved in the calculations. The discussion also highlights the complexity of ensuring time-step independence in physics simulations.

TK
Messages
5
Reaction score
0
Help with Friction

Greetings , all fellow scientists!




I've been struggling with time-step independent physics for a programming project. The problem is that it doesn't seem to be time-step independent after all. Here's some of it in a pseudo-code form. It seems to be the friction part where it goes wrong. The reason I'm calculating friction like that anyway is because this way has a nice property of limiting the speed. ( Should implement surface friction and drag separately for better simulation though. ) The following gets executed at varying intervals. Hope the variable names are self-explanatory.
Code: 
``calc acc vector without friction
acc_x = time_step * ( move_force_x / mass )
acc_y = time_step * ( move_force_y / mass )
acc_z = time_step * ( move_force_z / mass )

``calc movement vector without friction
move_x = time_step * ( speed_x + ( acc_x / 2 ) )
move_y = time_step * ( speed_y + ( acc_y / 2 ) )
move_z = time_step * ( speed_z + ( acc_z / 2 ) )

``calc and apply friction
move_force_x = move_force_x - ( move_x * friction_coefficient )
move_force_y = move_force_y - ( move_y * friction_coefficient )
move_force_z = move_force_z - ( move_z * friction_coefficient )


``calc acc vector
acc_x = time_step * ( move_force_x / mass )
acc_y = time_step * ( move_force_y / mass )
acc_z = time_step * ( move_force_z / mass )

``calc movement vector
move_x = time_step * ( speed_x + ( acc_x / 2 ) )
move_y = time_step * ( speed_y + ( acc_y / 2 ) )
move_z = time_step * ( speed_z + ( acc_z / 2 ) )

``calc new speed
speed_x = speed_x + acc_x
speed_y = speed_y + acc_y
speed_z = speed_z + acc_z

``calc new pos
pos_x = pos_x + move_x
pos_y = pos_y + move_y
pos_z = pos_z + move_z

And now in a shorter form joining the coordinates to vector-type variables. Could have only posted that one but then the variable names would have been less self-explanatory.
Code: 
``calc acc vector without friction
V_acc = time_step * ( V_move_force / mass )

``calc movement vector without friction
V_move = time_step * ( V_speed + ( V_acc / 2 ) )

``calc and apply friction
V_move_force = V_move_force - ( V_move * friction_coefficient )


``calc acc vector
V_acc = time_step * ( V_move_force / mass )

``calc movement vector
V_move = time_step * ( V_speed + ( V_acc / 2 ) )

``calc new speed
V_speed = V_speed + V_acc

``calc new pos
V_pos = V_pos + V_move

Maybe it's more like a mathematical question but anyway it is wrong to separate those sciences. The physics are not complex here and that's why I thought it'd do with lesser explanation on what it is supposed to do and so on. In case the above is how it should be after all I'll take a look at the part where it calculates the time-step in the 1st place.
Thanks in advance!




All the best!


TK
 
Last edited:
Physics news on Phys.org
I do not see any way that your calculations can be time step independent, please provide more information about what you mean.

move_x = time_step * ( speed_x + ( acc_x / 2 ) )

This will not give you the correct position. You are adding a velocity to an acceleration, you need to do this:

[tex]move_x = time_{step} * (speed_x + (time_{step} * \frac {acc_x} 2))[/tex]

to get a distance.
 
Hiya , Integral!


Thank You for a really fast reply! Thought I'd have to wait atleast until tomorrow morning.
Anyway , it should be a nice , little optimization. Follow the flow of the code...
Code: 
``calc acc vector without friction
V_acc = time_step * ( V_move_force / mass )

``calc movement vector without friction
V_move = time_step * ( V_speed + ( V_acc / 2 ) )
...acceleration is premultiplied with time-step. Should of have made it clearer though and perhaps named the variable differently.
 
Last edited:
Had a mistype( typo ) there...
``calc and apply friction
move_force_X = move_force_x - ( move_x * friction_coefficient )
move_force_X = move_force_y - ( move_y * friction_coefficient )
move_force_X = move_force_z - ( move_z * friction_coefficient )
This is not the case with the real thing though.
So , has anyone got any ideas? Thank You!
 
Has anyone got any ideas?