In this video, we're going to look at depriving the Tuti tracking system process model.
So looking at how we can derive the equations of motion and put them into the matrix form that we want.
So here we have the equations of motion, we have the acceleration, we have velocity and we have position.
So we know that acceleration here is a second order differential equation.
So what we can do is break it up into two first order equations like we've shown in the past, one four
velocity, one four position.
So solving this equation, assuming a constant acceleration, we can get the standard relationships
that we've seen before.
So these are basically saying the velocity of an object is equal to the initial velocity plus the acceleration
and the amount of time that's applied.
The same thing can be said about position.
The position of an object is equal to the initial position, plus the time at the initial velocity,
plus a half, eight squared.
So half of the acceleration value eight times the time squared of the time it it's accelerating.
So if we look at the acceleration, this is basically saying if we have a constant acceleration, we
get a profile that looks like this.
So we have one value that's held over a time period.
Now, over this time period, we have the initial velocity v note and it'll be accelerating at a constant
rate.
The acceleration up to this kind of the V here at time T and if we have a look at the position, we
can see the same thing.
We can start with initial position, but this time we have a quadratic relationship to the final position
at T, and this is because we have a constant acceleration.
We have a first order increase in velocity, which means we get a second order increase in our position.
So these are our first order equations.
Now, these aren't differential equations anymore because we've solved the differential equation, but
we can put this into a matrix form.
So to do that, we can basically break it down into our position and velocity, so these become our
states, we get a state matrix that looks like this.
So this is basically saying the position in the final time is equal to pay, not plus tee times velocity,
initial Qawasmi, plus an acceleration value multiplied by these coefficients here.
And the same thing can be said about velocity.
Velocity is going to be Alvino plus our acceleration value eight times the time it's applied.
So this matrix equation form here, it's just the matrix form of these equations.
Now we can basically convert this into a discrete time by saying are we not here?
Is going to be OK minus one Alvie here is going to be OK and we're going to have a timestep of Doherty.
So we set is a utility and basically we just make the substitutions here, here.
So it's exactly the same equations except now we have to timestep k k minus one and timestep delta t.
So these become our discrete time equations that they're going to use for the common Philidor.
So we have to durata the equations for a one dimensional example that has a versity and a position in
one dimension.
So now we're going to extend this into a two dimensional example.
And to do this is fairly straightforward.
All we have to do is just put the systems together for the X and Y, so the X and Y are just going to
be independent of each other, but they're just going to be replications of the one dimensional example
that we had before.
So we have an API.
So the position in the X position in the Y, we have a V, X and a V, why?
So the velocity in the X velocity in a Y and as you can see, if you look at the sub matrix for P,
X and the X, it's just going to be the same one as we had before.
An assembly for the P p, y and the VI is just going to be another replication of it before.
So this matrix has no cross coupling between the X and Y axes, but that's fine to do in this example.
And we can see for the input.
Again, it is the same thing here.
So now we have a X and Y for the acceleration, the extraction and acceleration in Y direction.
They have one problem with this example is that it requires an input vector input vector of the accelerations.
So this becomes a problem because we can't have acceleration sensors on board the object that we want
to track for this example.
So basically, we can't have an input because it doesn't fit the problem.
So what we do instead, instead of having a known deterministic input, we assume that the input is
just going to be due to noise.
So basically we model the same matrix instead of a matrix.
We have an L matrix, which is exactly the same.
And instead of X and Y being a deterministic input, now they're random variables with a certain probability
density function and we assume it has a normal distribution of zero main and a sigma of this X and a
signal of a Y.
So basically, these two premies sort of become attuning parameters, they say they don't tell the system
how much we think the acceleration is going to vary in the extraction and how much we think it's going
to vary in the Y direction.
So we can't measure the acceleration directly.
So we have to assume that it is a random variable and let the common filter work it out implicitly.
So our precious motto becomes the process model shown on this slide here.
We have dropped the input and we assume that the only input into the system is going to be from the
noise value.
So we have a noise value of Iwai, which are going to be part of a normal distribution with standard
deviation shown here.
We have our noise sensitivity metrics, which is just going to be now the copy of the input matrix.
But now we're going to use it as a noise matrix.
So we're going to have the process model here is going to be based on the current state, plus some
random input, which is going to be from the noise.
So this formed this great process model that we're going to use in the common field of the state, Vector
X is going to be a four dimensional vector.
It's going to have states X, P, Y, the X, V, Y.
So the position and the X, Y and Vosta in the X, Y, the state transition matrix is going to be the
simple concept matrix here, which is going to be a function of the timestep.
And then we're going to have this noise input matrix here, which also is going to be a function of
the time.
Skip step.
And it's going to be the input is going to be based on these two noise distributions here, which each
have a standard deviation of some value for the noise density.