Example usage for org.apache.commons.math3.geometry.euclidean.threed FieldVector3D FieldVector3D

List of usage examples for org.apache.commons.math3.geometry.euclidean.threed FieldVector3D FieldVector3D

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.math3.geometry.euclidean.threed.*
  5. FieldVector3D
  6. FieldVector3D

Introduction

In this page you can find the example usage for org.apache.commons.math3.geometry.euclidean.threed FieldVector3D FieldVector3D.

Prototype

public FieldVector3D(final double a1, final FieldVector3D<T> u1, final double a2, final FieldVector3D<T> u2,
        final double a3, final FieldVector3D<T> u3)

Source Link

Document

Linear constructor Build a vector from three other ones and corresponding scale factors.

Usage

From source file:org.orekit.utils.FieldAngularCoordinates.java

/** Add an offset from the instance.
 * <p>/*from  w  w w .  ja v  a 2s.  c om*/
 * We consider here that the offset FieldRotation<T> is applied first and the
 * instance is applied afterward. Note that angular coordinates do <em>not</em>
 * commute under this operation, i.e. {@code a.addOffset(b)} and {@code
 * b.addOffset(a)} lead to <em>different</em> results in most cases.
 * </p>
 * <p>
 * The two methods {@link #addOffset(FieldAngularCoordinates) addOffset} and
 * {@link #subtractOffset(FieldAngularCoordinates) subtractOffset} are designed
 * so that round trip applications are possible. This means that both {@code
 * ac1.subtractOffset(ac2).addOffset(ac2)} and {@code
 * ac1.addOffset(ac2).subtractOffset(ac2)} return angular coordinates equal to ac1.
 * </p>
 * @param offset offset to subtract
 * @return new instance, with offset subtracted
 * @see #subtractOffset(FieldAngularCoordinates)
 */
public FieldAngularCoordinates<T> addOffset(final FieldAngularCoordinates<T> offset) {
    final FieldVector3D<T> rOmega = rotation.applyTo(offset.rotationRate);
    final FieldVector3D<T> rOmegaDot = rotation.applyTo(offset.rotationAcceleration);
    return new FieldAngularCoordinates<T>(rotation.applyTo(offset.rotation), rotationRate.add(rOmega),
            new FieldVector3D<T>(1.0, rotationAcceleration, 1.0, rOmegaDot, -1.0,
                    FieldVector3D.crossProduct(rotationRate, rOmega)));
}

From source file:org.orekit.utils.FieldPVCoordinates.java

/** Linear constructor
 * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
 * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
 * @param a1 first scale factor/*www.j  ava 2  s.c o m*/
 * @param pv1 first base (unscaled) PVCoordinates
 * @param a2 second scale factor
 * @param pv2 second base (unscaled) PVCoordinates
 * @param a3 third scale factor
 * @param pv3 third base (unscaled) PVCoordinates
 */
public FieldPVCoordinates(final double a1, final FieldPVCoordinates<T> pv1, final double a2,
        final FieldPVCoordinates<T> pv2, final double a3, final FieldPVCoordinates<T> pv3) {
    position = new FieldVector3D<T>(a1, pv1.position, a2, pv2.position, a3, pv3.position);
    velocity = new FieldVector3D<T>(a1, pv1.velocity, a2, pv2.velocity, a3, pv3.velocity);
    acceleration = new FieldVector3D<T>(a1, pv1.acceleration, a2, pv2.acceleration, a3, pv3.acceleration);
}

From source file:org.orekit.utils.FieldPVCoordinates.java

/** Linear constructor
 * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
 * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
 * @param a1 first scale factor/*  w ww  .  ja va  2  s .c om*/
 * @param pv1 first base (unscaled) PVCoordinates
 * @param a2 second scale factor
 * @param pv2 second base (unscaled) PVCoordinates
 * @param a3 third scale factor
 * @param pv3 third base (unscaled) PVCoordinates
 */
public FieldPVCoordinates(final T a1, final FieldPVCoordinates<T> pv1, final T a2,
        final FieldPVCoordinates<T> pv2, final T a3, final FieldPVCoordinates<T> pv3) {
    position = new FieldVector3D<T>(a1, pv1.position, a2, pv2.position, a3, pv3.position);
    velocity = new FieldVector3D<T>(a1, pv1.velocity, a2, pv2.velocity, a3, pv3.velocity);
    acceleration = new FieldVector3D<T>(a1, pv1.acceleration, a2, pv2.acceleration, a3, pv3.acceleration);
}

From source file:org.orekit.utils.FieldPVCoordinates.java

/** Linear constructor
 * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
 * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
 * @param a1 first scale factor//w  w  w.j a  v a 2  s. c o m
 * @param pv1 first base (unscaled) PVCoordinates
 * @param a2 second scale factor
 * @param pv2 second base (unscaled) PVCoordinates
 * @param a3 third scale factor
 * @param pv3 third base (unscaled) PVCoordinates
 */
public FieldPVCoordinates(final T a1, final PVCoordinates pv1, final T a2, final PVCoordinates pv2, final T a3,
        final PVCoordinates pv3) {
    position = new FieldVector3D<T>(a1, pv1.getPosition(), a2, pv2.getPosition(), a3, pv3.getPosition());
    velocity = new FieldVector3D<T>(a1, pv1.getVelocity(), a2, pv2.getVelocity(), a3, pv3.getVelocity());
    acceleration = new FieldVector3D<T>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(), a3,
            pv3.getAcceleration());
}

From source file:org.orekit.utils.FieldPVCoordinates.java

/** Get a time-shifted state.
 * <p>// w  w  w . ja  v a  2s  .c  om
 * The state can be slightly shifted to close dates. This shift is based on
 * a simple quadratic model. It is <em>not</em> intended as a replacement for
 * proper orbit propagation (it is not even Keplerian!) but should be sufficient
 * for either small time shifts or coarse accuracy.
 * </p>
 * @param dt time shift in seconds
 * @return a new state, shifted with respect to the instance (which is immutable)
 */
public FieldPVCoordinates<T> shiftedBy(final double dt) {
    return new FieldPVCoordinates<T>(
            new FieldVector3D<T>(1, position, dt, velocity, 0.5 * dt * dt, acceleration),
            new FieldVector3D<T>(1, velocity, dt, acceleration), acceleration);
}

From source file:org.orekit.utils.TimeStampedFieldAngularCoordinates.java

/** Add an offset from the instance.
 * <p>//from   w  w  w .  ja v a2s . c  om
 * We consider here that the offset FieldRotation<T> is applied first and the
 * instance is applied afterward. Note that angular coordinates do <em>not</em>
 * commute under this operation, i.e. {@code a.addOffset(b)} and {@code
 * b.addOffset(a)} lead to <em>different</em> results in most cases.
 * </p>
 * <p>
 * The two methods {@link #addOffset(FieldAngularCoordinates) addOffset} and
 * {@link #subtractOffset(FieldAngularCoordinates) subtractOffset} are designed
 * so that round trip applications are possible. This means that both {@code
 * ac1.subtractOffset(ac2).addOffset(ac2)} and {@code
 * ac1.addOffset(ac2).subtractOffset(ac2)} return angular coordinates equal to ac1.
 * </p>
 * @param offset offset to subtract
 * @return new instance, with offset subtracted
 * @see #subtractOffset(FieldAngularCoordinates)
 */
public TimeStampedFieldAngularCoordinates<T> addOffset(final FieldAngularCoordinates<T> offset) {
    final FieldVector3D<T> rOmega = getRotation().applyTo(offset.getRotationRate());
    final FieldVector3D<T> rOmegaDot = getRotation().applyTo(offset.getRotationAcceleration());
    return new TimeStampedFieldAngularCoordinates<T>(date, getRotation().applyTo(offset.getRotation()),
            getRotationRate().add(rOmega), new FieldVector3D<T>(1.0, getRotationAcceleration(), 1.0, rOmegaDot,
                    -1.0, FieldVector3D.crossProduct(getRotationRate(), rOmega)));
}

From source file:org.orekit.utils.TimeStampedFieldPVCoordinates.java

/** Linear constructor
 * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
 * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
 * @param date date of the built coordinates
 * @param a1 first scale factor/*  w  w  w. java2  s. c om*/
 * @param pv1 first base (unscaled) PVCoordinates
 * @param a2 second scale factor
 * @param pv2 second base (unscaled) PVCoordinates
 * @param a3 third scale factor
 * @param pv3 third base (unscaled) PVCoordinates
 */
public TimeStampedFieldPVCoordinates(final AbsoluteDate date, final double a1, final FieldPVCoordinates<T> pv1,
        final double a2, final FieldPVCoordinates<T> pv2, final double a3, final FieldPVCoordinates<T> pv3) {
    super(new FieldVector3D<T>(a1, pv1.getPosition(), a2, pv2.getPosition(), a3, pv3.getPosition()),
            new FieldVector3D<T>(a1, pv1.getVelocity(), a2, pv2.getVelocity(), a3, pv3.getVelocity()),
            new FieldVector3D<T>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(), a3,
                    pv3.getAcceleration()));
    this.date = date;
}

