OrbitModel

java.lang.Object
- math.AbstractDataModel
- - math.AbstractGradientModel
  - - astro.OrbitModel

All Implemented Interfaces:

Clipping, DataModel, GradientModel, LevenbergMarquardtCapable
```
public class OrbitModel
extends AbstractGradientModel
```
The orbit model is the differentiable model that fits to a radial velocity of an SB1 orbit. It can be used in a Levenberg-Marquardt schema to solve a Keplerian orbit. The model that fits an SB-1 orbit is given by
```
  v_r=v_0+e·K*cos(ω)+K*cos(ω+ν),
 
```
where v_0 is the baricentric velocity of the system, K is the radial velocity amplitude, e is the excentricity of the system, ω is the argument of perihelion, and ν is the true anomaly. From the eccentricity and the eccentric anomaly, the true anomaly follows as
```
  tan(ν/2) = sqrt((1+e)/(1-e))·tan(E/2)
 
```
From the time of perihelion passage, the orbital period, and the numeric eccentricity from the orbit, get the excentric anomaly for the current time. Solve Kepler's equation
```
  M=2π/P·(t-t0)=E-e·sin(E)
 
```
which is done iteratively.
For calculating the quadrature of an orbit, saee the special class.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`OrbitModel.Anomaly` Calculates excentric and true anomaly given M and e.
`static class`	`OrbitModel.Calculate` Supply the orbit parameters t0, P, e, omega, K1 and vB to the command line to get the orbit solution for the specified time.
`static class`	`OrbitModel.Hss348` Orbital elements from RV solution for HSS 348.
`static class`	`OrbitModel.Orbit` Supply the orbit parameters t0, P, e, omega, K1 and vB to the command line to get the orbit solution for the specified time.
`static class`	`OrbitModel.Quadrature` Calculates the phases of quadrature, defined as ν=±90, or, if a second argument is given, which is then the argument of periastron, as the times of maximum rv, which follows from the defintion of rv to
`static class`	`OrbitModel.Test` For testing.

Nested classes/interfaces inherited from class math.AbstractDataModel
AbstractDataModel.ChiSquare, AbstractDataModel.Lorentzian, AbstractDataModel.Robust

Field Summary

Fields
Modifier and Type	Field and Description
`private static double`	`ACCURACY` Accuracy to reach in Kepler's equation.
`private double`	`erradd`
`private static int`	`ITERMAX` Maximum number of iterations, log_2(2/ACCURACY).

Constructor Summary

Constructors
Constructor and Description

OrbitModel(VectorG[] times, double[] y, double[] err, double off)
Measures at differnt point-in-time.

