thesis/prelim_notes/paper_notes.md

Notes on Research Papers

Neural Networks in Time-Optimal Low-Thrust Interplanetary Transfers

• For the most part this paper isn't that relevant.
• It seems to be a low-fidelity method, or at least, it's fidelity is kind of hard to pin down, since it uses a neural net.
• However, the neural net is an interesting concept.
• And in fact, this paper advocates for a concept of using the neural net as a predictor. So, say, given a leg of a particular journey, as in the Englander paper, could I use this technique rather than Sims-Flanagan transcription in the outer loop?
• Something to consider as an alternative to the method proposed in Englander
• Could also be used to generate initial guesses for the single-shooting methods that I'll have to use if I use an indirect optimization method.

Design and optimization of interplanetary low-thrust trajectory with planetary aerogravity-assist maneuver

• I didn't realize that this paper is specifically talking about aerogravity assists. I don't think that level of complication is necessary for this paper. I'm going to stick with gravity assists that don't get into atmospheric effects.

Orbital and Angular Motion Construction for Low Thrust Interplanetary Flight

• This one actually isn't even about optimization. Not relevant
• To be honest, I don't actually understand it very well anyway

A Rapid Estimation for Interplanetary Low-Thrust Trajectories Using Support Vector Regression

• This is another machine-learning approach
• It uses a different approach that I'm not that familiar with (Support Vector Regression)
  • It looks like this is a form of regression similar to linear regression, I suppose being used by the machine learning algorithm for predicting optimal trajectories
• However, it seems like everything that applies in the neural net paper probably apply here as well
• This could be an alternative for predicting optimal trajectories over certain legs of the journey

Automated Solution of the Low-Thrust Interplanetary Trajectory Problem

• This is the Englander paper I mentioned earlier. It seems highly relevant as they're essentially doing what I'd like to do: producing an automated method for high-level interplanetary low-thrust mission design including the flybys.
• I need to look up MALTO and GALLOP (established tools that do this)
• This paper also open sources it's code: available here
• This paper formulates the problem as a Hybrid Optimal Control Problem. This requires some further research by me, but from the paper it seems to be a way of optimizing two seperables subproblems where one of the subproblems exists as a sub-loop of the other problem (for instance optimizing flybys in a high-level loop and particular planet-to-planet trajectories as a sub-loop of that problem). This apparently works because the "outer-loop" uses discrete variables while the "inner-loop" uses continuous variables.
• The outer loop is based on the "null-gene" transciption from another Englander paper and uses a genetic algorithm.
  • I'm not going to go too deep here into the details of the GA. But there's an entire paper on it
  • The paper does mention that it lends itself well to parallelization, which is true. Kubernetes cluster?
• The inner loop uses Sim-Flanagan transcription combined with Monotonic Basin Hopping, a method for single-shooting without initial guesses
  • Sims-Flanagan transcription is where you discretize the flight arc into many smaller time steps and the thrust applied is approximated as an impulsive thrust in the middle of each time step.
    • SFT is considered to be a "medium-fidelity" approach
  • For this solver, the trajectory betweens these points is produced as a solution to Kepler's problem, which is basically just the analytical solution to the 2BP, so that no derivatives or orbit-propagation is needed, for speed.
  • One thing I noted about this approach is that it doesn't seem to include a possibility for "coasting arcs" or throttling anything less than 100% (though the modeling of what 100% means is quite thorough), so perhaps we're missing some fidelity there?
  • I think SNOPT is used to optimize these "inner-loops". This should be pretty fast since it just uses Kepler's eq
  • The MBH method eliminates the need to solve Lambert's problem for initial guesses. This allows for a more robust analysis of the search base (if there are global optima further from the local optima near lambert's solution) but might be slower? I'm not sure.
    • The technique is kind of weird, but I suppose it works.
• This paper uses a hierarchy of events starting with the overall mission, which separates into journies, which, in the example I'm pursuing will be Earth -> Neptune and Neptune -> Earth (if applicable, but probably just the first one). Then these journies are further divided into phases, which include each planet -> planet leg. The number of phases and the identities of the planets are chosen by the algorithm.
• The paper goes into some length to determine what the launch C3, propulsion, power, and ephemeris modeling are. This is all very useful, but as far as I can tell it's pretty typical, so I won't note too much about it.
  • However, it does mention that SPICE presented some challenges for using a preferable method of parallelization. As an alternative, the paper mentions that FIRE could be used instead for ephemeris. Which might be worth looking into.
• The paper also include pseudocode, which is nice

Automated Mission Planning via Evolutionary Algorithms

• This is another Englander paper that gives more details on the outer-loop GA. Useful for details.

Multi-Objective Low-Thrust Interplanetary Trajectory Optimization Based on Generalized Logarithmic Spirals

• This is the first paper I looked at. It's actually quite similar to the Englander paper, but I think not quite as good
• Again, it formulates the problem as an HOCP.
• However, the "inner-loop" for this problem is an optimization of generalized logarithmic spirals. I don't think this is a very high fidelity method.
• The outer step uses collocation and an NLP optimizer (looks like it actually might just feed the guesses into GALLOP, which I assume uses SNOPT, though, to be honest, I can't find much on it from a quick search)
• I'm leaning toward Englander's approach over this one, perhaps with an alternative being to use one of the machine-learning approaches from above for the inner loop instead