Added initial notes

prelim_notes/paper_notes.md

@@ -0,0 +1,102 @@
+# 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 *aero*gravity 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](https://opensource.gsfc.nasa.gov/projects/emtg/index.php)
+- 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
+

prelim_notes/plan.md

@@ -0,0 +1,26 @@
+# Plan After Literature Review
+
+After reading the papers in the Google Drive (see `paper_notes.md`) I've come up with the following
+plan:
+
+I think that I'd like to follow an approach similar to what I saw in Englander and Morante. However,
+I think it makes more sense to follow the Englander approach for the specific optimizers being used
+in the inner and outer loops. Specifically this means:
+
+- Set up the problem as a Hybrid Optimal Control Problem (HOCP) with an inner and an outer loop
+- The outer loop will determine the number and identities of the flybys and optimize using a Binary
+  Genetic Algorithm described by Englander
+- The inner loop in Englander uses Sims-Flanagan Transcription optimized using monotonic basin
+  hopping. This seems like a good approach. I'd like to use this approach, but also consider using,
+  as an alternative method for comparison, one of the machine-learning algorithms from the other
+  papers.
+- There are a number of other details including modeling launch C3, power, thrust, and ephemeris.
+  For all of these I'll use either the exact approach from Englander or a similar approach. There
+  exists an option to use alternatives to SPICE for ephemeris, but I think the parallelization
+  problems that SPICE poses can be solved in other ways.
+    - Specifically, I'd like to build this program using a micro-service architecture. This could
+      allow for deployment using Kubernetes clusters. This will handle the parallelization (by
+      running multiple inner loop micro-services at once) and allow for simpler use in production
+      environments if that's ever needed, as kubernetes has a robust integration with most
+      web-hosting services. This also allows for flexible scalability if improved speed is ever
+      needed.

readme.md

@@ -1 +1,8 @@
 # Thesis Repository
+
+This will be a repository for my code while I work on my thesis. The general idea is to generate a
+method for automatically producing optimal low-thrust trajectories (including optimizations of the
+planetary flybys) for a sample mission to Neptune. 
+
+For now, it will just be a location for storing my notes as I come up with a plan. I will update
+this readme as I flush out the plan a little better and then as I begin producing code.