Updated documentation of field-based propagation.

src/design/field.puml

+' Copyright 2002-2017 CS Systèmes d'Information
+' Licensed to CS Systèmes d'Information (CS) under one or more
+' contributor license agreements.  See the NOTICE file distributed with
+' this work for additional information regarding copyright ownership.
+' CS licenses this file to You under the Apache License, Version 2.0
+' (the "License"); you may not use this file except in compliance with
+' the License.  You may obtain a copy of the License at
+'
+'   http://www.apache.org/licenses/LICENSE-2.0
+'
+' Unless required by applicable law or agreed to in writing, software
+' distributed under the License is distributed on an "AS IS" BASIS,
+' WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+' See the License for the specific language governing permissions and
+' limitations under the License.
+ 
+@startuml
+
+  skinparam svek                  true
+  skinparam ClassBackgroundColor  #F3EFEB/CCC9C5
+  skinparam ClassArrowColor       #691616
+  skinparam ClassBorderColor      #691616
+  skinparam NoteBackgroundColor   #F3EFEB
+  skinparam NoteBorderColor       #691616
+  skinparam NoteFontColor         #691616
+  skinparam ClassFontSize         11
+  skinparam PackageFontSize       12
+
+  package org.hipparchus #ECEBD8 {
+
+    interface "FieldElement<T>" as FieldElement_T_ {
+      T add(T a)
+      T subtract(T a)
+      T negate()
+      T multiply(int n)
+      T multiply(T a)
+      T divide(T a)
+      T reciprocal()
+      Field<T> getField()
+    }
+
+    interface "RealFieldElement<T>" as RealFieldElement_T_ {
+      T sin()
+      T cos()
+      ...
+      T copySign(T sign)
+      double getReal()
+    }
+    note top
+      lots of mathematical methods
+      omitted for clarity
+    end note
+
+    package analysis.differentiation #DDEBD8  {
+
+        class DSFactory {
+          +DSFactory(int parameters, int order)
+          +constant(double value)
+          +variable(int index, double value)
+        }
+
+        class DerivativeStructure {
+          +DSFactory getFactory()
+          +int getFreeParameters()
+          +int getOrder()
+          +double getValue()
+          +double getPartialDerivative(int[] orders)
+          +double taylor(double[] delta)
+        }
+
+        FieldElement_T_     <..      RealFieldElement_T_
+        RealFieldElement_T_     <..      DerivativeStructure
+        DSFactory           --> DerivativeStructure : creates
+    }
+
+    package util #DDEBD8  {
+       RealFieldElement_T_     <..      Tuple
+    }
+
+  }
+
+  package org.orekit.propagation #ECEBD8 {
+      interface "FieldPropagator<T>" as FieldPropagator_T_ {
+      }
+      RealFieldElement_T_ <-- FieldPropagator_T_
+  }
+
+@enduml

src/site/markdown/architecture/propagation.md

@@ -360,7 +360,7 @@ Semianalytical propagation is implemented using Draper Semianalytical Satellite
 Since version 7.0, both mean elements equations of motion models and short periodic terms
 have been implemented and validated.
 
-## Field propagation and Taylor Algebra
+## Field propagation
 
 Since 9.0, most of the Orekit propagators (in fact all of them except DSST) have both a regular
 version the propagates states based on classical real numbers (i.e. double precision numbers)
@@ -370,6 +370,10 @@ support all operations from the real field (addition, subtraction, multiplicatio
 but also direct and inverse trigonometric functions, direct and inverse hyperbolic functions,
 logarithms, powers, roots...).
 
+![fields class diagram](../images/design/field.png)
+
+### Taylor algebra
+
 A very important implementation of the `RealFieldElement` interface is the `DerivativeStructure`
 class, which in addition to compute the result of the canonical operation (add, multiply, sin,
 atanh...) also computes its derivatives, with respect to any number of variables and to any
@@ -408,3 +412,21 @@ a Monte-Carlo application is *very* fast. So even if the propagation ends up to
 hundred of times slower than regular propagation, depending on the number of derivatives, the
 payoff is still very important as soon as we evaluate a few hundreds of points. As Monte-Carlo
 analyses more often use several thousands of evaluations, the payoff is really interesting.
+
+### Parallel computation
+
+Another important implementation of the `RealFieldElement` interface is the `Tuple`
+class, which computes the same operation on a number of components of a tuple, hence
+allowing to perform parallel orbit propagation in one run. Each spacecraft will correspond
+to one component of the tuple. The first spacecraft (component at index 0) is the reference.
+
+There is a catch, however. In many places in orbit propagations, there are conditional
+statements the depend on the current state (for example is the spacecraft in eclipse
+or still in Sun light). As a single choice is allowed, the outcome of the check is based
+on the reference spacecraft only (i.e. fist component of the tuple) and the conditional
+branch is selected according to this reference spacecraft. The spacecrafts represented by
+the other components of the tuple will follow the same branch in the algorithm, even despite
+they may not be in the same conditions. This means that using `Tuple` for orbit propagation
+works only for close enough spacecrafts. This is well suited for finite differences,
+formation flying or co-positioning, but this is not suited for constellations.
+