Skip to content
Snippets Groups Projects
Commit 2008f523 authored by Luc Maisonobe's avatar Luc Maisonobe
Browse files

Added a way to reuse transform interpolator from one run to another. 

This is done by dumping its state into a file, thus avoiding costly
initialization.
parent 98fe8829
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 490 additions and 39 deletions
core/src/main/java/org/orekit/rugged/api/Rugged.java
+ 233
− 36
View file @ 2008f523
......@@ -16,6 +16,11 @@
*/
package org.orekit.rugged.api;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
......@@ -23,6 +28,7 @@ import java.util.List;
import java.util.Map;
import org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math3.exception.util.LocalizedFormats;
import org.apache.commons.math3.geometry.euclidean.threed.FieldVector3D;
import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
......@@ -169,26 +175,12 @@ public class Rugged {
final List<TimeStampedAngularCoordinates> quaternions, final int aInterpolationNumber,
final AngularDerivativesFilter aFilter, final double tStep)
throws RuggedException {
// space reference
this.ellipsoid = extend(ellipsoid);
// orbit/attitude to body converter
this.scToBody = new SpacecraftToObservedBody(inertialFrame, ellipsoid.getBodyFrame(),
minDate, maxDate, overshootTolerance,
positionsVelocities, pvInterpolationNumber, pvFilter,
quaternions, aInterpolationNumber, aFilter,
tStep);
// intersection algorithm
this.algorithm = selectAlgorithm(algorithmID, updater, maxCachedTiles);
this.sensors = new HashMap<String, LineSensor>();
this.finders = new HashMap<String, SensorMeanPlaneCrossing>();
setLightTimeCorrection(true);
setAberrationOfLightCorrection(true);
this(updater, maxCachedTiles, algorithmID, ellipsoid,
createInterpolator(inertialFrame, ellipsoid.getBodyFrame(),
minDate, maxDate, overshootTolerance,
positionsVelocities, pvInterpolationNumber, pvFilter,
quaternions, aInterpolationNumber, aFilter,
tStep));
}
/** Build a configured instance.
......@@ -263,10 +255,166 @@ public class Rugged {
final CartesianDerivativesFilter pvFilter, final AngularDerivativesFilter aFilter,
final double tStep, final Propagator propagator)
throws RuggedException {
try {
this(updater, maxCachedTiles, algorithmID, ellipsoid,
createInterpolator(inertialFrame, ellipsoid.getBodyFrame(),
minDate, maxDate, overshootTolerance,
interpolationStep, interpolationNumber,
pvFilter, aFilter, tStep, propagator));
}
// space reference
this.ellipsoid = extend(ellipsoid);
/** Build a configured instance, reusing the interpolator dumped from a previous instance.
* <p>
* By default, the instance performs both light time correction (which refers
* to ground point motion with respect to inertial frame) and aberration of
* light correction (which refers to spacecraft proper velocity). Explicit calls
* to {@link #setLightTimeCorrection(boolean) setLightTimeCorrection}
* and {@link #setAberrationOfLightCorrection(boolean) setAberrationOfLightCorrection}
* can be made after construction if these phenomena should not be corrected.
* </p>
* @param updater updater used to load Digital Elevation Model tiles
* @param maxCachedTiles maximum number of tiles stored in the cache
* @param algorithmID identifier of algorithm to use for Digital Elevation Model intersection
* @param ellipsoidID identifier of reference ellipsoid
* @param inertialFrameID identifier of inertial frame
* @param bodyRotatingFrameID identifier of body rotating frame
* @param dumpStream stream from where to read previous instance dumped interpolator
* (caller opened it and remains responsible for closing it)
* @exception RuggedException if dump file cannot be loaded
* or if frames do not match the ones referenced in the dump file
* @see #dumpInterpolator(OutputStream)
*/
public Rugged(final TileUpdater updater, final int maxCachedTiles,
final AlgorithmId algorithmID, final EllipsoidId ellipsoidID,
final InertialFrameId inertialFrameID, final BodyRotatingFrameId bodyRotatingFrameID,
final InputStream dumpStream)
throws RuggedException {
this(updater, maxCachedTiles, algorithmID,
selectEllipsoid(ellipsoidID, selectBodyRotatingFrame(bodyRotatingFrameID)),
selectInertialFrame(inertialFrameID), dumpStream);
}
/** Build a configured instance, reusing the interpolator dumped from a previous instance.
* <p>
* By default, the instance performs both light time correction (which refers
* to ground point motion with respect to inertial frame) and aberration of
* light correction (which refers to spacecraft proper velocity). Explicit calls
* to {@link #setLightTimeCorrection(boolean) setLightTimeCorrection}
* and {@link #setAberrationOfLightCorrection(boolean) setAberrationOfLightCorrection}
* can be made after construction if these phenomena should not be corrected.
* </p>
* @param updater updater used to load Digital Elevation Model tiles
* @param maxCachedTiles maximum number of tiles stored in the cache
* @param algorithmID identifier of algorithm to use for Digital Elevation Model intersection
* @param ellipsoid reference ellipsoid
* @param inertialFrame inertial frame
* @param dumpStream stream from where to read previous instance dumped interpolator
* (caller opened it and remains responsible for closing it)
* @exception RuggedException if dump file cannot be loaded
* or if frames do not match the ones referenced in the dump file
* @see #dumpInterpolator(OutputStream)
*/
public Rugged(final TileUpdater updater, final int maxCachedTiles,
final AlgorithmId algorithmID, final OneAxisEllipsoid ellipsoid, final Frame inertialFrame,
final InputStream dumpStream)
throws RuggedException {
this(updater, maxCachedTiles, algorithmID, ellipsoid,
createInterpolator(inertialFrame, ellipsoid.getBodyFrame(), dumpStream));
}
/** Build a configured instance.
* <p>
* By default, the instance performs both light time correction (which refers
* to ground point motion with respect to inertial frame) and aberration of
* light correction (which refers to spacecraft proper velocity). Explicit calls
* to {@link #setLightTimeCorrection(boolean) setLightTimeCorrection}
* and {@link #setAberrationOfLightCorrection(boolean) setAberrationOfLightCorrection}
* can be made after construction if these phenomena should not be corrected.
* </p>
* @param updater updater used to load Digital Elevation Model tiles
* @param maxCachedTiles maximum number of tiles stored in the cache
* @param algorithmID identifier of algorithm to use for Digital Elevation Model intersection
* @param ellipsoid f reference ellipsoid
* @param scToBody transforms interpolator
*/
private Rugged(final TileUpdater updater, final int maxCachedTiles,
final AlgorithmId algorithmID, final OneAxisEllipsoid ellipsoid,
final SpacecraftToObservedBody scToBody) {
// space reference
this.ellipsoid = extend(ellipsoid);
// orbit/attitude to body converter
this.scToBody = scToBody;
// intersection algorithm
this.algorithm = selectAlgorithm(algorithmID, updater, maxCachedTiles);
this.sensors = new HashMap<String, LineSensor>();
this.finders = new HashMap<String, SensorMeanPlaneCrossing>();
setLightTimeCorrection(true);
setAberrationOfLightCorrection(true);
}
/** Create a transform interpolator from positions and quaternions lists.
* @param inertialFrame inertial frame
* @param bodyFrame observed body frame
* @param minDate start of search time span
* @param maxDate end of search time span
* @param overshootTolerance tolerance in seconds allowed for {@code minDate} and {@code maxDate} overshooting
* @param positionsVelocities satellite position and velocity
* @param pvInterpolationNumber number of points to use for position/velocity interpolation
* @param pvFilter filter for derivatives from the sample to use in position/velocity interpolation
* @param quaternions satellite quaternions
* @param aInterpolationNumber number of points to use for attitude interpolation
* @param aFilter filter for derivatives from the sample to use in attitude interpolation
* @param tStep step to use for inertial frame to body frame transforms cache computations
* @return transforms interpolator
* @exception RuggedException if data needed for some frame cannot be loaded or if position
* or attitude samples do not fully cover the [{@code minDate}, {@code maxDate}] search time span
*/
private static SpacecraftToObservedBody createInterpolator(final Frame inertialFrame, final Frame bodyFrame,
final AbsoluteDate minDate, final AbsoluteDate maxDate,
final double overshootTolerance,
final List<TimeStampedPVCoordinates> positionsVelocities,
final int pvInterpolationNumber,
final CartesianDerivativesFilter pvFilter,
final List<TimeStampedAngularCoordinates> quaternions,
final int aInterpolationNumber,
final AngularDerivativesFilter aFilter, final double tStep)
throws RuggedException {
return new SpacecraftToObservedBody(inertialFrame, bodyFrame,
minDate, maxDate, overshootTolerance,
positionsVelocities, pvInterpolationNumber, pvFilter,
quaternions, aInterpolationNumber, aFilter,
tStep);
}
/** Create a transform interpolator from a propagator.
* @param inertialFrame inertial frame
* @param bodyFrame observed body frame
* @param minDate start of search time span
* @param maxDate end of search time span
* @param overshootTolerance tolerance in seconds allowed for {@code minDate} and {@code maxDate} overshooting
* @param interpolationStep step to use for inertial/Earth/spacraft transforms interpolations
* @param interpolationNumber number of points of to use for inertial/Earth/spacraft transforms interpolations
* @param pvFilter filter for derivatives from the sample to use in position/velocity interpolation
* @param aFilter filter for derivatives from the sample to use in attitude interpolation
* @param tStep step to use for inertial frame to body frame transforms cache computations
* @param propagator global propagator
* @return transforms interpolator
* @exception RuggedException if data needed for some frame cannot be loaded
*/
private static SpacecraftToObservedBody createInterpolator(final Frame inertialFrame, final Frame bodyFrame,
final AbsoluteDate minDate, final AbsoluteDate maxDate,
final double overshootTolerance,
final double interpolationStep, final int interpolationNumber,
final CartesianDerivativesFilter pvFilter,
final AngularDerivativesFilter aFilter,
final double tStep, final Propagator propagator)
throws RuggedException {
try {
// extract position/attitude samples from propagator
final List<TimeStampedPVCoordinates> positionsVelocities =
......@@ -299,25 +447,74 @@ public class Rugged {
propagator.propagate(minDate.shiftedBy(-interpolationStep), maxDate.shiftedBy(interpolationStep));
// orbit/attitude to body converter
this.scToBody = new SpacecraftToObservedBody(inertialFrame, ellipsoid.getBodyFrame(),
minDate, maxDate, overshootTolerance,
positionsVelocities, interpolationNumber, pvFilter,
quaternions, interpolationNumber, aFilter,
tStep);
// intersection algorithm
this.algorithm = selectAlgorithm(algorithmID, updater, maxCachedTiles);
return createInterpolator(inertialFrame, bodyFrame,
minDate, maxDate, overshootTolerance,
positionsVelocities, interpolationNumber, pvFilter,
quaternions, interpolationNumber, aFilter,
tStep);
this.sensors = new HashMap<String, LineSensor>();
this.finders = new HashMap<String, SensorMeanPlaneCrossing>();
setLightTimeCorrection(true);
setAberrationOfLightCorrection(true);
} catch (PropagationException pe) {
throw new RuggedException(pe, pe.getSpecifier(), pe.getParts());
}
}
/** Create a transform interpolator from positions and quaternions lists.
* @param inertialFrame inertial frame
* @param bodyFrame observed body frame
* @param dumpStream stream from where to read previous instance dumped interpolator
* (caller opened it and remains responsible for closing it)
* @return recovered interpolator from dump
* @exception RuggedException if dump file cannot be loaded or if
* frames do not match the ones referenced in the dump file
*/
private static SpacecraftToObservedBody createInterpolator(final Frame inertialFrame, final Frame bodyFrame,
final InputStream dumpStream)
throws RuggedException {
try {
final ObjectInputStream ois = new ObjectInputStream(dumpStream);
final SpacecraftToObservedBody scToBody = (SpacecraftToObservedBody) ois.readObject();
if (!inertialFrame.getName().equals(scToBody.getInertialFrameName())) {
throw new RuggedException(RuggedMessages.FRAMES_MISMATCH_WITH_INTERPOLATOR_DUMP,
inertialFrame.getName(), scToBody.getInertialFrameName());
}
if (!bodyFrame.getName().equals(scToBody.getBodyFrameName())) {
throw new RuggedException(RuggedMessages.FRAMES_MISMATCH_WITH_INTERPOLATOR_DUMP,
bodyFrame.getName(), scToBody.getBodyFrameName());
}
return scToBody;
} catch (ClassNotFoundException cnfe) {
throw new RuggedException(cnfe, RuggedMessages.NOT_INTERPOLATOR_DUMP_DATA);
} catch (ClassCastException cce) {
throw new RuggedException(cce, RuggedMessages.NOT_INTERPOLATOR_DUMP_DATA);
} catch (IOException ioe) {
throw new RuggedException(ioe, RuggedMessages.NOT_INTERPOLATOR_DUMP_DATA);
}
}
/** Dump frames transform interpolator.
* <p>
* This method allows to reuse the interpolator built in one instance, to build
* another instance by calling {@link #Rugged(TileUpdater, int, AlgorithmId, OneAxisEllipsoid, Frame, InputStream)}
* or {@link #Rugged(TileUpdater, int, AlgorithmId, EllipsoidId, InertialFrameId, BodyRotatingFrameId, InputStream)}.
* This reduces Rugged initialization time as setting up the interpolator can be long, it is
* mainly intended to be used when several runs are done (for example in an image processing chain)
* with the same configuration.
* </p>
* @param dumpStream stream where to dump the interpolator
* (caller opened it and remains responsible for closing it)
* @exception RuggedException if interpolator cannot be written to file
* @see #Rugged(TileUpdater, int, AlgorithmId, OneAxisEllipsoid, Frame, File)
* @see #Rugged(TileUpdater, int, AlgorithmId, EllipsoidId, InertialFrameId, BodyRotatingFrameId, File)
*/
public void dumpInterpolator(final OutputStream dumpStream) throws RuggedException {
try {
final ObjectOutputStream oos = new ObjectOutputStream(dumpStream);
oos.writeObject(scToBody);
} catch (IOException ioe) {
throw new RuggedException(ioe, LocalizedFormats.SIMPLE_MESSAGE, ioe.getMessage());
}
}
/** Set flag for light time correction.
* <p>
* This methods set the flag for compensating or not light time between
......
core/src/main/java/org/orekit/rugged/api/RuggedMessages.java
+ 3
− 1
View file @ 2008f523
......@@ -60,7 +60,9 @@ public enum RuggedMessages implements Localizable {
LINE_OF_SIGHT_NEVER_CROSSES_LATITUDE("line-of-sight never crosses latitude {0}"),
LINE_OF_SIGHT_NEVER_CROSSES_LONGITUDE("line-of-sight never crosses longitude {0}"),
LINE_OF_SIGHT_NEVER_CROSSES_ALTITUDE("line-of-sight never crosses altitude {0}"),
DEM_ENTRY_POINT_IS_BEHIND_SPACECRAFT("line-of-sight enters the Digital Elevation Model behind spacecraft!");
DEM_ENTRY_POINT_IS_BEHIND_SPACECRAFT("line-of-sight enters the Digital Elevation Model behind spacecraft!"),
FRAMES_MISMATCH_WITH_INTERPOLATOR_DUMP("frame {0} does not match frame {1} from interpolator dump"),
NOT_INTERPOLATOR_DUMP_DATA("data is not an interpolator dump");
// CHECKSTYLE: resume JavadocVariable check
......
core/src/main/java/org/orekit/rugged/utils/SpacecraftToObservedBody.java
+ 27
− 1
View file @ 2008f523
......@@ -16,6 +16,7 @@
*/
package org.orekit.rugged.utils;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
......@@ -36,7 +37,16 @@ import org.orekit.utils.TimeStampedPVCoordinates;
/** Provider for observation transforms.
* @author Luc Maisonobe
*/
public class SpacecraftToObservedBody {
public class SpacecraftToObservedBody implements Serializable {
/** Serializable UID. */
private static final long serialVersionUID = 20140909L;
/** Name of the inertial frame. */
private final String inertialFrameName;
/** Name of the body frame. */
private final String bodyFrameName;
/** Start of search time span. */
private final AbsoluteDate minDate;
......@@ -87,6 +97,8 @@ public class SpacecraftToObservedBody {
throws RuggedException {
try {
this.inertialFrameName = inertialFrame.getName();
this.bodyFrameName = bodyFrame.getName();
this.minDate = minDate;
this.maxDate = maxDate;
this.overshootTolerance = overshootTolerance;
......@@ -170,6 +182,20 @@ public class SpacecraftToObservedBody {
}
}
/** Get the name of the inertial frame.
* @return inertial frame name
*/
public String getInertialFrameName() {
return inertialFrameName;
}
/** Get the name of the body frame.
* @return body frame name
*/
public String getBodyFrameName() {
return bodyFrameName;
}
/** Get the start of search time span.
* @return start of search time span
*/
......
core/src/main/resources/assets/org/orekit/rugged/RuggedMessages_en.utf8
+ 6
− 0
View file @ 2008f523
......@@ -30,3 +30,9 @@ LINE_OF_SIGHT_NEVER_CROSSES_ALTITUDE = line-of-sight never crosses altitude {0}
# line-of-sight enters the Digital Elevation Model behind spacecraft!
DEM_ENTRY_POINT_IS_BEHIND_SPACECRAFT = line-of-sight enters the Digital Elevation Model behind spacecraft!
# frame {0} does not match frame {1} from interpolator dump
FRAMES_MISMATCH_WITH_INTERPOLATOR_DUMP = frame {0} does not match frame {1} from interpolator dump
# data is not an interpolator dump
NOT_INTERPOLATOR_DUMP_DATA = data is not an interpolator dump
core/src/main/resources/assets/org/orekit/rugged/RuggedMessages_fr.utf8
+ 6
− 0
View file @ 2008f523
......@@ -30,3 +30,9 @@ LINE_OF_SIGHT_NEVER_CROSSES_ALTITUDE = la ligne de visée ne franchit jamais l''
# line-of-sight enters the Digital Elevation Model behind spacecraft!
DEM_ENTRY_POINT_IS_BEHIND_SPACECRAFT = la ligne de visée entre dans le Modèle Numérique de Terrain derrière le satellite !
# frame {0} does not match frame {1} from interpolator dump
FRAMES_MISMATCH_WITH_INTERPOLATOR_DUMP = le repère {0} ne correspond pas au repère {1} de la sauvegarde d''interpolateur
# data is not an interpolator dump
NOT_INTERPOLATOR_DUMP_DATA = les données ne correspondent pas à une sauvegarde d''interpolateur
core/src/test/java/org/orekit/rugged/api/RuggedMessagesTest.java
+ 1
− 1
View file @ 2008f523
......@@ -29,7 +29,7 @@ public class RuggedMessagesTest {
@Test
public void testMessageNumber() {
Assert.assertEquals(11, RuggedMessages.values().length);
Assert.assertEquals(13, RuggedMessages.values().length);
}
@Test
......
core/src/test/java/org/orekit/rugged/api/RuggedTest.java
+ 210
− 0
View file @ 2008f523
......@@ -17,9 +17,13 @@
package org.orekit.rugged.api;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.StreamCorruptedException;
import java.net.URISyntaxException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
......@@ -534,6 +538,212 @@ public class RuggedTest {
}
@Test
public void testInterpolatorDump()
throws RuggedException, OrekitException, URISyntaxException {
int dimension = 200;
String path = getClass().getClassLoader().getResource("orekit-data").toURI().getPath();
DataProvidersManager.getInstance().addProvider(new DirectoryCrawler(new File(path)));
final BodyShape earth = createEarth();
final Orbit orbit = createOrbit(Constants.EIGEN5C_EARTH_MU);
AbsoluteDate crossing = new AbsoluteDate("2012-01-01T12:30:00.000", TimeScalesFactory.getUTC());
// one line sensor
// position: 1.5m in front (+X) and 20 cm above (-Z) of the S/C center of mass
// los: swath in the (YZ) plane, looking at 50° roll, ±1° aperture
Vector3D position = new Vector3D(1.5, 0, -0.2);
List<Vector3D> los = createLOS(new Rotation(Vector3D.PLUS_I, FastMath.toRadians(50.0)).applyTo(Vector3D.PLUS_K),
Vector3D.PLUS_I,
FastMath.toRadians(1.0), dimension);
// linear datation model: at reference time we get line 100, and the rate is one line every 1.5ms
LineDatation lineDatation = new LinearLineDatation(crossing, dimension / 2, 1.0 / 1.5e-3);
int firstLine = 0;
int lastLine = dimension;
LineSensor lineSensor = new LineSensor("line", lineDatation, position, los);
AbsoluteDate minDate = lineSensor.getDate(firstLine);
AbsoluteDate maxDate = lineSensor.getDate(lastLine);
TileUpdater updater =
new RandomLandscapeUpdater(0.0, 9000.0, 0.5, 0x84186d1344722b8fl,
FastMath.toRadians(1.0), 257);
Rugged ruggedOriginal = new Rugged(updater, 8, AlgorithmId.DUVENHAGE,
EllipsoidId.WGS84, InertialFrameId.EME2000, BodyRotatingFrameId.ITRF,
minDate, maxDate, 5.0,
orbitToPV(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 8,
CartesianDerivativesFilter.USE_PV,
orbitToQ(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 2,
AngularDerivativesFilter.USE_R, 0.001);
ruggedOriginal.addLineSensor(lineSensor);
GeodeticPoint[] gpOriginal = ruggedOriginal.directLocalization("line", 100);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ruggedOriginal.dumpInterpolator(bos);
Assert.assertTrue(bos.size() > 100000);
Assert.assertTrue(bos.size() < 200000);
Rugged ruggedRecovered = new Rugged(updater, 8, AlgorithmId.DUVENHAGE,
EllipsoidId.WGS84, InertialFrameId.EME2000, BodyRotatingFrameId.ITRF,
new ByteArrayInputStream(bos.toByteArray()));
ruggedRecovered.addLineSensor(lineSensor);
GeodeticPoint[] gpRecovered = ruggedRecovered.directLocalization("line", 100);
for (int i = 0; i < gpOriginal.length; ++i) {
Vector3D pOriginal = earth.transform(gpOriginal[i]);
Vector3D pRecovered = earth.transform(gpRecovered[i]);
Assert.assertEquals(0.0, Vector3D.distance(pOriginal, pRecovered), 1.0e-15);
}
}
@Test
public void testInterpolatorDumpWrongFrame()
throws RuggedException, OrekitException, URISyntaxException {
int dimension = 200;
String path = getClass().getClassLoader().getResource("orekit-data").toURI().getPath();
DataProvidersManager.getInstance().addProvider(new DirectoryCrawler(new File(path)));
final BodyShape earth = createEarth();
final Orbit orbit = createOrbit(Constants.EIGEN5C_EARTH_MU);
AbsoluteDate crossing = new AbsoluteDate("2012-01-01T12:30:00.000", TimeScalesFactory.getUTC());
// one line sensor
// position: 1.5m in front (+X) and 20 cm above (-Z) of the S/C center of mass
// los: swath in the (YZ) plane, looking at 50° roll, ±1° aperture
Vector3D position = new Vector3D(1.5, 0, -0.2);
List<Vector3D> los = createLOS(new Rotation(Vector3D.PLUS_I, FastMath.toRadians(50.0)).applyTo(Vector3D.PLUS_K),
Vector3D.PLUS_I,
FastMath.toRadians(1.0), dimension);
// linear datation model: at reference time we get line 100, and the rate is one line every 1.5ms
LineDatation lineDatation = new LinearLineDatation(crossing, dimension / 2, 1.0 / 1.5e-3);
int firstLine = 0;
int lastLine = dimension;
LineSensor lineSensor = new LineSensor("line", lineDatation, position, los);
AbsoluteDate minDate = lineSensor.getDate(firstLine);
AbsoluteDate maxDate = lineSensor.getDate(lastLine);
Rugged ruggedOriginal = new Rugged(null, -1, AlgorithmId.IGNORE_DEM_USE_ELLIPSOID,
EllipsoidId.WGS84, InertialFrameId.EME2000, BodyRotatingFrameId.ITRF,
minDate, maxDate, 5.0,
orbitToPV(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 8,
CartesianDerivativesFilter.USE_PV,
orbitToQ(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 2,
AngularDerivativesFilter.USE_R, 0.001);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ruggedOriginal.dumpInterpolator(bos);
Assert.assertTrue(bos.size() > 100000);
Assert.assertTrue(bos.size() < 200000);
for (InertialFrameId iId : Arrays.asList(InertialFrameId.GCRF,
InertialFrameId.MOD,
InertialFrameId.TOD,
InertialFrameId.VEIS1950)) {
try {
new Rugged(null, -1, AlgorithmId.IGNORE_DEM_USE_ELLIPSOID,
EllipsoidId.WGS84, iId, BodyRotatingFrameId.ITRF,
new ByteArrayInputStream(bos.toByteArray()));
Assert.fail("an exception should have been thrown");
} catch (RuggedException re) {
Assert.assertEquals(RuggedMessages.FRAMES_MISMATCH_WITH_INTERPOLATOR_DUMP,
re.getSpecifier());
}
}
for (BodyRotatingFrameId bId : Arrays.asList(BodyRotatingFrameId.GTOD,
BodyRotatingFrameId.ITRF_EQUINOX)) {
try {
new Rugged(null, -1, AlgorithmId.IGNORE_DEM_USE_ELLIPSOID,
EllipsoidId.WGS84, InertialFrameId.EME2000, bId,
new ByteArrayInputStream(bos.toByteArray()));
Assert.fail("an exception should have been thrown");
} catch (RuggedException re) {
Assert.assertEquals(RuggedMessages.FRAMES_MISMATCH_WITH_INTERPOLATOR_DUMP,
re.getSpecifier());
}
}
}
@Test
public void testInterpolatorNotADump()
throws RuggedException, OrekitException, URISyntaxException {
String path = getClass().getClassLoader().getResource("orekit-data").toURI().getPath();
DataProvidersManager.getInstance().addProvider(new DirectoryCrawler(new File(path)));
// the following array is a real serialization file corresponding to the following
// made-up empty class that does not exist in Rugged:
// public class NonExistentClass implements java.io.Serializable {
// private static final long serialVersionUID = -1;
// }
byte[] nonExistentClass = new byte[] {
-84, -19, 0, 5, 115, 114,
0, 16, 78, 111, 110, 69,
120, 105, 115, 116, 101, 110,
116, 67, 108, 97, 115, 115,
-1, -1, -1, -1, -1, -1,
-1, -1, 2, 0, 0, 120,
112
};
// the following array is a real serialization file of object Integer.valueOf(1)
byte[] integerOne = new byte[] {
-84, -19, 0, 5, 115, 114,
0, 17, 106, 97, 118, 97,
46, 108, 97, 110, 103, 46,
73, 110, 116, 101, 103, 101,
114, 18, -30, -96, -92, -9,
-127,-121, 56, 2, 0, 1,
73, 0, 5, 118, 97, 108,
117, 101, 120, 114, 0, 16,
106, 97, 118, 97, 46, 108,
97, 110, 103, 46, 78, 117,
109, 98, 101, 114,-122, -84,
-107, 29, 11,-108, -32,-117,
2, 0, 0, 120, 112, 0,
0, 0, 1
};
// the following array is a truncation of the previous one
byte[] truncatedDump = new byte[] {
-84, -19, 0, 5, 115, 114,
0, 17, 106, 97, 118, 97
};
byte[] notSerialization = new byte[] {
1, 2, 3, 4, 5, 6
};
for (byte[] array : Arrays.asList(nonExistentClass, integerOne, truncatedDump, notSerialization)) {
try {
new Rugged(null, -1, AlgorithmId.IGNORE_DEM_USE_ELLIPSOID,
EllipsoidId.WGS84, InertialFrameId.EME2000, BodyRotatingFrameId.ITRF,
new ByteArrayInputStream(array));
Assert.fail("an exception should have been thrown");
} catch (RuggedException re) {
Assert.assertEquals(RuggedMessages.NOT_INTERPOLATOR_DUMP_DATA,
re.getSpecifier());
if (array == nonExistentClass) {
Assert.assertEquals(ClassNotFoundException.class, re.getCause().getClass());
} else if (array == integerOne) {
Assert.assertEquals(ClassCastException.class, re.getCause().getClass());
} else if (array == truncatedDump) {
Assert.assertEquals(EOFException.class, re.getCause().getClass());
} else if (array == notSerialization) {
Assert.assertEquals(StreamCorruptedException.class, re.getCause().getClass());
}
}
}
}
// the following test is disabled by default
// it is only used to check timings, and also creates a large (38M) temporary file
@Test
......
src/site/xdoc/changes.xml
+ 4
− 0
View file @ 2008f523
......@@ -22,6 +22,10 @@
<body>
<release version="1.0" date="TBD"
description="TBD">
<action dev="luc" type="add">
Added a way to reuse transform interpolator from one run to another
by dumping its state into a file, thus avoiding costly initialization.
</action>
<action dev="luc" type="add">
Time step for internal transform caching is now user-configurable.
</action>
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment