Example usage for org.apache.commons.math3.geometry.euclidean.threed FieldVector3D 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) 

Source Link

Document

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

Usage

From source file:org.orekit.forces.BoxAndSolarArraySpacecraft.java

/** Get solar array normal in spacecraft frame.
 * @param date current date//w  ww  . j  a  v  a  2  s .  c o m
 * @param frame inertial reference frame for state (both orbit and attitude)
 * @param position position of spacecraft in reference frame
 * @param rotation orientation (attitude) of the spacecraft with respect to reference frame
 * @return solar array normal in spacecraft frame
 * @exception OrekitException if sun direction cannot be computed in best lightning
 * configuration
 */
public synchronized FieldVector3D<DerivativeStructure> getNormal(final AbsoluteDate date, final Frame frame,
        final FieldVector3D<DerivativeStructure> position, final FieldRotation<DerivativeStructure> rotation)
        throws OrekitException {

    final DerivativeStructure one = position.getX().getField().getOne();

    if (referenceDate != null) {
        // use a simple rotation at fixed rate
        final DerivativeStructure alpha = one.multiply(rotationRate * date.durationFrom(referenceDate));
        return new FieldVector3D<DerivativeStructure>(alpha.cos(), saX, alpha.sin(), saY);
    }

    // compute orientation for best lightning
    final FieldVector3D<DerivativeStructure> sunInert = position
            .subtract(sun.getPVCoordinates(date, frame).getPosition()).negate().normalize();
    final FieldVector3D<DerivativeStructure> sunSpacecraft = rotation.applyTo(sunInert);
    final DerivativeStructure d = FieldVector3D.dotProduct(sunSpacecraft, saZ);
    final DerivativeStructure f = d.multiply(d).subtract(1).negate();
    if (f.getValue() < Precision.EPSILON) {
        // extremely rare case: the sun is along solar array rotation axis
        // (there will not be much output power ...)
        // we set up an arbitrary normal
        return new FieldVector3D<DerivativeStructure>(one, saZ.orthogonal());
    }

    final DerivativeStructure s = f.sqrt().reciprocal();
    return new FieldVector3D<DerivativeStructure>(s, sunSpacecraft)
            .subtract(new FieldVector3D<DerivativeStructure>(s.multiply(d), saZ));

}

---

From source file:org.orekit.forces.BoxAndSolarArraySpacecraft.java

/** Compute contribution of one facet to force.
 * <p>This method implements equation 8-44 from David A. Vallado's
 * Fundamentals of Astrodynamics and Applications, third edition,
 * 2007, Microcosm Press.</p>//from w w w .  ja va  2s.co  m
 * @param normal facet normal
 * @param area facet area
 * @param fluxSat radiation pressure flux in spacecraft frame
 * @param dot dot product of facet and fluxSat (must be negative)
 * @return contribution of the facet to force in spacecraft frame
 */
private FieldVector3D<DerivativeStructure> facetRadiationAcceleration(
        final FieldVector3D<DerivativeStructure> normal, final double area,
        final FieldVector3D<DerivativeStructure> fluxSat, final DerivativeStructure dot) {
    final DerivativeStructure psr = fluxSat.getNorm();

    // Vallado's equation 8-44 uses different parameters which are related to our parameters as:
    // cos (phi) = -dot / (psr * area)
    // n         = facet / area
    // s         = -fluxSat / psr
    final DerivativeStructure cN = dot.multiply(-2 * area)
            .multiply(dot.divide(psr).multiply(specularReflectionCoeff).subtract(diffuseReflectionCoeff / 3));
    final DerivativeStructure cS = dot.divide(psr).multiply(area * (specularReflectionCoeff - 1));
    return new FieldVector3D<DerivativeStructure>(cN, normal, cS, fluxSat);

}

---

From source file:org.orekit.forces.BoxAndSolarArraySpacecraft.java

/** Compute contribution of one facet to force.
 * <p>This method implements equation 8-44 from David A. Vallado's
 * Fundamentals of Astrodynamics and Applications, third edition,
 * 2007, Microcosm Press.</p>/*from ww  w  .  ja va2  s  .  c o m*/
 * @param normal facet normal
 * @param area facet area
 * @param fluxSat radiation pressure flux in spacecraft frame
 * @param dot dot product of facet and fluxSat (must be negative)
 * @param specularReflectionCoeffDS specular reflection coefficient
 * @param diffuseReflectionCoeffDS diffuse reflection coefficient
 * @return contribution of the facet to force in spacecraft frame
 */