Constructors
Constructor and Description
`OrbitModel(VectorG[] times, double[] y, double[] err, double off)` Measures at differnt point-in-time.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`evaluateModel(VectorG a, VectorG t)` The model that fits an SB-1 orbit is given by
`VectorG`	`evaluateModelGradient(VectorG a, VectorG t)`
`static double`	`getEccentricAnomaly(double m, double e)` From the normal anomaly M and the excentricity e, we solve Kepler's equation
`static double`	`getEccentricAnomaly(double t, double t0, double p, double e)` From the time of perihelion passage, the orbital period, and the numeric eccentricity from the orbit, get the excentric anomaly for the current time.
`static double`	`getEccentricAnomalyInverse(double nu, double e)`
`VectorG`	`getGradientAtMeasure(int row, VectorG a)`
`MyMatrix`	`getGradientMatrix(VectorG a)` This is the derivative matrix of the orbital solution with respect to the parameters.
`static double`	`getMeanAnomalyInverse(double nu, double e)`
`double[]`	`getMeasurementErrors()` If we had an external error, we subtract it again.
`double[]`	`getModel(VectorG a)` The model that fits an SB-1 orbit is given by
`private static double`	`getOrbitSolution(double t, VectorG a)` Calculates the orbit rv for the given time and the specified parameter set.
`int`	`getParameterCount()` An orbit has six parameters, namely at indices: 0: The perihelium time, in the units of our time, like JD. 1: The orbital period, in our time units (e.g.
`static double`	`getTrueAnomaly(double e, double exan)` From the eccentricity and the eccentric anomaly return the true anomaly.

Methods inherited from class math.AbstractGradientModel
check, check, getCovarianceForSolution, getCovarianceForSolution, getFixParameters, getFixParameters, getNegativeChi2HalfGradient, getNegativeChi2HalfGradient, getPseudoHessian, getPseudoHessian, LevenbergMarquardtSolver

Methods inherited from class math.AbstractDataModel
clip, getChi2, getChi2, getChiSquareModel, getChiSquareModel, getComponent, getFixParameters, getFixParameters, getLorentzianModel, getLorentzianSolving, getMeasureCount, getMeasurementTimes, getMeasures, getModel, getResiduals, getResiduals, getRms, getRms, getRobustModel, getRobustSolving, getSimplexSolving, getTimeOffset, getTimes, getTotalErrors, setMeasures, setTimes, setTotalErrors

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface math.DataModel
getMeasureCount, getMeasures, getResiduals, getTimeOffset, getTimes, getTotalErrors

Methods inherited from interface math.LevenbergMarquardtCapable
getChiSquareModel

- Field Detail
  - ACCURACY
```
private static double ACCURACY
```
    Accuracy to reach in Kepler's equation.
  - ITERMAX
```
private static int ITERMAX
```
    Maximum number of iterations, log_2(2/ACCURACY).
  - erradd
```
private final double erradd
```
- Constructor Detail
  - OrbitModel
```
public OrbitModel(VectorG[] times,
                  double[] y,
                  double[] err,
                  double off)
```
    Measures at differnt point-in-time. Each VectorG has only a single dimentsion, this is the time.
    
    Parameters:
    
    times - The times of the measure, a Vector1D array.
    
    y - The measurements of radial velocity.
    
    err - The errors of the measurements.
- Method Detail
  - getParameterCount
```
public int getParameterCount()
```
    An orbit has six parameters, namely at indices:
    - 0: The perihelium time, in the units of our time, like JD.
    - 1: The orbital period, in our time units (e.g. days).
    - 2: Excentricity of the orbit, dimensionless, 0-1.
    - 3: The perihel argument, in radian.
    - 4: The amplitude of the radial velocity, i.e. half of peak-to-valley, in units of the measurement.
    - 5: The barycentric velocity of the system.
  - getMeasurementErrors
```
public double[] getMeasurementErrors()
```
    If we had an external error, we subtract it again.
    
    Specified by:
    
    getMeasurementErrors in interface DataModel
    
    Overrides:
    
    getMeasurementErrors in class AbstractDataModel
  - getModel
```
public double[] getModel(VectorG a)
```
    The model that fits an SB-1 orbit is given by
```
  v_r=v_0+e·K*cos(ω)+K*cos(ω+ν),
 
```
    where v_0 is the baricentric velocity of the system, K is the radial velocity amplitude, e is the excentricity of the system, ω is the argument of perihelion, and ν is the true anomaly.
    Specified by:
    
    getModel in interface DataModel
    
    Overrides:
    
    getModel in class AbstractDataModel
    
    See Also:
    
    getParameterCount
  - evaluateModel
```
public double evaluateModel(VectorG a,
                            VectorG t)
```
    The model that fits an SB-1 orbit is given by
```
  v_r=v_0+e·K*cos(ω)+K*cos(ω+ν),
 
```
    where v_0 is the baricentric velocity of the system, K is the radial velocity amplitude, e is the excentricity of the system, ω is the argument of perihelion, and ν is the true anomaly.
    Parameters:
    
    a - The fitted parameter
    
    t - Only the zero'th component is used, this is the jd.
    
    See Also:
    
    getParameterCount
  - evaluateModelGradient
```
public VectorG evaluateModelGradient(VectorG a,
                                     VectorG t)
```
  - getOrbitSolution
```
private static double getOrbitSolution(double t,
                                       VectorG a)
```
    Calculates the orbit rv for the given time and the specified parameter set.
    
    Parameters:
    
    t - The time, same units as in the model
    
    a - The orbit model parameters, see getParameterCount() for order.
  - getGradientMatrix
```
public MyMatrix getGradientMatrix(VectorG a)
```
    This is the derivative matrix of the orbital solution with respect to the parameters. From the definition of v_r one gets
    Let v_nu be the partial derivative of vr with respect to ν
```
  v_nu = -K*sin(&omega+&nu);
 
```
    Then, calling E the excentric anomaly, 2π/P*(t-t_0)=E-e·sinE, the respective gradients columns are:
    - 0:
    - 1:
    - 2: Excentricity of the orbit, dimensionless, 0-1.
    - 3:
    - 4:
    - 5: 1
  - getGradientAtMeasure
```
public VectorG getGradientAtMeasure(int row,
                                    VectorG a)
```
  - getMeanAnomalyInverse
```
public static final double getMeanAnomalyInverse(double nu,
                                                 double e)
```
    Parameters:
    
    nu - true anomaly in radians
    
    e - the numeric excentricity
    
    Returns:
  - getEccentricAnomalyInverse
```
public static final double getEccentricAnomalyInverse(double nu,
                                                      double e)
```
    Parameters:
    
    nu - true anomaly in radians
    
    e - the numeric excentricity
    
    Returns:
  - getEccentricAnomaly
```
public static final double getEccentricAnomaly(double t,
                                               double t0,
                                               double p,
                                               double e)
```
    From the time of perihelion passage, the orbital period, and the numeric eccentricity from the orbit, get the excentric anomaly for the current time. We solve Kepler's equation
```
  M=2π/P·(t-t0)=E-e·sin(E)
 
```
    with Newton's method. If that does not converge, we can trap a solution between M+1 and M-1 and bisector from there.
  - getEccentricAnomaly
```
public static final double getEccentricAnomaly(double m,
                                               double e)
```
    From the normal anomaly M and the excentricity e, we solve Kepler's equation
```
 M = E-e&middotsin(E)
 
```
    with Newton's method. If that does not converge, we can trap a solution between M+1 and M-1 and bisector from there.
  - getTrueAnomaly
```
public static final double getTrueAnomaly(double e,
                                          double exan)
```
    From the eccentricity and the eccentric anomaly return the true anomaly.
```
  tan(ν/2) = sqrt((1+e)/(1-e))·tan(E/2)
 
```

Class OrbitModel

Nested Class Summary

Nested classes/interfaces inherited from class math.AbstractDataModel

Field Summary

Constructor Summary

Method Summary

Methods inherited from class math.AbstractGradientModel

Methods inherited from class math.AbstractDataModel

Methods inherited from class java.lang.Object

Methods inherited from interface math.DataModel

Methods inherited from interface math.LevenbergMarquardtCapable

Field Detail

ACCURACY

ITERMAX

erradd

Constructor Detail

OrbitModel

Method Detail

getParameterCount

getMeasurementErrors

getModel

evaluateModel

evaluateModelGradient

getOrbitSolution

getGradientMatrix

getGradientAtMeasure

getMeanAnomalyInverse

getEccentricAnomalyInverse

getEccentricAnomaly

getEccentricAnomaly

getTrueAnomaly