rec.autos.simulators

  Yes, it's very exciting the first time, isn't it ?  You'll experience both
bouts of extreme frustration and big smiling (even evil, devilish sounding
laughter) attacks in turn in the future :-)

  >I have noticed some annoying jittering on the wheels when at low

  This is an age old problem that even today engineers are still developing new
methods to eliminate.  Ruud pointed out a paper that has an excellent solution,
probably the best one any of us here have seen, although you might need to drop
him or Gregor a note for help (sorry guys ;-)).  It's confusing to say the
least, although rather brilliant.  Thanks can go to Chris West for pointing it
our way.

  The problem you're having is (we all have this problem), the tires tend to
overshoot their "ideal" slip ratio by a small amount, then fall back the next
step, and continue oscillating.  At higher speeds, since the rotational speed
of the wheel and theoretical free rolling speed are high, the oscillation in
slip ratio isn't enough to notice or cause an instability.  However, since slip
ratio is essentially (TrueRotVel / TheoreticalRotVel), once the car slows down
enough, even a small change in true rotational velocity causes a large change
in slip ratio, which causes a really big torque back the other direction.  This
goes back and forth, and gets worse the slower you go.  This is why I sometimes
cringe when people here at r.a.s. occasionally get frustrated at some low speed
behavi***"quirk" in one of their various racing sims, and immediately dub it
"arcade" instead of "*** super realistic simulation."  They don't
understand how the situation is completely different when it moves to high
speed racing modelling.

  The paper Ruud talks about treats slip ratio (and slip angle) as a state
variable.  Meaning you calculate what it "should" be the same way you're doing
it now, but then you only let it increase/decrease a little bit towards this
value each time step, depending on the speed of wheel rotation and linear
motion.  It slowly gains on the slip ratio (and angle) while the wheel rotates
according to a somewhat arbitrarily defined "relaxation length" the wheel
moves/rotates through, and eventually arrives at the slip ratio you're
currently calculating.  This lets the slip ratio and slip angle slowly build
up, and when stopping on a hill (a problem you'll soon discover that will rear
it's ugly head, causing a massive hair pulling episode), the slip ratio and
angle settle at some non-zero value, even though the wheel isn't rotating,
keeping the forces right where they should be.  It's elegent and beautiful, IMO
:-)

  I haven't included this in my system yet, although I've played around a
little with the gain effect in a seperate program as an experiment to see
how/why/if it worked.

  Anyway, since I didn't know about this relaxation approach when I first
encountered the problem, I did two things:

  1.  I decoupled the rotational velocity/acceleration of the tires from the
