Inject spacecraft directly into circular parking orbit of altitude 100km. At burnout flight
path angle is zero and velocity is
Even though launch at equator (line of nodes), Orbit has an undesired
This target satellite was
After you rendezvous with the first satellite, you need to transfer to a second satellite in
GEO which was
Finally after making one complete orbit with this second satellite you need to take your final
position in GEO which is another
Design the above sequence. You may opt to minimize the time to complete or the fuel
needed
No drag while in LEO orbit. This allows the spacecraft to orbit as many times as needed to improve rendezvous conditions with the first target in GEO.
All impulses applied are assumed to have infinitely small time durations.
In addition, all assumptions used to derived Kepler equation apply as well.
Launch site latitude effect on
The geometry of the problem is illustrated in the figure below, which depicts the state of
the system at
The analysis part will show an outline of the maneuvers to achieve the goal of the project.
The criteria for selecting the maneuvering sequence is:
The minimization of fuel
Which directly relates to the minimization of the
Now, we will show each phase of the maneuver, with different scenarios to achieve each phase. Before starting, there are common calculations that will be done now that will be shared by many scenarios, so that we do not have to re-calculate these each time.
For the Hohmann transfer from LEO to GEO:
Let
Let
Let
Let
For the LEO and GEO orbits:
Let
Let
Let
Let
Let
let
Then
so,
so,
The problem is that we are given two non-coplanar circular orbits of different radices. A LEO orbit that is inclined at an angle to the plane of another, and larger circular GEO orbit.
We wish to transfer from the inclined (
We must correct the plane inclination to be able to transfer to the desired GEO orbit.
There are 3 possible ways to achieve this1:
Now, we will analyze each case above in details and find the
Move from the initial circular parking orbit (which has
Next, and immediately, apply a coplanar Hohmann transfer (2 impulses) to transfer from the LEO orbit to the outer GEO orbit. (We Can combine the inclination correction velocity impulse vector with the first Hohmann velocity impulse vector using vector additions.)
This is illustrated in figure below.
To find impulse 1:
hence,
To find impulse 2:
(speed up).
To find impulse 3:
(speed up).
Hence, total impulses is found by summing the above
Transfer from the initial LEO orbit (which has
This is illustrated in figure below.
To find impulse 1:
To find impulse 2:
(speed up). To find impulse 3
In this scenario, we will apply a partial orbit plane correction at the perigee and the remaining correction at the apogee. See figure below.
At the perigee of the Hohmann transfer, apply the law of the cosines to obtain
To find the minimum
To solve for
The function returns back the angle
For an initial guess for
Applying Newton iterative root finding:
The tricky part in this problem was finding a good initial guess for the root (common problem with using Newton roots finding method).
I had to try different values for an initial guess before the root was converged to. For
example, when I selected
For this design project, we are given that
is the solution. Hence, this is the angle I will use for the correction to apply at the perigee.
So, at the perigee, Apply a correction of
To find the impulse needed to correct inclination at the perigee and transfer from LEO to a
Hohmann orbit with a correction of
so,
To find impulse needed to correct inclination at the apogee and transfer from Hohmann to
the GEO orbit for an angle
so,
So, for this scenario, total
Comparing the
scenario 1:
scenario 2:
scenario 3:
So, we can see that splitting the plane correction between the perigee and the apogee points leads to a more economical maneuver.
Hence Choose scenario 3 for the next sequence.
The vehicle was at the lines of node at
The above time is the same regardless if we inject at one end of the lines of nodes or at the other end. Also, this time is independent of what inclination the Hohmann transfer orbit was at the time of injection.
In the previous step, the time it takes to move from LEO to GEO over a Hohmann orbit was found.
Now, find when to make this transfer. That is, we need to find the time to inject into the
transfer orbit such that the overall
The injection must occur when the space vehicle is on the line of nodes. Since this line is where the LEO and the desired GEO plane intersects at.
Hence, there are only 2 points on the LEO orbit that we can use to launch to GEO. (Both ends of the lines of nodes, at both sides of earth). Let me call one end of the lines of nodes, the top end, and the other end, the bottom end. Where the top end is that end which the spacecraft was at when it first reached LEO, i.e. at time=0.
In addition to the above restriction, if we want to eliminate the need to make any phasing
loops when we arrive at the desired GEO orbit in order to rendezvous with the first target,
then injection must occur only when the correct lead angle
We know that the synodic period between LEO and GEO is
But due to the restriction that this radial vector be only the lines of nodes of the space vehicle, using this synodic period is not too much help for me here.
So, what options do we have?
These are the options to investigate:
At the end, select the option which gives the smallest
we know that at
From previous calculations, we found the time needed for space vehicle to reach
GEO orbit is
Hence When Vehicle reaches GEO, the first satellite will be (see diagram)
behind the space vehicle.
Hence
The reason a minus sign is used, is because
For
Hence
Hence
For
Hence
Continuing the above process, I obtain this table.
|
|
Period of phase orbit (in days) | Total time in phasing period in days |
|
|
|
|
|
|
|
|
|
|
|
|
|
| | |
| | | |
| | | |
|
|
|
|
|
|
|
|
|
|
|
|
Any one of the above choices for
Plotting
Figure above shows that most saving in fuel is made by staying in the phasing orbit for less than 20 days. For more than 20 days, the additional saving in fuel is not justified by the time wasted in the phasing orbit.
Zooming in the region of interest in the plot shown in above figure results in figure below
From the above, it is clear that the slope after 6 days in the phasing orbit is less steep than
earlier. The two options I see is to choose
For
For
Since the fuel saved is so small compared to the initial fuel needed to send the vehicle into GEO orbit, I decided to use the smaller time here.
Looking at above figure, the problem can be seen as the following: we need to find the time it
takes for the spacecraft to be at the top end of the lines of nodes when the target is at the
correct lead angle
How do we find this time value?
First, find
Travel time for spacecraft is half the Hohmann orbit period =
Travel time
Where period
Hence, and since
Solve for
So, now that we know
The angle that the target will move by for each one full period that the spacecraft makes in
the LEO orbit is
Exactly,
Hence, target will travel
Now that we know the angle the target will travel for each one full LEO period, we need to
find how many times we have to do this so that target will end at the correct
This becomes a simple counting problem. If we imagine a straight line, starting at t=0, and
then we move a stick from its left end to its right end at an equal increments of 21.68 units,
we just need to find when this stick will land at the correct point (or close enough) on the
line where the point
When the stick reaches the right end of the line, we carry the reminder back to the start of the line and continue the process.
Figure below shows how to do this counting. Notice that the point I am interested in
finding, which is the angle
So, the point on the line we are looking for is
Figure below shows how the counting is actually done.
I wrote a small MATLAB3 function called nma_findPointOnLine.m to do the counting. This function accepts as input the step size, the length of the line, and the distance we are looking for (60.344 in the above example), and how close to the target we want to be (the tolerance).
It returns the number of steps needed to achieve the synchronization.
This is an example call
>> stepSize=21.68; lineLength=360; target=60.344; tol=0.1; >> nSteps=nma_findPointOnLine(stepSize,lineLength,target,tol) nSteps = 3274
This is the result of the MATLAB function
tolerance (in degrees) | number of LEO periods needed | time to achieve (seconds) | time in hrs |
1 | 36 | | 51.89 |
0.1 | 3274 | | 4719 |
It is clear that to achieve synchronization to 0.1 degree is too costly in time.
For the case of 1 degree tolerance, it will take 36 LEO loops to achieve the optimal situation
with the target at the correct
This means, if we spend this time in LEO, we can inject and will meet the target at the same
time when we reach GEO. Hence no additional
This case is the same as above, except now we want the spacecraft to be at the other end of
the lines of nodes at injection. The only difference is that now t=0 have been shifted to
become time after making one half LEO period. We can find this shift since we
know the angle the target will travel in one half LEO period. We found from above
that target will travel
So, the only thing we need to do is determine where the point is located that we need to synchronize with, as illustrated by the figure below.
So, use the same MATLAB function to find the number of full LEO rotations needed.
>> stepSize=21.68; lineLength=360; target= 231.544; tol=0.1; >> nSteps=nma_findPointOnLine(stepSize,lineLength,target,tol) nSteps = 3614 >> nSteps=nma_findPointOnLine(stepSize,lineLength,target,1) nSteps = 293
Hence, we see that for a tolerance of 1 degree, we have to wait 293 full LEO loops.
Compare this with the earlier case where we looked for the other end of the lines of nodes, which achieved the same synchronization for only 36 LEO loops. Hence this maneuver will not be accepted.
To solve this problem, I will calculate the lead angle
At
Figure below illustrates this case.
Total time from epoch to reach GEO
Hence, angle that the GEO satellite will travel in this time is found from
Hence When Vehicle reaches GEO, the first satellite will be
At
Total time from epoch to reach GEO
Hence, angle that the GEO satellite will travel in this time is found from
Hence When Vehicle reaches GEO, the first satellite will be
behind
At
Total time from epoch to reach GEO
Hence, angle that the GEO satellite will travel in this time is found from
Hence When Vehicle reaches GEO, the first satellite will be
Continue this process. The result is illustrated in this table
time | total time to reach GEO (sec) | |
|
|
0 | |
|
|
behind |
|
|
|
|
ahead |
|
|
|
|
behind |
|
|
|
|
ahead |
|
|
|
|
behind |
|
|
|
|
ahead |
|
| | | behind |
| | | | ahead |
| | | | behind |
|
|
|
|
ahead |
|
|
|
|
behind |
|
|
|
|
ahead |
|
|
|
|
behind |
|
|
|
|
ahead |
|
|
|
|
behind |
From the above table, we see that the closest the target gets to the lines of nodes (within the
first
What is left to do is to determine is the
Now, for the
Let
Let
Let
Let
Let
Let
First, find the period of the phasing orbit
for a specific
Then find
Where 5.8 is the slope of the line relating
Try the above for a number of different values for
For
Hence
Hence
I do not need to look for n=2 and higher for this case, since the saving in
For first option, move to GEO without phase-waiting in LEO, and instead phase-wait in
GEO, results in
For the second and third options, the time spend is all in LEO, and zero
For 4th option, part of time spend is in LEO, and some part of time spend is in GEO.
Notice that in this table, the
scenario | |
LEO loop | total time cost to rendezvous |
first. Inject at t=0 | |
0 | 52,426 (sec) |
second. optimal |
0 km/sec | 36 | 186,804 (sec) = 51.89 hrs = 2 days 3 hrs 53 minutes |
third. optimal | 0 km/sec | 293 | 1,520,377 (sec) |
fourth. smallest |
|
6 | 133,820 (sec) = 1 day, 13 hrs, 10 minutes, 20 seconds. |
Clearly option 3 is bad. With option 2, we get the same saving for much less time.
Between options 1 and 4, I prefer option 4, since for the cost of about 1.5 days, we reduced
So, the final choice is between option 4 and option 2.
With option 2, we have zero
Compared to the
Will not consider option 2 as the time needed is not worth the saving in fuel.
Option 4 is selected
Simply perform an in-orbit repositioning using a phasing orbit to rendezvous with the second
satellite. The second satellite is
|
|
Period of phase orbit (in days) | Total time in phasing period in days |
|
|
|
|
|
|
|
|
|
|
|
|
|
| | |
| | | |
| | | |
|
|
|
|
|
|
|
|
|
|
|
|
Plotting
Similarly, at
However, since the fuel saved as a percentage of initial fuel is small, it does not seem that
spending extra 6 days in orbit is worth it. I will use
Also, since from the specifications, it seems that it says that the second satellite needs to be
reached quickly, so I choose
Stay in orbit for one complete orbit revolution. This adds one day to the total time in flight.
No additional
Perform an in-orbit repositioning using a phasing orbit to reposition
Apply the same process of in-orbit repositioning to decide on the procedure to select. This table was generated:
|
|
Period of phase orbit (in days) | Total time in phasing period in days |
|
|
|
|
|
|
|
|
|
|
|
|
|
| | |
| | | |
| | | |
|
|
|
|
|
|
|
|
|
|
|
|
As before, choose
This completes the required sequence.
See figure below for the final decision tree.
This is a summary, in table format, of the entire orbiting sequences using the most
sequence: Inject to LEO. wait in LEO for 6 full orbits. Perform Hohmann transfer with partial plane correction at each end. phase-wait in GEO to rendezvous with first target. Phase-wait in GEO to rendezvous with second target. Lock into second target. Reposition to final location in GEO.
sequence | |
duration |
wait in LEO | 0 | 50,050 (sec) |
Hohmann transfer | 4.0716 | 18,916 (sec) |
Rendezvous with 1st target | 0.0598 | 83,770 (sec) |
Rendezvous with 2nd target | 0.255 | 98,131 (sec) |
lock with 2nd target | 0 | 86,400 (sec) |
position to final destination | 0.02868 | 87,360 (sec) |
TOTAL | 4.41508 | 424,627 (sec)=117.95 hrs = 4 days 21hrs 57 min |
To reach LEO, we have found that
For the drag effect, it of course depends on the rocket cross sectional area, the drag
coefficient and air density. A typical value I have seen in the literature for rockets is to use
Hence total
Hence the total
see figure below for a graphical display of the deltaV used at each stage.
This is the MATLAB function that solves for
Caller script:
function nma_testfindAlphaForMinDeltaV r0 = 6378.145; r1 = 100+r0; r2 = 35860+r0; beta = 15; mu = 3.986012*10^5; alpha = nma_findAlphaForMinDeltaV(r1,r2,beta,mu)
This is the function that solves for alpha.
function alpha=nma_findAlphaForMinDeltaV(r1,r2,beta,mu) %function alpha=nma_findAlphaForMinDeltaV(r1,r2,beta,mu) % % Finds the minimum alpha (initial inclination correction) % for an orbit relative to a larger circular orbit. % see design note for more details. % %INPUT: % r1: The radius of the smaller circular orbit % r2: the radius of the larger circular orbit % beta: the angle, in degrees, in which the two % circular orbits are non co-planers to % each others. % mu: gravitational constant % % OUTPUT: % alpha: The angle in degrees to use for initial % correction such that minimum delta V is % obtained to move from the smaller circular % orbit to the larger circular orbit % % Author: Nasser Abbasi % May 19,2003 a = (r1+r2)/2; rp = r1; ra = r2; Va=sqrt( mu*(2/ra - 1/a )); Vp=sqrt( mu*(2/rp - 1/a )); Vc1=sqrt( mu/r1 ); Vc2=sqrt( mu/r2 ); beta=beta*pi/180; \end{Verbatim} \newpage\begin{Verbatim} root(1)=0.1*beta; keepLooking = true; i=0; while(keepLooking) i=i+1; root(i+1)=root(i)- ( F(Vc1,Vc2,Vp,Va,root(i),beta)/dF(Vc1,Vc2,Vp,Va,root(i),beta) ); root(i+1) if( abs ( (root(i+1) - root(i)) / root(i+1) ) * 100 < 0.001 ) keepLooking=false; else if( ( root(i+1) * root(i) )<0.0) error('jumped out of root'); end end if(i>100) error('Failed to converge'); end end alpha=root(end); alpha=alpha*180/pi; %%%%%%%%%%%%%%% % % %%%%%%%%%%%%%%%% function v=F(Vc1,Vc2,Vp,Va,alpha,beta) v=Vc1*Vp*sin(alpha)*sqrt(Vc2^2+Va^2-2*Vc2*Va*cos(beta-alpha)) ... - Vc2*Va*sin(beta-alpha)*sqrt(Vc1^2+Vp^2-2*Vc1*Vp*cos(alpha)); %%%%%%%%%%%%%%% % % %%%%%%%%%%%%%%%% function v=dF(Vc1,Vc2,Vp,Va,alpha,beta) v=Vc1*Vp*cos(alpha)*sqrt(Vc2^2+Va^2-2*Vc2*Va*cos(beta-alpha)) ... +Vc1*Vp*sin(alpha)* ... ( -Vc2*Va*sin(beta-alpha)/sqrt(Vc2^2+Va^2-2*Vc2*Va*cos(beta-alpha))) ... - (Vc2*Va*cos(beta-alpha)*sqrt(Vc1^2+Vp^2-2*Vc1*Vp*cos(alpha)) ... + Vc2*Va*sin(beta-alpha)*... ( Vc1*Vp*sin(alpha) / sqrt(Vc1^2+Vp^2-2*Vc1*Vp*cos(alpha)))); \end{Verbatim} \newpage\begin{Verbatim} function nSteps=nma_findPointOnLine(stepSize,lineLength,target,tol) %function nSteps=nma_findPointOnLine(stepSize,lineLength,target,tol) % % Function to find how many steps needed to reach withing tolearance % close to a point on a line by taking fixed number of steps. Line wrapes % around. % %INPUT: % stepSize: the step size % lineLength: The line length % target: The distance from leftend of line that we want to reach % tol: tolerance in abs. value % %OUTPUT: % nSteps: number of steps needed % %Author Nasser Abbasi. May 22, 2003 % currentDist = 0; nSteps = 0; while true currentDist = currentDist+stepSize; nSteps = 1; while(currentDist <= lineLength) if( abs (currentDist-target) < tol ) return; end rem = lineLength-currentDist; if(rem < stepSize) currentDist = stepSize-rem; else currentDist = currentDist+stepSize; end nSteps = nSteps+1; end end