List of usage examples for org.apache.commons.math3.analysis.differentiation DerivativeStructure multiply
public DerivativeStructure multiply(final DerivativeStructure a) throws DimensionMismatchException
From source file:curveavg.QuinticFunction.java
public DerivativeStructure value(DerivativeStructure t) { return t.pow(5).multiply(a).add( t.pow(4).multiply(b).add(t.pow(3).multiply(c).add(t.pow(2).multiply(d).add(t.multiply(e).add(f))))); }
From source file:de.tuberlin.uebb.jdae.examples.FactorialEquation.java
private final DerivativeStructure dfactorial(final DerivativeStructure ds) { if (ds.getValue() <= 1.0) { final DerivativeStructure divide = ds.divide(ds); return divide; } else// ww w . jav a 2 s . c o m return ds.multiply(dfactorial(ds.subtract(1.0))); }
From source file:de.tuberlin.uebb.jbop.example.DSExampleOrig.java
@Test public DerivativeStructure run() { x = new DerivativeStructure(3, 3, 0, x0); y = new DerivativeStructure(3, 3, 1, y0); z = new DerivativeStructure(3, 3, 2, z0); // ax/*from w w w. j a v a2 s . c om*/ final DerivativeStructure ax2 = x.pow(2).multiply(a);// // ay final DerivativeStructure ay2 = y.pow(2).multiply(a);// // az final DerivativeStructure az2 = z.pow(2).multiply(a);// // + bx final DerivativeStructure bx = x.multiply(b); // + by final DerivativeStructure by = y.multiply(b); // + bz final DerivativeStructure bz = z.multiply(b); final DerivativeStructure multiply = ax2.multiply(ay2).multiply(az2); final DerivativeStructure multiply2 = bx.multiply(by).multiply(bz); return multiply.add(multiply2).add(c); }
From source file:org.orekit.bodies.OneAxisEllipsoid.java
/** Transform a surface-relative point to a Cartesian point. * @param point surface-relative point, using time as the single derivation parameter * @return point at the same location but as a Cartesian point including derivatives */// www . jav a 2s . c o m public PVCoordinates transform(final FieldGeodeticPoint<DerivativeStructure> point) { final DerivativeStructure latitude = point.getLatitude(); final DerivativeStructure longitude = point.getLongitude(); final DerivativeStructure altitude = point.getAltitude(); final DerivativeStructure cLambda = longitude.cos(); final DerivativeStructure sLambda = longitude.sin(); final DerivativeStructure cPhi = latitude.cos(); final DerivativeStructure sPhi = latitude.sin(); final DerivativeStructure n = sPhi.multiply(sPhi).multiply(e2).subtract(1.0).negate().sqrt().reciprocal() .multiply(getA()); final DerivativeStructure r = n.add(altitude).multiply(cPhi); return new PVCoordinates(new FieldVector3D<DerivativeStructure>(r.multiply(cLambda), r.multiply(sLambda), sPhi.multiply(altitude.add(n.multiply(g2))))); }
From source file:org.orekit.bodies.OneAxisEllipsoid.java
/** Transform a Cartesian point to a surface-relative point. * @param point Cartesian point// w w w. j ava 2 s . c om * @param frame frame in which Cartesian point is expressed * @param date date of the computation (used for frames conversions) * @return point at the same location but as a surface-relative point, * using time as the single derivation parameter * @exception OrekitException if point cannot be converted to body frame */ public FieldGeodeticPoint<DerivativeStructure> transform(final PVCoordinates point, final Frame frame, final AbsoluteDate date) throws OrekitException { // transform point to body frame final Transform toBody = frame.getTransformTo(bodyFrame, date); final PVCoordinates pointInBodyFrame = toBody.transformPVCoordinates(point); final FieldVector3D<DerivativeStructure> p = pointInBodyFrame.toDerivativeStructureVector(2); final DerivativeStructure pr2 = p.getX().multiply(p.getX()).add(p.getY().multiply(p.getY())); final DerivativeStructure pr = pr2.sqrt(); final DerivativeStructure pz = p.getZ(); // project point on the ellipsoid surface final TimeStampedPVCoordinates groundPoint = projectToGround( new TimeStampedPVCoordinates(date, pointInBodyFrame), bodyFrame); final FieldVector3D<DerivativeStructure> gp = groundPoint.toDerivativeStructureVector(2); final DerivativeStructure gpr2 = gp.getX().multiply(gp.getX()).add(gp.getY().multiply(gp.getY())); final DerivativeStructure gpr = gpr2.sqrt(); final DerivativeStructure gpz = gp.getZ(); // relative position of test point with respect to its ellipse sub-point final DerivativeStructure dr = pr.subtract(gpr); final DerivativeStructure dz = pz.subtract(gpz); final double insideIfNegative = g2 * (pr2.getReal() - ae2) + pz.getReal() * pz.getReal(); return new FieldGeodeticPoint<DerivativeStructure>(DerivativeStructure.atan2(gpz, gpr.multiply(g2)), DerivativeStructure.atan2(p.getY(), p.getX()), DerivativeStructure.hypot(dr, dz).copySign(insideIfNegative)); }
From source file:org.orekit.data.FundamentalNutationArguments.java
/** Evaluate a polynomial. * @param tc offset in Julian centuries/*from w w w. j a v a2s. co 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
/** Get solar array normal in spacecraft frame. * @param date current date/*from www .j a v a 2 s . c om*/ * @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
/** {@inheritDoc} */ public FieldVector3D<DerivativeStructure> dragAcceleration(final AbsoluteDate date, final Frame frame, final FieldVector3D<DerivativeStructure> position, final FieldRotation<DerivativeStructure> rotation, final DerivativeStructure mass, final double density, final FieldVector3D<DerivativeStructure> relativeVelocity) throws OrekitException { // relative velocity in spacecraft frame final FieldVector3D<DerivativeStructure> v = rotation.applyTo(relativeVelocity); // solar array contribution final FieldVector3D<DerivativeStructure> solarArrayFacet = new FieldVector3D<DerivativeStructure>( solarArrayArea, getNormal(date, frame, position, rotation)); DerivativeStructure sv = FieldVector3D.dotProduct(v, solarArrayFacet).abs(); // body facets contribution for (final Facet facet : facets) { final DerivativeStructure dot = FieldVector3D.dotProduct(v, facet.getNormal()); if (dot.getValue() < 0) { // the facet intercepts the incoming flux sv = sv.subtract(dot.multiply(facet.getArea())); }/*from ww w .j av a 2s. c o m*/ } return new FieldVector3D<DerivativeStructure>(sv.multiply(density * dragCoeff / 2.0).divide(mass), relativeVelocity); }
From source file:org.orekit.forces.BoxAndSolarArraySpacecraft.java
/** {@inheritDoc} */ public FieldVector3D<DerivativeStructure> dragAcceleration(final AbsoluteDate date, final Frame frame, final Vector3D position, final Rotation rotation, final double mass, final double density, final Vector3D relativeVelocity, final String paramName) throws OrekitException { if (!DRAG_COEFFICIENT.equals(paramName)) { throw new OrekitException(OrekitMessages.UNSUPPORTED_PARAMETER_NAME, paramName, DRAG_COEFFICIENT); }/*from w w w . j av a 2s . c om*/ final DerivativeStructure dragCoeffDS = new DerivativeStructure(1, 1, 0, dragCoeff); // relative velocity in spacecraft frame final Vector3D v = rotation.applyTo(relativeVelocity); // solar array contribution final Vector3D solarArrayFacet = new Vector3D(solarArrayArea, getNormal(date, frame, position, rotation)); double sv = FastMath.abs(Vector3D.dotProduct(solarArrayFacet, v)); // body facets contribution for (final Facet facet : facets) { final double dot = Vector3D.dotProduct(facet.getNormal(), v); if (dot < 0) { // the facet intercepts the incoming flux sv -= facet.getArea() * dot; } } return new FieldVector3D<DerivativeStructure>(dragCoeffDS.multiply(sv * density / (2.0 * mass)), relativeVelocity); }
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>//w w w. jav a 2 s .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); }