From source file:org.orekit.utils.TimeStampedFieldPVCoordinates.java

/** Linear constructor
 * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
 * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
 * @param date date of the built coordinates
 * @param a1 first scale factor// w  w w  . ja  va 2  s .c o  m
 * @param pv1 first base (unscaled) PVCoordinates
 * @param a2 second scale factor
 * @param pv2 second base (unscaled) PVCoordinates
 * @param a3 third scale factor
 * @param pv3 third base (unscaled) PVCoordinates
 */
public TimeStampedFieldPVCoordinates(final AbsoluteDate date, final T a1, final FieldPVCoordinates<T> pv1,
        final T a2, final FieldPVCoordinates<T> pv2, final T a3, final FieldPVCoordinates<T> pv3) {
    super(new FieldVector3D<T>(a1, pv1.getPosition(), a2, pv2.getPosition(), a3, pv3.getPosition()),
            new FieldVector3D<T>(a1, pv1.getVelocity(), a2, pv2.getVelocity(), a3, pv3.getVelocity()),
            new FieldVector3D<T>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(), a3,
                    pv3.getAcceleration()));
    this.date = date;
}

From source file:org.orekit.utils.TimeStampedFieldPVCoordinates.java

/** Linear constructor
 * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
 * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
 * @param date date of the built coordinates
 * @param a1 first scale factor//from   w w  w  .j  a  v a 2 s .  c  om
 * @param pv1 first base (unscaled) PVCoordinates
 * @param a2 second scale factor
 * @param pv2 second base (unscaled) PVCoordinates
 * @param a3 third scale factor
 * @param pv3 third base (unscaled) PVCoordinates
 */
public TimeStampedFieldPVCoordinates(final AbsoluteDate date, final T a1, final PVCoordinates pv1, final T a2,
        final PVCoordinates pv2, final T a3, final PVCoordinates pv3) {
    super(new FieldVector3D<T>(a1, pv1.getPosition(), a2, pv2.getPosition(), a3, pv3.getPosition()),
            new FieldVector3D<T>(a1, pv1.getVelocity(), a2, pv2.getVelocity(), a3, pv3.getVelocity()),
            new FieldVector3D<T>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(), a3,
                    pv3.getAcceleration()));
    this.date = date;
}