Is it possible to predict if an orbiting satellite will pass over a given point on Earth after n periods?

Question

I'm learning basic astrodynamics, and I have a question that I cannot find on the Internet (maybe I'm not looking hard enough).

My question is, is there a way to predict how many periods would a satellite need to pass over a specific point on Earth, if not in the current period, maybe in next n periods? or to calculate if it ever will?

Being more specific, let's say at some point in the current period the satellite will fly-over city A, but not in the city B. Now, we know that after each period, the orbit shifts westwards, meaning that it might not fly-over city A in that period, but it might fly-over city B. How do you calculate the number of periods, or the time, it would take for the satellite's orbit to be aligned with city B, if ever?

Here's a shitty image I drew for visualization purposes .. :)

Thanks! :)

Answer 1

Using Python code How do I determine the ground-track period of ... from uhoh:

and Great Circle Distances in Python from Chris Webb, I wrote a program to plot the distance of the ISS ground track to a given reference point on Earth during 4 days after November 17, 2020.

The minimum distance is 113.81 km, calculated every minute of 4 days. The ISS moves very fast, using a smaller stepsize changes the minimum found.

every 60 seconds of 2 days :  150.12 km
every 30 seconds of 2 days :   71.40 km
every 15 seconds of 2 days :   55.43 km

But a calculation for every 5 seconds of 4 days requires too much memory and time.

The orbit height and period of the ISS is not constant, see ISS Height. So only a prediction for some days is possible but not for longer time and eventual re-boosts.

import numpy as np
import matplotlib.pyplot as plt
from skyfield.api import Loader, Topos, EarthSatellite
import greatcircle

TLE = """1 44303U 98067QA  20320.43936697  .00008076  00000-0  12168-3 0  9990
2 44303  51.6405 305.3910 0005107 159.4387 200.6810 15.55769424 83251
"""

L1, L2 = TLE.splitlines()

load    = Loader('~/Documents/fishing/SkyData')  # avoids multiple copies of large files
data    = load('de421.bsp')
earth   = data['earth']
ts      = load.timescale(builtin=True)

minutes = np.arange(60. * 24 * 4)           # four days
time    = ts.utc(2020, 11, 17, 0, minutes)  # start November 17, 2020

ISS     = EarthSatellite(L1, L2)

subpoint = ISS.at(time).subpoint()

lon      = subpoint.longitude.degrees
lat      = subpoint.latitude.degrees

# great circle distance
if True :
    # reference point on Earth for distance calculation
    ref_point_lat = 49.619832
    ref_point_lon = 11.037711

    gc = greatcircle.GreatCircle()
    MEAN_EARTH_RADIUS_KM = 6371

    gc.name1 = "reference point"
    gc.latitude1_degrees = ref_point_lat
    gc.longitude1_degrees = ref_point_lon

    dist_km = np.zeros_like(lat, float)
    hours = np.zeros_like(lat, float)
    
    gc.name2 = "ISS"
    min_dist = 2.0 * np.pi * MEAN_EARTH_RADIUS_KM
    for i in range(len(lat)) :
        gc.latitude2_degrees = lat[i]
        gc.longitude2_degrees = lon[i]
        gc.calculate()
        if gc.valid == True :
            dist_km[i] = MEAN_EARTH_RADIUS_KM * gc.central_angle_radians
        hours[i] = minutes[i] / 60.

        min_dist = min(dist_km[i], min_dist)  # finding minimum distance
        
    print('minimum distance {: 5.2f} km'.format( min_dist))
        
    fig, ax = plt.subplots(figsize=(6, 6))
    plt.plot(hours, dist_km)
    ax.set_title("ISS pass over a specific point on Earth")
    ax.set_xlabel('time hours')
    ax.set_ylabel('distance km')
    plt.show()

Answer 2

I found it in the meantime:

Using the length_of function to check an arcminute length, a meridian, the equator and pole diameter:

from skyfield.api import Topos, load
from skyfield.functions import length_of

ts = load.timescale(builtin=True)
t = ts.utc(2021, 1, 1)

b1 = Topos(0., 0., elevation_m=0.0)
b2 = Topos(1. / 60., 0., elevation_m=0.0)
print(round(length_of(b1.at(t).position.km - b2.at(t).position.km), 5))

b3 = Topos(90., 0., elevation_m=0.0)
b2 = Topos(90.0 - 1. / 60., 0., elevation_m=0.0)
print(round(length_of(b3.at(t).position.km - b2.at(t).position.km), 5))

b2 = Topos(0., 1. / 60., elevation_m=0.0)
print(round(length_of(b1.at(t).position.km - b2.at(t).position.km), 5))

b4 = Topos(90., 0., elevation_m=0.0)
print(round(length_of(b1.at(t).position.km - b4.at(t).position.km), 3))

b5 = Topos(0., 180., elevation_m=0.0)
print(round(length_of(b1.at(t).position.km - b5.at(t).position.km), 3))

b6 = Topos(-90., 0., elevation_m=0.0)
print(round(length_of(b4.at(t).position.km - b6.at(t).position.km), 3))

#Meridianminute of geographic lattitude at the equator 1842.90 m,
#but at the poles 1861.57 m
#arclength of an arcminute at the equator 1855.31 m.
#a meridian from equator up to a pole 10,001.966 km
#equator diameter    12,756.27 km
#pole diameter    12,713.50 km    

The results are very precise:

• 1.8429 km
• 1.86157 km
• 1.85532 km
• 9004.939 km
• 12756.273 km
• 12713.504 km

Of course the meridian is measured thru the ground and not at the surface, therefore 9004.939 instead of 10,001.966 km, straight line, no great circle.