Example usage for org.apache.commons.math3.analysis.differentiation DerivativeStructure getField

Introduction

In this page you can find the example usage for org.apache.commons.math3.analysis.differentiation DerivativeStructure getField.

Prototype

public Field<DerivativeStructure> getField() 

Source Link

Usage

From source file:org.orekit.data.FundamentalNutationArguments.java

/** Evaluate a polynomial.
 * @param tc offset in Julian centuries/*from  w  w  w. j av a 2 s .  c  o  m*/
 * @param coefficients polynomial coefficients (ordered from low degrees to high degrees)
 * @return value of the polynomial
 */
private DerivativeStructure value(final DerivativeStructure tc, final double[] coefficients) {
    DerivativeStructure value = tc.getField().getZero();
    for (int i = coefficients.length - 1; i >= 0; --i) {
        value = value.multiply(tc).add(coefficients[i]);
    }
    return value;
}

---

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

/** {@inheritDoc} */
public FieldVector3D<DerivativeStructure> radiationPressureAcceleration(final AbsoluteDate date,
        final Frame frame, final FieldVector3D<DerivativeStructure> position,
        final FieldRotation<DerivativeStructure> rotation, final DerivativeStructure mass,
        final FieldVector3D<DerivativeStructure> flux) throws OrekitException {

    if (flux.getNormSq().getValue() < Precision.SAFE_MIN) {
        // null illumination (we are probably in umbra)
        return new FieldVector3D<DerivativeStructure>(0.0, flux);
    }//w ww  .  j  a  v  a  2s  .  c  o  m

    // radiation flux in spacecraft frame
    final FieldVector3D<DerivativeStructure> fluxSat = rotation.applyTo(flux);

    // solar array contribution
    FieldVector3D<DerivativeStructure> normal = getNormal(date, frame, position, rotation);
    DerivativeStructure dot = FieldVector3D.dotProduct(normal, fluxSat);
    if (dot.getValue() > 0) {
        // the solar array is illuminated backward,
        // fix signs to compute contribution correctly
        dot = dot.negate();
        normal = normal.negate();
    }
    FieldVector3D<DerivativeStructure> force = facetRadiationAcceleration(normal, solarArrayArea, fluxSat, dot);

    // body facets contribution
    for (final Facet bodyFacet : facets) {
        normal = new FieldVector3D<DerivativeStructure>(mass.getField().getOne(), bodyFacet.getNormal());
        dot = FieldVector3D.dotProduct(normal, fluxSat);
        if (dot.getValue() < 0) {
            // the facet intercepts the incoming flux
            force = force.add(facetRadiationAcceleration(normal, bodyFacet.getArea(), fluxSat, dot));
        }
    }

    // convert to inertial frame
    return rotation.applyInverseTo(new FieldVector3D<DerivativeStructure>(mass.reciprocal(), force));

}

---

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

public DerivativeStructure value(DerivativeStructure t) {
    DerivativeStructure y1 = t.getField().getOne().multiply(polynomial[polynomial.length - 1].toDouble());
    for (int j = polynomial.length - 2; j >= 0; j--) {
        y1 = y1.multiply(t).add(polynomial[j].toDouble());
    }// w  w  w .ja va2s  .  c o m
    DerivativeStructure oneMinusT2 = t.getField().getOne().subtract(t.multiply(t));
    DerivativeStructure y2 = oneMinusT2.pow(m).sqrt();
    return y1.multiply(y2).multiply(normalization.toDouble());
}

---

From source file:org.orekit.propagation.analytical.EcksteinHechlerPropagator.java

/** Computes the eccentric latitude argument from the mean latitude argument.
 * @param alphaM = M +  mean latitude argument (rad)
 * @param ex e cos(), first component of circular eccentricity vector
 * @param ey e sin(), second component of circular eccentricity vector
 * @return the eccentric latitude argument.
 *//*from w  ww.ja va2s  . c  o m*/
private DerivativeStructure meanToEccentric(final DerivativeStructure alphaM, final DerivativeStructure ex,
        final DerivativeStructure ey) {
    // Generalization of Kepler equation to circular parameters
    // with alphaE = PA + E and
    //      alphaM = PA + M = alphaE - ex.sin(alphaE) + ey.cos(alphaE)
    DerivativeStructure alphaE = alphaM;
    DerivativeStructure shift = alphaM.getField().getZero();
    DerivativeStructure alphaEMalphaM = alphaM.getField().getZero();
    DerivativeStructure cosAlphaE = alphaE.cos();
    DerivativeStructure sinAlphaE = alphaE.sin();
    int iter = 0;
    do {
        final DerivativeStructure f2 = ex.multiply(sinAlphaE).subtract(ey.multiply(cosAlphaE));
        final DerivativeStructure f1 = alphaM.getField().getOne().subtract(ex.multiply(cosAlphaE))
                .subtract(ey.multiply(sinAlphaE));
        final DerivativeStructure f0 = alphaEMalphaM.subtract(f2);

        final DerivativeStructure f12 = f1.multiply(2);
        shift = f0.multiply(f12).divide(f1.multiply(f12).subtract(f0.multiply(f2)));

        alphaEMalphaM = alphaEMalphaM.subtract(shift);
        alphaE = alphaM.add(alphaEMalphaM);
        cosAlphaE = alphaE.cos();
        sinAlphaE = alphaE.sin();

    } while ((++iter < 50) && (FastMath.abs(shift.getValue()) > 1.0e-12));

    return alphaE;

}

---