main system and let it operate at its own frequency.  This lets me set the
sampling frequency of the tires and differential to a really high value without
doing every single body motion calculation and ground intersection 10-100 times
as often (actually, it's adjustable on the fly, I should experiment with that
come to think of it.)  To see what I mean, increase the main frequency
(decrease your timestep) and you'll notice that the speed where instabilities
start to occur drops.  This lessens the problem, but you'd need an infinite
frequency to completely eliminate it this way.  Perhaps there will be an
Infinite HZ holographic laser/time warp operated CPU someday :-)  (Inside joke:
 Would Papy make a CPU patch for this as quickly as they did for the 1.4 GHz if
it didn't work right away?  WOW, was that fast! ;-))

  2.  I wrote something similar to a "rigid-ring" tire model for low
speed/stationary movement.  This treats the tire and wheel as two seperate
things that can rotate around each other like a torsion spring.  The angular
difference between the two "rings" is multiplied by a spring rate, which
provides a forward/aft force and torque, and is damped by the difference in
rotational velocity.  It works great for slow motion stuff, although it's
tricky to adjust it so you don't notice the sudden change between the low and
regular (high speed) model.  It also doesn't deal well in certain situations
with my differential gear code if the diff unlocks, so it isn't perfect, but it
lets you stop on hills or move slowly up and down them with no stability
problems and without resorting to absurdly high sampling frequencies.

      As far as the lateral (slip angle) stuff goes, my experience is the same
as what Ruud mentioned in that letting the slip angle oscillate quickly between
high negative and positive slip angles is usually unnoticeable, even at low
speeds, and lets the car stop sideways on embankments.  I haven't put anything
special in my system to handle this, and you can only see the oscillations when
I've got extremely high grip tires on a really light car, then it shakes just
like it has a big engine, so maybe it's not all bad ;-)  

    Still, if you've got a few bucks to pay SAE for the paper Ruud mentioned
and are mathematically inclined enough to work it, it's the best solution I've
seen for all the low speed problems.  I'm planning on using it as a basis when
it's time to get back into my tire model.

   Thanks for the slip ratio equation, I've currently got an IF block to handle
the different forward/aft movement vs. rotation combinations to make sure the
slip ratio is calculated correctly.  That's ugly and slow compared to Brian
Beckman's equation :-)

  I believe it's because the amount of longitudinal stretching in the tire is
dependent on slip ratio, rather than slip velocity (that's kind of circular
reasoning, but what the heck).  Imagine a piece of *** moving through the
contact patch from front to rear (ignoring distortion from tire radius change.)
 Imagine it's moving rearwards 1 m/s quicker than it would be in a free rolling
tire:

1.  In a tire that had a free rolling velocity of only 1 m/s, the piece of
*** would leave the contact patch twice as quickly as it would if it was
rolling freely.  If the contact patch was 1 meter long (big tire!), it would
have stretched out of place .5 meters from where it should be in a free rolling
situation.  If a longitudinal tire spring rate could be estimated at
1000N/meter, you'd now have 500 N of force.  The tire acts like a big ***
band, so the amount of stretching (.5 meters in this case) is what causes the
force.

2.  In a tire that had a free rolling velocity of 100 m/s, the piece of ***
would leave the contact patch only 1/100th more quickly than it should.  That
would only amount to a tiny amount of stretching in the print (.01 * .5 meter
print = .05 meters ahead, instead of .5 meters ahead.)  Multiply that by our
1000N/meter spring rate and you'd only have 50 N of force.  

     Anyway, I don't know if my math is quite right there, but maybe the reason
is apparant now anyway.  The slip "velocity" in both cases is identical at 1
m/s slip.  If you tried to find the amount of stretching using different
velocities calculated from a constant slip ratio, the amount of stretching
would probably be constant.  Therefore, since the "***band" is stretched out
of shape the same amount, it'd make the same force.  Make sense?  

Todd Wasson
---
Performance Simulations
Drag Racing and Top Speed Prediction
Software
http://www.racesimcentral.net/

For the slip angle this is not entirely true, since sliding sideways
will never get you at the exact 90 degree slipangle (or was it the 180
degree case). May be good enough just the same.

Actually, Chris does that when things get stiffer (or you get to the
bumpstops), IIRC. Well, perhaps the whole frequency goes up in that
case, but it's the same idea, based on the situation at hand.

Actually, they had seen the problem in N4, and it was a 32-bit counter
that needed to be 64-bit (or 16 vs. 32). But still, yes, the fix was
there fast. :)

Sounds good; I'd have thought the longitudinal spring coefficient are
so stiff that you STILL need high frequencies. This is the method
somewhat in SAE980453 (may need to shuffle the 453 ;-) ), although
that one uses a real 3D spring to fix things. Has its problems (read:
things it doesn't support like camber), so I recommend SAE950311.
Problem also is to get the 3 stiffness coefficients. Pacejka numbers
are easier to guess almost. :)

You can add that to your list of features! ;-)

I'm just still confused about the damping, but should bring that back
after I've gotten energy back to work on that part again...

It's also explained in that 200+ page PDF thesis btw. Including the
implications for SAE950311 (another abs()).

Uhm, nice weather here today. ;-)

Ruud van Gaal, GPL Rank +53.25
Pencil art    : http://www.racesimcentral.net/
Free car sim  : http://www.racesimcentral.net/

Right... erm... <carefully ensures brain is in gear>

Okay, bug 1: the *torque* applied by the brake, to the wheel is
*exactly* equal (and opposite) to the torque applied by the tyre (due
to the tractive force produced).  If they were different the wheel
would accelerate (either +vely or -vely, i.e. decelerate).

Remember that for friction "F <= mu N", not "F = mu N".

