OnBoardAntennaRangeModifier.java

  1. /* Copyright 2002-2022 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.estimation.measurements.modifiers;

  18. import java.util.Collections;
  19. import java.util.List;

  20. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  21. import org.orekit.estimation.measurements.EstimatedMeasurement;
  22. import org.orekit.estimation.measurements.EstimationModifier;
  23. import org.orekit.estimation.measurements.Range;
  24. import org.orekit.frames.Transform;
  25. import org.orekit.propagation.SpacecraftState;
  26. import org.orekit.time.AbsoluteDate;
  27. import org.orekit.utils.ParameterDriver;
  28. import org.orekit.utils.TimeStampedPVCoordinates;

  29. /** On-board antenna offset effect on range measurements.
  30.  * @author Luc Maisonobe
  31.  * @since 9.0
  32.  */
  33. public class OnBoardAntennaRangeModifier implements EstimationModifier<Range> {

  34.     /** Position of the Antenna Phase Center in satellite frame. */
  35.     private final Vector3D antennaPhaseCenter;

  36.     /** Simple constructor.
  37.      * @param antennaPhaseCenter position of the Antenna Phase Center in satellite frame
  38.      */
  39.     public OnBoardAntennaRangeModifier(final Vector3D antennaPhaseCenter) {
  40.         this.antennaPhaseCenter = antennaPhaseCenter;
  41.     }

  42.     /** {@inheritDoc} */
  43.     @Override
  44.     public List<ParameterDriver> getParametersDrivers() {
  45.         return Collections.emptyList();
  46.     }

  47.     /** {@inheritDoc} */
  48.     @Override
  49.     public void modify(final EstimatedMeasurement<Range> estimated) {
  50.         if (estimated.getObservedMeasurement().isTwoWay()) {
  51.             modifyTwoWay(estimated);
  52.         } else {
  53.             modifyOneWay(estimated);
  54.         }
  55.     }

  56.     /** Apply a modifier to a one-way range measurement.
  57.      * @param estimated estimated measurement to modify
  58.      */
  59.     private void modifyOneWay(final EstimatedMeasurement<Range> estimated) {

  60.         // the participants are spacecraft at emission, ground station at reception
  61.         final TimeStampedPVCoordinates[] participants = estimated.getParticipants();
  62.         final AbsoluteDate               emissionDate = participants[0].getDate();
  63.         final Vector3D                   pReception   = participants[1].getPosition();

  64.         // transform from spacecraft to inertial frame at emission date
  65.         final SpacecraftState refState          = estimated.getStates()[0];
  66.         final SpacecraftState emissionState     = refState.shiftedBy(emissionDate.durationFrom(refState.getDate()));
  67.         final Transform       spacecraftToInert = emissionState.toTransform().getInverse();

  68.         // compute the geometrical value of the range directly from participants positions.
  69.         // Note that this may be different from the value returned by estimated.getEstimatedValue(),
  70.         // because other modifiers may already have been taken into account
  71.         final Vector3D pSpacecraft = spacecraftToInert.transformPosition(Vector3D.ZERO);
  72.         final double rangeUsingSpacecraftCenter = Vector3D.distance(pSpacecraft, pReception);

  73.         // compute the geometrical value of the range replacing
  74.         // the spacecraft position with antenna phase center position
  75.         final Vector3D pAPC = spacecraftToInert.transformPosition(antennaPhaseCenter);
  76.         final double rangeUsingAntennaPhaseCenter = Vector3D.distance(pAPC, pReception);

  77.         // get the estimated value before this modifier is applied
  78.         final double[] value = estimated.getEstimatedValue();

  79.         // modify the value
  80.         value[0] += rangeUsingAntennaPhaseCenter - rangeUsingSpacecraftCenter;
  81.         estimated.setEstimatedValue(value);

  82.     }

  83.     /** Apply a modifier to a two-way range measurement.
  84.      * @param estimated estimated measurement to modify
  85.      */
  86.     private void modifyTwoWay(final EstimatedMeasurement<Range> estimated) {

  87.         // the participants are ground station at emission, spacecraft, ground station at reception
  88.         // or spacecraft, ground station at reception if oneWay
  89.         final TimeStampedPVCoordinates[] participants = estimated.getParticipants();
  90.         final Vector3D                   pEmission    = participants[0].getPosition();
  91.         final AbsoluteDate               transitDate  = participants[1].getDate();
  92.         final Vector3D                   pReception   = participants[2].getPosition();

  93.         // transform from spacecraft to inertial frame at transit date
  94.         final SpacecraftState refState          = estimated.getStates()[0];
  95.         final SpacecraftState transitState      = refState.shiftedBy(transitDate.durationFrom(refState.getDate()));
  96.         final Transform       spacecraftToInert = transitState.toTransform().getInverse();

  97.         // compute the geometrical value of the range directly from participants positions.
  98.         // Note that this may be different from the value returned by estimated.getEstimatedValue(),
  99.         // because other modifiers may already have been taken into account
  100.         final Vector3D pSpacecraft = spacecraftToInert.transformPosition(Vector3D.ZERO);
  101.         final double rangeUsingSpacecraftCenter =
  102.                         0.5 * (Vector3D.distance(pEmission, pSpacecraft) + Vector3D.distance(pSpacecraft, pReception));

  103.         // compute the geometrical value of the range replacing
  104.         // the spacecraft position with antenna phase center position
  105.         final Vector3D pAPC = spacecraftToInert.transformPosition(antennaPhaseCenter);
  106.         final double rangeUsingAntennaPhaseCenter =
  107.                         0.5 * (Vector3D.distance(pEmission, pAPC) + Vector3D.distance(pAPC, pReception));

  108.         // get the estimated value before this modifier is applied
  109.         final double[] value = estimated.getEstimatedValue();

  110.         // modify the value
  111.         value[0] += rangeUsingAntennaPhaseCenter - rangeUsingSpacecraftCenter;
  112.         estimated.setEstimatedValue(value);

  113.     }

  114. }