OrbitType.java

  1. /* Copyright 2002-2013 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.orbits;

  19. import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
  20. import org.orekit.frames.Frame;
  21. import org.orekit.time.AbsoluteDate;
  22. import org.orekit.utils.PVCoordinates;

  24. /** Enumerate for {@link Orbit orbital} parameters types.
  25.  */
  26. public enum OrbitType {

  28.     /** Type for propagation in {@link CartesianOrbit Cartesian parameters}. */
  29.     CARTESIAN {

  31.         /** {@inheritDoc} */
  32.         public Orbit convertType(final Orbit orbit) {
  33.             return (orbit.getType() == this) ? orbit : new CartesianOrbit(orbit);
  34.         }

  36.         /** {@inheritDoc} */
  37.         public void mapOrbitToArray(final Orbit orbit, final PositionAngle type,
  38.                                     final double[] stateVector) {

  40.             final PVCoordinates pv = orbit.getPVCoordinates();
  41.             final Vector3D      p  = pv.getPosition();
  42.             final Vector3D      v  = pv.getVelocity();

  44.             stateVector[0] = p.getX();
  45.             stateVector[1] = p.getY();
  46.             stateVector[2] = p.getZ();
  47.             stateVector[3] = v.getX();
  48.             stateVector[4] = v.getY();
  49.             stateVector[5] = v.getZ();

  51.         }

  53.         /** {@inheritDoc} */
  54.         public Orbit mapArrayToOrbit(final double[] stateVector, final PositionAngle type,
  55.                                      final AbsoluteDate date, final double mu, final Frame frame) {

  57.             final Vector3D p     = new Vector3D(stateVector[0], stateVector[1], stateVector[2]);
  58.             final Vector3D v     = new Vector3D(stateVector[3], stateVector[4], stateVector[5]);
  59.             return new CartesianOrbit(new PVCoordinates(p, v), frame, date, mu);

  61.         }

  63.     },

  65.     /** Type for propagation in {@link CircularOrbit circular parameters}. */
  66.     CIRCULAR {

  68.         /** {@inheritDoc} */
  69.         public Orbit convertType(final Orbit orbit) {
  70.             return (orbit.getType() == this) ? orbit : new CircularOrbit(orbit);
  71.         }

  73.         /** {@inheritDoc} */
  74.         public void mapOrbitToArray(final Orbit orbit, final PositionAngle type,
  75.                                     final double[] stateVector) {

  77.             final CircularOrbit circularOrbit = (CircularOrbit) OrbitType.CIRCULAR.convertType(orbit);

  79.             stateVector[0] = circularOrbit.getA();
  80.             stateVector[1] = circularOrbit.getCircularEx();
  81.             stateVector[2] = circularOrbit.getCircularEy();
  82.             stateVector[3] = circularOrbit.getI();
  83.             stateVector[4] = circularOrbit.getRightAscensionOfAscendingNode();
  84.             stateVector[5] = circularOrbit.getAlpha(type);

  86.         }

  88.         /** {@inheritDoc} */
  89.         public Orbit mapArrayToOrbit(final double[] stateVector, final PositionAngle type,
  90.                                      final AbsoluteDate date, final double mu, final Frame frame) {
  91.             return new CircularOrbit(stateVector[0], stateVector[1], stateVector[2], stateVector[3],
  92.                                      stateVector[4], stateVector[5], type,
  93.                                      frame, date, mu);
  94.         }

  96.     },

  98.     /** Type for propagation in {@link EquinoctialOrbit equinoctial parameters}. */
  99.     EQUINOCTIAL {

  101.         /** {@inheritDoc} */
  102.         public Orbit convertType(final Orbit orbit) {
  103.             return (orbit.getType() == this) ? orbit : new EquinoctialOrbit(orbit);
  104.         }

  106.         /** {@inheritDoc} */
  107.         public void mapOrbitToArray(final Orbit orbit, final PositionAngle type,
  108.                                     final double[] stateVector) {

  110.             final EquinoctialOrbit equinoctialOrbit =
  111.                 (EquinoctialOrbit) OrbitType.EQUINOCTIAL.convertType(orbit);

  113.             stateVector[0] = equinoctialOrbit.getA();
  114.             stateVector[1] = equinoctialOrbit.getEquinoctialEx();
  115.             stateVector[2] = equinoctialOrbit.getEquinoctialEy();
  116.             stateVector[3] = equinoctialOrbit.getHx();
  117.             stateVector[4] = equinoctialOrbit.getHy();
  118.             stateVector[5] = equinoctialOrbit.getL(type);

  120.         }

  122.         /** {@inheritDoc} */
  123.         public Orbit mapArrayToOrbit(final double[] stateVector, final PositionAngle type,
  124.                                      final AbsoluteDate date, final double mu, final Frame frame) {
  125.             return new EquinoctialOrbit(stateVector[0], stateVector[1], stateVector[2], stateVector[3],
  126.                                         stateVector[4], stateVector[5], type,
  127.                                         frame, date, mu);
  128.         }

  130.     },

  132.     /** Type for propagation in {@link KeplerianOrbit Keplerian parameters}. */
  133.     KEPLERIAN {

  135.         /** {@inheritDoc} */
  136.         public Orbit convertType(final Orbit orbit) {
  137.             return (orbit.getType() == this) ? orbit : new KeplerianOrbit(orbit);
  138.         }

  140.         /** {@inheritDoc} */
  141.         public void mapOrbitToArray(final Orbit orbit, final PositionAngle type,
  142.                                     final double[] stateVector) {

  144.             final KeplerianOrbit keplerianOrbit =
  145.                 (KeplerianOrbit) OrbitType.KEPLERIAN.convertType(orbit);

  147.             stateVector[0] = keplerianOrbit.getA();
  148.             stateVector[1] = keplerianOrbit.getE();
  149.             stateVector[2] = keplerianOrbit.getI();
  150.             stateVector[3] = keplerianOrbit.getPerigeeArgument();
  151.             stateVector[4] = keplerianOrbit.getRightAscensionOfAscendingNode();
  152.             stateVector[5] = keplerianOrbit.getAnomaly(type);

  154.         }

  156.         /** {@inheritDoc} */
  157.         public Orbit mapArrayToOrbit(final double[] stateVector, final PositionAngle type,
  158.                                      final AbsoluteDate date, final double mu, final Frame frame) {
  159.             return new KeplerianOrbit(stateVector[0], stateVector[1], stateVector[2], stateVector[3],
  160.                                       stateVector[4], stateVector[5], type,
  161.                                       frame, date, mu);
  162.         }

  164.     };

  166.     /** Convert an orbit to the instance type.
  167.      * <p>
  168.      * The returned orbit is the specified instance itself if its type already matches,
  169.      * otherwise, a new orbit of the proper type created
  170.      * </p>
  171.      * @param orbit orbit to convert
  172.      * @return converted orbit with type guaranteed to match (so it can be cast safely)
  173.      */
  174.     public abstract Orbit convertType(final Orbit orbit);

  176.     /** Convert orbit to state array.
  177.      * <p>
  178.      * Note that all implementations of this method <em>must</em> be consistent with the
  179.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  180.      * org.orekit.orbits.PositionAngle, double[][]) Orbit.getJacobianWrtCartesian}
  181.      * method for the corresponding orbit type in terms of parameters order and meaning.
  182.      * </p>
  183.      * @param orbit orbit to map
  184.      * @param type type of the angle
  185.      * @param stateVector flat array into which the state vector should be mapped */
  186.     public abstract void mapOrbitToArray(Orbit orbit, PositionAngle type, double[] stateVector);

  188.      /** Convert state array to orbital parameters.
  189.      * <p>
  190.      * Note that all implementations of this method <em>must</em> be consistent with the
  191.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  192.      * org.orekit.orbits.PositionAngle, double[][]) Orbit.getJacobianWrtCartesian}
  193.      * method for the corresponding orbit type in terms of parameters order and meaning.
  194.      * </p>
  195.      * @param array state as a flat array
  196.      * @param type type of the angle
  197.      * @param date integration date
  198.      * @param mu central attraction coefficient used for propagation (m<sup>3</sup>/s<sup>2</sup>)
  199.      * @param frame frame in which integration is performed
  200.      * @return orbit corresponding to the flat array as a space dynamics object
  201.      */
  202.     public abstract Orbit mapArrayToOrbit(double[] array, PositionAngle type,
  203.                                           AbsoluteDate date, double mu, Frame frame);

  205. }
Created with JaCoCo 0.6.3.201306030806