private FieldVector3D<DerivativeStructure> facetRadiationAcceleration(final Vector3D normal, final double area,
        final Vector3D fluxSat, final double dot, final DerivativeStructure specularReflectionCoeffDS,
        final DerivativeStructure diffuseReflectionCoeffDS) {
    final double psr = fluxSat.getNorm();

    // Vallado's equation 8-44 uses different parameters which are related to our parameters as:
    // cos (phi) = -dot / (psr * area)
    // n         = facet / area
    // s         = -fluxSat / psr
    final DerivativeStructure cN = diffuseReflectionCoeffDS.divide(3)
            .subtract(specularReflectionCoeffDS.multiply(dot / psr)).multiply(2 * area * dot);
    final DerivativeStructure cS = specularReflectionCoeffDS.subtract(1).multiply(area * dot / psr);

    return new FieldVector3D<DerivativeStructure>(cN, normal, cS, fluxSat);

}

---

From source file:org.orekit.forces.gravity.Relativity.java

@Override
public FieldVector3D<DerivativeStructure> accelerationDerivatives(final AbsoluteDate date, final Frame frame,
        final FieldVector3D<DerivativeStructure> position, final FieldVector3D<DerivativeStructure> velocity,
        final FieldRotation<DerivativeStructure> rotation, final DerivativeStructure mass) {

    //radius/*from ww  w.  j  a v a  2 s .  co m*/
    final DerivativeStructure r2 = position.getNormSq();
    final DerivativeStructure r = r2.sqrt();
    //speed squared
    final DerivativeStructure s2 = velocity.getNormSq();
    final double c2 = Constants.SPEED_OF_LIGHT * Constants.SPEED_OF_LIGHT;
    //eq. 3.146
    return new FieldVector3D<DerivativeStructure>(r.reciprocal().multiply(4 * this.gm).subtract(s2), position,
            position.dotProduct(velocity).multiply(4), velocity)
                    .scalarMultiply(r2.multiply(r).multiply(c2).reciprocal().multiply(this.gm));

}

---

From source file:org.orekit.forces.gravity.Relativity.java

@Override
public FieldVector3D<DerivativeStructure> accelerationDerivatives(final SpacecraftState s,
        final String paramName) throws OrekitException {

    complainIfNotSupported(paramName);//from  ww w  .  ja v a2s .c o m
    final DerivativeStructure gmDS = new DerivativeStructure(1, 1, 0, this.gm);

    final PVCoordinates pv = s.getPVCoordinates();
    final Vector3D p = pv.getPosition();
    final Vector3D v = pv.getVelocity();
    //radius
    final double r2 = p.getNormSq();
    final double r = FastMath.sqrt(r2);
    //speed
    final double s2 = v.getNormSq();
    final double c2 = Constants.SPEED_OF_LIGHT * Constants.SPEED_OF_LIGHT;
    //eq. 3.146
    return new FieldVector3D<DerivativeStructure>(gmDS.multiply(4 / r).subtract(s2), p,
            new DerivativeStructure(1, 1, 4 * p.dotProduct(v)), v).scalarMultiply(gmDS.divide(r2 * r * c2));
}

---

From source file:org.orekit.forces.gravity.ThirdBodyAttraction.java

/** {@inheritDoc} */
public FieldVector3D<DerivativeStructure> accelerationDerivatives(final SpacecraftState s,
        final String paramName) throws OrekitException {

    complainIfNotSupported(paramName);//from w w w .  j a  va 2 s.co  m

    // compute bodies separation vectors and squared norm
    final Vector3D centralToBody = body.getPVCoordinates(s.getDate(), s.getFrame()).getPosition();
    final double r2Central = centralToBody.getNormSq();
    final Vector3D satToBody = centralToBody.subtract(s.getPVCoordinates().getPosition());
    final double r2Sat = satToBody.getNormSq();

    final DerivativeStructure gmds = new DerivativeStructure(1, 1, 0, gm);

    // compute relative acceleration
    return new FieldVector3D<DerivativeStructure>(gmds.divide(r2Sat * FastMath.sqrt(r2Sat)), satToBody,
            gmds.divide(-r2Central * FastMath.sqrt(r2Central)), centralToBody);

}

---

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

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

---

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

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

---

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

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

---

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

/** Estimate velocity between two positions.
 * <p>Estimation is based on a simple fixed velocity translation
 * during the time interval between the two positions.</p>
 * @param start start position//from ww  w  .ja v  a  2  s . com
 * @param end end position
 * @param dt time elapsed between the dates of the two positions
 * @param <T> the type of the field elements
 * @return velocity allowing to go from start to end positions
 */
public static <T extends RealFieldElement<T>> FieldVector3D<T> estimateVelocity(final FieldVector3D<T> start,
        final FieldVector3D<T> end, final double dt) {
    final double scale = 1.0 / dt;
    return new FieldVector3D<T>(scale, end, -scale, start);
}

---

• «
• 1
• 2
• »