Now, back to the original question.  We have two free bodies (the car
and the wheel/axle) plus the ground.  (Not for nothing is my nickname
"first principles" on the polo shirt I'm wearing ;-)

- Engine (i.e. car) applies a torque to the wheel, which applies the
same torque back to the car (see Newton, law 3) (causing a small
amount of weight transfer - but I'll ignore that unless you /want/ me
to go into it).

- Tyre (i.e. wheel) accelerates (rotates), acquires a slip ratio and
so generates a tractive force.  Wheel pushes back on ground, ground
pushes forward on wheel.

- Wheel pushes forward on car (at axle bearings).  Car applies equal
and opposite reaction force through bearings.

We now have two equal[1] forces on the wheel: the ground pushing it
forwards, and the car pushing it back.  However, these are offset by
the tyre's rolling radius and so although there's no overall *force*
on the wheel (it's all transferred to the car) there is a *torque*,
which in equilibrium is equal to that applied by the drivetrain.

Does that help?
Jonny

[1] They're not *quite* equal since some force is used in accelerating
the wheel *forwards* (as opp. rotationally).  But we'll conveniently
ignore that for now.

I've just found one big problem with locking the wheels when pressing
the brake button, as we all know due to the traction circle, if the
wheels are locked the longitudinal force is the maximum -ve force
possible so there is not place on the 'circle' left for lateral
forces. Result, I just go straight on and slam into the tires :-(

This all means that I'll have to do some proper braking code sooner
rather than later ;-)

Colin

  This is still an area most of us are not clear on yet.  Ruud allows two
different types of friction circle activity to occur.  I'm doing it the way you
are right now, where once a wheel locks, the longitudinal force goes to
maximum, and there is zero force left for lateral control.  In other words, I'm
calculating slip ratio and longitudinal force first, then, "just enough" force
is applied in the lateral direction to keep inside the friction circle (if slip
angle indicates the force is too large.)

  I don't think this is correct though.  If a tire was running at a 10 degree
slip angle, for example, and was locked, there would still be lateral
distortion in the print, so there would still be lateral force.  Ruud talked
recently about and allows a "vector trim" approach, where the entire slip
velocity is trimmed down to contact the edge of the friction circle, thus
allowing for some lateral forces to be developed.  This probably is more
correct, as a car sliding sideways at 90 degrees with locked tires will
certainly develop a lateral force!

Todd Wasson
---
Performance Simulations
Drag Racing and Top Speed Prediction
Software
http://PerformanceSimulations.Com

This sounds similar to what I do. I first define the vector that results
from lateral and longitudinal forces (without clipping to friction). I then
calculate the length of this vector. If this exceeds the maximum force
allowable due to friction, I clip to the outside of the friction circle
(keeping the same vector direction), so the situation where you can't get
any longitudinal or lateral force never arises.

This seems to work quite well for me, and I'm sure it's the correct way to
do things. All that's happening is that you're making sure that the force
applied to the tyres doesn't exceed the friction limit. The force is a
combination of lateral and longitudinal forces, and there's not really any
reason for clipping each one seperately - the two directions are not
independent as far as friction goes.

A good way of doing things properly is explained here:

http://www.esbconsult.com.au/ogden/locost/phors/phors.htm

Check chapters 24 & 25. Basically, you need to first calculate the
combined slip and its components, and use these to explicitly (without
clipping) calculate both the lateral and longitudinal forces from the
equations for separate longitudinal and lateral response. This approach
returns the same results as the separate operation when there is only
slip ratio or slip angle present without the other.

-Gregor

Ruud van Gaal, GPL Rank +53.25
Pencil art    : http://www.marketgraph.nl/gallery/
Free car sim  : http://www.marketgraph.nl/gallery/racer/

I think I apply the forward forces at the wheel's roll center, but I'm
not really simulating rod links very well so this is the best I could
do perhaps. Feels ok-ish, but have no idea whether the rollcenters are
on the mark. :)

Ruud van Gaal, GPL Rank +53.25
Pencil art    : http://www.marketgraph.nl/gallery/
Free car sim  : http://www.marketgraph.nl/gallery/racer/

This makes it not a function of the direction the SAE
tire axes are pointing, unless your combined slip model
is sophisticated enough to impose this boundary condition.

--
Matthew V. Jessick         Motorsims

Vehicle Dynamics Engineer  (972)910-8866 Ext.125, Fax: (972)910-8216

agreed. That's why I use directly the components of the slip velocity
(velocity_size*sin(slip_angle) and
Omega*R-velocity_size*cos(slip_angle), and in my program I explicity
calculate the slip velocity vector to get these two components) divided
by the size of the velocity to do my calculations instead of slip angle,
slip ratio. For small slip angles, the definitions are equivalent
anyway, but for larger ones this one is more natural and gives the
correct locked wheel behaviour.

-Gregor

  That's what I was thinking too.  Otherwise, front tires that are locked can
generate steering forces, like they do sometimes in my stuff ;-)  Glad to know
you feel this way about it.
Todd Wasson
---
Performance Simulations
Drag Racing and Top Speed Prediction
Software
http://PerformanceSimulations.Com

Just have 1 NDE (Near Death Experience) and you'll know for all time.
In fact, getting of the brakes at one time saved me from hitting a
sudden line of cars, and I could steer onto the exit lane (that I was
supposed to take, mind you :) ).

Just didn't have the time to test how soon it started to loose all
steering control, hehe. (in other words, at what point does the tire
really begin to act like a block of *** instead of the normal
flexing and all that).

Ruud van Gaal, GPL Rank +53.25
Pencil art    : http://www.racesimcentral.net/
Free car sim  : http://www.racesimcentral.net/