0

I have the celestial coordinates of the center of telescope image, the telescope's field of view (in seconds), the start time of taking photo (full date), and the exposure time (in seconds). And I want to know how many Starlink satellites can get into the image frame. I cannot figure out how to calculate this correctly. I don't understand the celestial coordinates very well. I tried to use Skyfield api, geocentric coordinates and assume that the telescope is pointing up. But it is too long and isn't working correctly...

This is what I tried to do so far.

import skyfield.timelib
from skyfield.api import Topos, load
from datetime import timedelta

def satnum(start_time, exposition, eq_cords, field_of_view):
    """Counts number of satellites

    Arguments
    ---------
    :param start_time: skyfield.timelib.Time object
    :param exposition: int
    :param eq_cords: list of floats
    :param field_of_view: int

    Returns
    -------
    :return: int


    Examples
    --------
    import satnum
    start_time = [2020, 12, 14, 18, 00, 00]
    exposition = 15
    eq_cords = [4741.1, -2257.7, 4505.7]
    field_of_view = 45
    satnum.satnum(start_time, exposition, eq_cords, field_of_view)
    0
    """

    url = "https://celestrak.com/NORAD/elements/starlink.txt"
    satellites = load.tle_file(url)
    sat_counter = 0
    ts = load.timescale()
    eq_cords = Topos(*eq_cords)

    for satellite in satellites:

        difference = satellite - eq_cords

        for n in range(exposition):
            time = ts.utc(start_time.utc_datetime() + timedelta(seconds=n))
            topocentric = difference.at(time)
            altaz = topocentric.altaz()
            if altaz[0].degrees >= 90 - (field_of_view/2)/60:
                sat_counter += 1
                break

    return sat_counter

I'd be appreciate any ideas.

Oliver Wayne
  • 39
  • 8
  • 1
    I’m voting to close this question because this is not a programming question, but rather a question about astronomy, geophysics, and/or basic celestial math. It seems that whenever the OP learns how to accomplish the required task on paper, automating the code via a Python script will be a trivial matter. This makes this not a programming question. – CryptoFool Dec 27 '20 at 08:18
  • 2
    Hi Oliver, I appreciate your work. Very Nice. I dont have an exact answer but first I suggest you to try to do it manually. Otherwise, please share 2-3 sample inputs and expected outputs. – sam Dec 27 '20 at 08:20
  • 2
    Hi, Oliver! It just so happens that in the few hours since you asked this question, I have tried adding a new "Discussion" forum to Skyfield’s GitHub repository. It might be a better fit for a broad question like this one, that is less about any one specific programming or astronomy concept, and more about "how do I accomplish a big task, and what conceptual tools will I need?": https://github.com/skyfielders/python-skyfield/discussions – Brandon Rhodes Dec 27 '20 at 15:32

1 Answers1

0

A simple solution (if I understand your goal correctly), would be to simply calculate the surface number density of starlink satellites, and then multiply by the area of the telescope, which would give you the number of satellites you would expect to find in the field of view at any time. Then the probability of finding a satellite in that field of view would be determined from the poisson distribution (which assumes that the positions of the satellites and the pointing of your telescope is completely random, which is not entirely correct, but would give a good order of magnitude estimate).

So, if "#" is the total number of starlink satellites, "A" is the area of your telescope view (in steradians), and the total area of the sky is 4*pi steradians:

Average number "n" of starlinks in a random pointing:

n = A * #/(4*pi)

Probability "P" of finding "k" satellites in a given pointing:

P(k) = n^k * e^-n / k!

atrapp
  • 21
  • 3