Guarantee angle of incidence range during an orbit

Orekit Python Wrapper usage
1

Dear all,
I am currently try to simulate the performances of a spacecraft with a payload characterized by a range of incidence angles on ground. The method I have used in the past consisted on fixing a roll angle for the whole simulation, and around one body axis I centered a DoubleDihedralFieldOfView in which one angular aperture is very close to 0, and the other is representative of the aperture of the antenna. In this way, I obtain with the method getFootprint the range (on a line) of points seen on the ground characterized by that FoV.

If tuned correctly adopting spherical Earth geometry, it is possible to estimate roll and FoV angle based on the incidence angles, used as constants throughout the orbit. I wanted to know whether it is possible to use only the incidence angles on ground as inputs instead, and modify during the propagation the roll angle of the spacecraft to guarantee this incidence angle range on ground, since there are variation caused by the oblateness of the Earth.
To speed up the procedure one could also just maintain an attitude fixed with LVLH (without roll rotation) and create one or more FoVs around some body axes vectors, but the vector around which the FoV is centered shall change during the propagation, to be representative of the roll rotation.

Furthermore, would adopting the mean elements for the propagation still be good for the coverage analysis? In the past I have adopted a numerical propagator, with the aid of @luc , in which a correction of the orbital semi-major axis estimated the correct osculating semi-major axis to be used as input for the repeating ground track orbit.
Using a propagation with mean elements is faster and also skips this step, since I could directly use the average semi-major axis obtained from theory for a RGT orbit. I was wondering whether this solution would provide realistic values for the coverage, or not.

Thanks,
Antonio

2

Hello, I wanted to ask some further advice since the topic did not have any reply. As a simplification I am using constant values for the FoV boresight direction and aperture, assuming that the angle of incidence variation is low.

Is there any method (maybe a detector) that helps with the evaluating when a point of interest on ground (lat/lon) is within the antenna footprint of a satellite? The method I am currently using now defines a satellite body fixed FoV to project on ground what is the antenna footprint at each propagation step. Afterwards, I extract the extremes of the antenna footprint in lat/lon, obtaining the ground range that is currently seen by the antenna. I then interpolate between every swath on ground to have a representation of the continuous footprint of the antenna during the repeat cycle. This method has got many limitations:

  • To evaluate whether a point on ground is within the swaths, since every swath is discretely defined, I am manually constructing in post-processing a polygon between each state a polygon made by two successive swaths. Therefore, the continuous footprint is approximated between each time-step.

  • Due to this method, I need to have very small timesteps (in terms of 10/20s) to have a realistic continuous footprint and this slows the propagation, made as shown below.

    positionTolerance = 1E-1
    step_time = 10. 
    tolerances = DSSTPropagator.tolerances(positionTolerance, initialOrbit)
    integrator = DormandPrince853Integrator(1e-3, step_time,
                                            orekit.JArray_double.cast_(tolerances[0]), orekit.JArray_double.cast_(tolerances[1]))
    dsst_prop = DSSTPropagator(integrator)
    degree = 20
    order  = 20
    unnormalized = GravityFieldFactory.getUnnormalizedProvider(degree, order)
    zonal_force = DSSTZonal(unnormalized)
    tesseral_force = DSSTTesseral(itrf, Constants.WGS84_EARTH_ANGULAR_VELOCITY, unnormalized)
    earth = OneAxisEllipsoid(Constants.WGS84_EARTH_EQUATORIAL_RADIUS,
                             Constants.WGS84_EARTH_FLATTENING,
                             itrf)
    forces = [zonal_force, tesseral_force]
    [dsst_prop.addForceModel(f) for f in forces]
    dsst_prop.setInitialState(initial_state, PropagationType.MEAN)
    attitudeProvider = LofOffset(inertialFrame, LOFType.LVLH_CCSDS, RotationOrder.XYZ, 0.0, 0.0, 0.0)
    dsst_prop.setAttitudeProvider(attitudeProvider)
    t = [epochDate.shiftedBy(float(dt)) for dt in np.arange(0, duration+step_time, step_time)]
    spacecraft1 = [dsst_prop.propagate(tt) for tt in t]
  • The antenna footprint is obtained as follows:
    LL_vec = Vector3D([0.,-np.sin(radians(roll)), np.cos(radians(roll))])
    SARfov = DoubleDihedraFieldOfView(LL_vec, Vector3D.PLUS_I, radians(FoV/2), Vector3D.PLUS_J, radians(0.000001),  0.0)
    inertToBody = [x.getFrame().getTransformTo(earth.getBodyFrame(), x.getDate()) for x in spacecraft1]
    scState = [SpacecraftState(x.getOrbit()) for x in spacecraft1]
    fovToBody = [Transform(x.getDate(),
                           x.toTransform().getInverse(),
                           y) for x, y in zip(spacecraft1, inertToBody)]
    footprint_leftLooking = [SARfov.getFootprint(x, earth, angularStep) for x in fovToBody]

Is there a faster way to evaluate the revisit of a zone with a sensor?

3

You can look at FieldOfViewDetector, it is configured using the FieldOfView defined at satellite level, and a PVCoordinatesProvider that defines the target, i.e the ground point you want to look at. As TopocentricFrame implements PVCoordinatesProvider, you can use to TopocentricFrame as the target.

Beware however that this detector just look at the target as a point and does not know about the full Earth shape, so it may consider visibility occurs more often than reality, as if the Earth was transparent. So you would probably want to combine this detector with an ElevationDetector.

4

Thank you for the answer @luc, I have also found other topics mentioning this application and I will try to use this method. I have some further questions:

  • If I have multiple targets on ground and I want to check the visibility of each one, should I create a detector for each target?
  • This works fine for “point” targets, but what if one would like to have a coloured map of revisit time over a given area over the Earth, with an input grid and not on single target points?
  • Finally, what I have noticed is that adopting “FieldOfViewDetector” provides me a pass only if I change the aperture of the FoV in the azimuth direction too: as can be seen in the previous snip of the code, since I was only using the extremes of the swath on ground to obtain information of the passes, the detector was not outputting any result. To obtain results I have to insert a not-null aperture in the azimuth direction, which I guess is needed since if the time-steps are too large the target is never within the FoV. This also requires me to not adopt step-times that are too large, otherwise I do not get any pass. Would it be possible to not be dependent on time-steps and azimuth FoV?
5

Yes, you have to use one detector for each point.
If you want to plot a colormap, this will not be well suited.
This this thread for a discussion about this.