| Earth Observation Mission CFI Software Usage Guide for Object Oriented Software |

# TARGET CALCULATION

This functionality performs accurate computation of pointing parameters from and to a satellite for various types of targets. Classes and methods for this functionality can be found in the Pointing CFI Library.
Before the user could call targets function, some parameters has to be initialised:

- Attitude: The attitude defines the relation between satellite coordinate frames and a general reference frame. The Earth Observation CFI provides a flexible way for the attitude computation, so that it could covers almost any satellite attitude system. Please refer to the [MCD] for further details about the satellite coordinate frames used for the attitude computation. (See Attitude Computation)

- For some targets calculation, it could be needed to take into account the atmospheric refraction of a signal travelling to/from the satellite. In these cases the user could choose the atmospheric model to use. For using an atmospheric model in the target calculation, the atmosphere configuration data has to be stored in an object of the AtmosId class. Afterwards this object is introduced in the target computation methods.(See Targets crossing the atmosphere)

- For geolocation routines it could be needed a digital elevation model (DEM) in order to get a more accurate target. The DEM is introduced in the target calculation methods using the CFI class DemId. (See Targets with a Digital Elevation Model)

Note that only the attitude initialisation is mandatory before doing any target computation. Go to the Targets sub-section to know more about the targets that can be computed.

## Attitude Computation

The attitude computation consists on the calculation of a rotation matrix (attitude matrix) from an inertial frame to a satellite/instrument reference frame (target frame). The Earth Observation CFI software requires the definition of a set of satellite frames, so that the attitude is computed as a sequence of rotations from the inertial frame to the requested target frame (see [MCD]). We can summarise the attitude computation in the following steps:

- Satellite and instrument attitude frames initialisation. There are four different levels of attitude frames:

  - Orbital Frame
  - Satellite Nominal Attitude Frame (SNAF)
  - Satellite Attitude Frame (SAF)
  - Instrument Attitude Frame (IRF)

  The Orbital frame is defined by the satellite state vector, so the user does not need to define it. However the satellite and instrument frames have to be defined by the user. The definition data (initialisation) are stored in objects of the clases: SatNomTransId, SatTransId and InstrTransId respectively. These classes have a set of initialisation methods where the attitude frame is defined (for example, the SAF can be definde as a rotation with respect to the SNAF or as a rotation with respect to an inertial frame...). See Figure 1, Figure 2 and Figure 3

  Note that not all attitude frames have to be defined. That depends on the target frame and the initialisation model as it is explained below.

- Attitude initialisation: An object of the class Attitude has to be created with the previous attitude frame objects. There are two possibilities:
  1. Create the Attitude with the empty constructor and then call the method setTransformations
  2. Create the Attitude using the constructor with the attitude frames
- Attitude computation: Using a satellite state vector at a given time the final attitude rotation matrix is computed by calling the method compute. The way in which the attitude matrix is computed depends on how the attitude frames where defined. Figure 4 shows the way in which this final attitude matrix is computed: The vertical arrows represent the transformation between the attitude frames, so that the attitude matrix is the combination of the transformations between the target frame and the inertial frame.

Finally, the data flow for the attitude computation is sumarised in Figure 5.

#### Figure1: Satellite Nominal Attitude frame

#### Figure2: Satellite Attitude frame

#### Figure3: Instrument Attitude frame

#### Figure4: Attitude computation schema

#### Figure5: Attitude computation data flow

## Targets

Once that the attitide has been computed, it is possible to compute a target. The list of targets is described below, but in general for every problem, there are three different target types:

- User target: it is the target requested by the user.
- LOS target (line of sight target): it is the computed raypath to reach the user target.
- DEM target: it is a target computed taking into account the DEM model. It is only used for geolocated targets targets.

A target can be constructed with the following steps:

- Construct the Target object with the Attitide and optionally with the DemId and the AtmosId.
- Call one of the target methods: targetXXX with the required parameters.
- The previous methods do not return directly the computed target parameters. The results have to be retrieved for one of thet target types (user, LOS or DEM) with one of the following methods:
  - extraVector
  - extraMain
  - extraAux
  - extraTargetToSun
  - extraTargetToMoon
  - extraEfTarget
  - extraEspecularReflection

The list of targets that can be computed is the following:

Target::targetXXX method | Description
--- | ---
Target::targetInter / Target::multiTargetInter | It calculates the intersection point(s) of the line of sight defined by an elevation and an azimuth angle expressed in the input Attitude frame, with a surface(s) located at a certain geodetic altitude(s) over the Earth.
Target::targetTravelTime / Target::multiTargetTravelTime | It calculates the point of the line or sight from the satellite (defined by an elevation and an azimuth angle expressed in the selected Attitude Frame) at a given travel time(s) along the (curved) line of sight.
Target::targetGroundRange | It calculates the location of a point that is placed on a surface at a certain geodetic altitude over the Earth, that lays on the plane defined by theS/C position, the nadir and a reference point, and that is at a certain distance or ground range measured along that surface from that reference point. This reference point is calculated being the intersection of the previous surface with the line of sight defined by an elevation and azimuth angle in the input Attitude coordinate system.
Target::targetIncidenceAngle | It calculates the location of a point that is placed on a surface at a certain geodetic altitude over the Earth and that is seen from the S/C on a line of sight that forms a certain azimuth angle in the input Attitude frame and that intersects that surface with a certain incidence angle.
Target::targetRange | It calculates the location of a point that is placed on a surface at a certain geodetic altitude over the Earth, that is seen from the S/C on a line of sight that forms a certain azimuth angle in the input Attitude frame, and that is at a certain range or slant-range from the S/C.
Target::targetRangeRate | It calculates the location of a point that is placed on a surface at a certain geodetic altitude over the Earth, that is at a certain range from S/C, and whose associated Earth-fixed target has a certain range-rate value.
Target::targetTangent | It calculates the location of the tangent point over the Earth that is located on the line of sight defined by an elevation and azimuth angles expressed in the input Attitude frame.
Target::targetAltitude | It calculates the location of the tangent point over the Earth that is located on a surface at a certain geodetic altitude over the Earth and that is on a line of sight that forms a certain azimuth angle in the input Attitude frame.
Target::targetStar | It calculates the location of the tangent point over the Earth that is located on the line of sight that points to a star defined by its right ascension and declination coordinates.
Target::targetGeneric | The cartesian state vector of the target is taken as an input.
Target::targetTangentSun | It calculates the location of the tangent point over the Earth that is located on the line of sight that points to the Sun
Target::targetTangentMoon | It calculates the location of the tangent point over the Earth that is located on the line of sight that points to the Moon
Target::targetStation | It calculates the most relevant observation parameters of the link between the satellite and a ground station |
Target::targetDRS | It calculates the most relevant observation parameters of the link between the satellite and a Data Relay Satellite (DRS).

## Targets crossing the atmosphere

The atmospheric refraction of a signal travelling from/to the satellite can be taken into account when computing a target:

- Compute the Attitude
- Create an object of AtmosId class
- Initialise the AtmosId object with the method init
- Construct the Target using the AtmosId as defined in the previous section
- Compute the Target with one of the target methods defined above

## Targets with a Digital Elevation Model

A target with a DEM can be computed in the following way:

- Create an DemId object
- Initialise the DemId with the method init
- Construct the Target using the DemId as defined in the previous section
- Compute the Target with one of the target methods defined above.
- Retrieve the results corresponding to the DEM target type

## Example

The following example shows how to get compute a target going through the following steps:

1. Time Correlation initialization
2. Atmosphere initialization
3. Satellite Nominal Attitude initialization
4. Satellite Attitude initialization
5. Attitude calculations
6. Target pointing: Intersection target
7. Get target results for USER target

    // ------------------------------------------------------------------------
    //
    //                           C++ Example Program.
    //                           TARGET COMPUTATION
    //
    // ------------------------------------------------------------------------

    // Non-EOCFI include files
    #include <string>
    #include <vector>
    #include <iostream>

    // EOCFI includes
    #include "TimeCorrelation.h"
    #include "ModelId.h"
    #include "DataHandlingData.h"
    #include "PointingData.h"
    #include "LibData.h"
    #include "SatNomTransId.h"
    #include "SatTransId.h"
    #include "InstrTransId.h"
    #include "Attitude.h"
    #include "Target.h"
    #include "AtmosId.h"
    #include "DemId.h"
    #include "StateVector.h"
    #include "Coord.h"

    // Namespaces
    using namespace EECFI;
    using namespace std;

    // Main program
    int main (int argc, char *argv[])
    {
      // Local variables declaration
      // ---------------------------

      // Accessors
      ParamModel     paramModel;
      AttFileModel   satNomFileModel;
      AngleModel     angleModel;
      HarmonicModel  harmoModel;
      AttitudeData   attitudeData;
      TargetIdData   targetData;

      // Sat nominal init file
      vector<string> attitudeFile;

      // Instrument init harmonic
      vector<long> harmonicTypePitch;
      vector<long> harmonicTypeRoll;
      vector<long> harmonicTypeYaw;
      vector<double> harmonicCoeffPitch;
      vector<double> harmonicCoeffRoll;
      vector<double> harmonicCoeffYaw;

      // Target inter
      long   deriv, interFlag, iray;
      double losAz, losEl, geodAlt, losAzRate, losElRate, freq;

      // Target extravector
      long targetType;
      long targetNumber;
      vector<double> vectorResults;
      vector<double> vectorResultsRate;
      vector<double> vectorResultsRateRate;

      // Target extra main
      long   choice;
      vector<double> mainResults;
      vector<double> mainResultsRate;
      vector<double> mainResultsRateRate;

      // Target extra aux
      vector<double> auxResults;
      vector<double> auxResultsRate;
      vector<double> auxResultsRateRate;

      // Target extra to sun
      vector<double> sunResults;
      vector<double> sunResultsRate;
      vector<double> sunResultsRateRate;

      // Target extra to moon
      vector<double> moonResults;
      vector<double> moonResultsRate;
      vector<double> moonResultsRateRate;

      // Target extra EF target
      vector<double> efTargetResultsRate;
      vector<double> efTargetResultsRateRate;

      //-------------------------------------------------
      // Put all the code inside try-catch statements
      //  so, if something fails, an exception is thrown
      //-------------------------------------------------
      try
      {

        // ------------------------------------------------------------------------
        // Satellite Id, ModelId and TimeCorrelatins initialization
        // ------------------------------------------------------------------------

        SatId satId(XPCFI_SAT_ENVISAT);

        ModelId          modelId; //Do nothing: using default models.

        double initTime[4];

        initTime[0]   = -245.1000000000000000;   // TAI time [days]
        initTime[1]   = -245.0995949074074074;   // UTC time [days] (= TAI - 35.0 s)
        initTime[2]   = -245.0995879629629630;   // UT1 time [days] (= TAI - 35.6 s)
        initTime[3]   = -245.0997800925925926;   // GPS time [days] (= TAI - 19.0 s)

        TimeCorrelation  timeId( initTime );

        // ------------------------------------------------------------------------
        // Atmosphere initialization
        // ------------------------------------------------------------------------

        // input values
        long   atmosMode   =  XPCFI_LUT_INIT;
        long   atmosModel  =  0;             //dummy
        string atmosFile   = "./xp_atmo_converter_coefs.out";

        AtmosId atmosId;
        atmosId.init( atmosMode, atmosModel, atmosFile );

        // ------------------------------------------------------------------------
        //
        //             Attitude initialization functions
        //                - Satellite Nominal Attitude
        //                - Satellite Attitude
        //                - Instrument Attitude
        //
        // ------------------------------------------------------------------------

        // ------------------------------------------------------------------------
        // Satellite Nominal Attitude
        // ------------------------------------------------------------------------

        // Set input values
        vector<double> modelParam;
        long modelEnum = XPCFI_MODEL_ENVISAT;

        modelParam.push_back( -0.1671 );
        modelParam.push_back(  0.0501 );
        modelParam.push_back(  3.9130 );

        // Initialiasation
        SatNomTransId satNomTransId;

        satNomTransId.init( modelEnum, modelParam );

        // ------------------------------------------------------------------------
        // Satellite Attitude
        // ------------------------------------------------------------------------

        // input values
        double ang[3];
        ang[0] =  0.1;
        ang[1] =  0.2;
        ang[2] = -0.3;

        // Initialiasation
        SatTransId satTransId;
        satTransId.init( ang );

        // ------------------------------------------------------------------------
        // Instrument Attitude
        // ------------------------------------------------------------------------

        InstrTransId instrTransId;
        // This frame is not to be initialised. The target frame for the attitude
        // will be the Satellite Attitude.

        // ------------------------------------------------------------------------
        // Attitude calculations
        // ------------------------------------------------------------------------

        // Initialisation
        Attitude attId;

        attId.setTransformations( timeId, satNomTransId, satTransId, instrTransId );

        // Satellite vector for input
        StateVector stVec;

        stVec.time.ref     = XPCFI_TIME_UTC;
        stVec.time.time    = 255.3456;
        stVec.coord.pos[0] =  6997887.57;
        stVec.coord.pos[1] = -1536046.83;
        stVec.coord.pos[2] =    99534.18;
        stVec.coord.vel[0] =     -240.99;
        stVec.coord.vel[1] =    -1616.85;
        stVec.coord.vel[2] =    -7376.65;
        stVec.coord.acc[0] =       -7.79104;
        stVec.coord.acc[1] =        1.69353;
        stVec.coord.acc[2] =       -0.10826;

        // Attitude calculation
        attId.compute( modelId, stVec, XPCFI_SAT_ATT );

        // ------------------------------------------------------------------------
        // Target pointing: Intersection target
        // ------------------------------------------------------------------------

        DemId dem; // DEM is not to be used

        interFlag = XPCFI_INTER_1ST;
        deriv     = XPCFI_NO_DER;
        losAz     =       50.0;
        losEl     =       85.0;
        geodAlt   =      100.0;
        losAzRate =        1.0;
        losElRate =        1.0;
        iray      = XPCFI_NO_REF;
        freq      =        1.e10;

        Target targetId( attId, dem, atmosId );
        targetId.targetInter( satId, deriv, interFlag,
                              losAz, losEl, geodAlt,
                              losAzRate, losElRate,
                              iray, freq );

        // ------------------------------------------------------------------------
        //  Get target results for USER target
        //     - extraVector
        //     - extraMain
        //     - extraAux
        //     - extraTargetToSun
        //     - extraTargetToMoon
        //     - extraEfTarget
        // ------------------------------------------------------------------------

        // input values
        choice       = XPCFI_NO_DER;
        targetType   = XPCFI_USER_TARGET_TYPE;
        targetNumber = 0;

        // Target Extra Vector
        targetId.extraVector( choice,
                              targetType,
                              targetNumber,
                              vectorResults,
                              vectorResultsRate,
                              vectorResultsRateRate );

        cout << "  INPUT" << endl;
        cout << "- Time Reference   : " << stVec.time.ref << endl;
        cout << "- Time             : " << stVec.time.time << endl;
        cout << "- Sat Position     : [" << stVec.coord.pos[0] << "," << stVec.coord.pos[1] << "," << stVec.coord.pos[2] << "]" << endl;
        cout << "- Sat Velocity     : [" << stVec.coord.vel[0] << "," << stVec.coord.vel[1] << "," << stVec.coord.vel[2] << "]" << endl;
        cout << "- Sat Acceleration : [" << stVec.coord.acc[0] << "," << stVec.coord.acc[1] << "," << stVec.coord.acc[2] << "]" << endl;
        cout << "- Derivative Flag  : "  << deriv << endl;
        cout << "- Intersection Flag: " << interFlag << endl;
        cout << "- LOS Azimuth      : " << losAz << endl;
        cout << "- LOS Elevation    : " << losEl << endl;
        cout << "- Geodetic Altitude: " << geodAlt << endl;
        cout << "- LOS Azimuth Rate : " << losAzRate << endl;
        cout << "- LOS Elev. Rate   : " << losElRate << endl;
        cout << "- Ray Tracing Model: " << iray << endl;
        cout << "- Frequency        : " << freq << endl;

        cout << "  OUTPUT" << endl;
        cout << "- Target Position  : [" << vectorResults[0] << "," << vectorResults[1] << "," << vectorResults[2] << "]" << endl;
        cout << "- Range            : " << vectorResults[6] << endl;
        cout << "- Sat-Target LOS   : [" << vectorResults[3] << "," << vectorResults[4] << "," << vectorResults[5] << "]" << endl;

        // Target Extra Main results

        choice       = XPCFI_TARG_EXTRA_AUX_ALL;
        targetType   = XPCFI_USER_TARGET_TYPE;
        targetNumber = 0;

        targetId.extraMain( choice,
                            targetType,
                            targetNumber,
                            mainResults,
                            mainResultsRate,
                            mainResultsRateRate );

        cout << "  INPUT" << endl;
        cout << "- Choice Flag                : " << choice << endl;
        cout << "  OUTPUT" << endl;
        cout << "- Geocentric Long.           : " << mainResults[0] << endl;
        cout << "- Geocentric Lat.            : " << mainResults[1] << endl;
        cout << "- Geodetic Latitude          : " << mainResults[2] << endl;
        cout << "- Geodetic Altitude          : " << mainResults[3] << endl;
        cout << "- Sat. to target Top. Azimuth: " << mainResults[4] << endl;
        cout << "- Sat. to target Top. Elev.  : " << mainResults[5] << endl;
        cout << "- Target Azimuth             : " << mainResults[6] << endl;
        cout << "- Target Elevation           : " << mainResults[7] << endl;
        cout << "- Topoc. Azimuth             : " << mainResults[8] << endl;
        cout << "- Topoc. Elevation           : " << mainResults[9] << endl;
        cout << "- Geocentric Long. rate      : " << mainResultsRate[0] << endl;
        cout << "- Geocentric Lat. rate       : " << mainResultsRate[1] << endl;
        cout << "- Geodetic Latitude rate     : " << mainResultsRate[2] << endl;
        cout << "- Geodetic Altitude rate     : " << mainResultsRate[3] << endl;
        cout << "- Sat2tar Top. Azimuth rate  : " << mainResultsRate[4] << endl;
        cout << "- Sat2tar Top. Elev.rate     : " << mainResultsRate[5] << endl;
        cout << "- Target Azimuth rate        : " << mainResultsRate[6] << endl;
        cout << "- Target Elevation rate      : " << mainResultsRate[7] << endl;
        cout << "- Topoc. Azimuth rate        : " << mainResultsRate[8] << endl;
        cout << "- Topoc. Elevation rate      : " << mainResultsRate[9] << endl;
        cout << "- Geocentric Long. rate rate : " << mainResultsRateRate[0] << endl;
        cout << "- Geocentric Lat. rate rate  : " << mainResultsRateRate[1] << endl;
        cout << "- Geodetic Latitude rate rate: " << mainResultsRateRate[2] << endl;
        cout << "- Geodetic Altitude rate rate: " << mainResultsRateRate[3] << endl;
        cout << "- Sat2tar Top. Azimuth rate r: " << mainResultsRateRate[4] << endl;
        cout << "- Sat2tar Top. Elev.rate rate: " << mainResultsRateRate[5] << endl;
        cout << "- Target Azimuth rate rate   : " << mainResultsRateRate[6] << endl;
        cout << "- Target Elevation rate rate : " << mainResultsRateRate[7] << endl;
        cout << "- Topoc. Azimuth rate rate   : " << mainResultsRateRate[8] << endl;
        cout << "- Topoc. Elevation rate rate : " << mainResultsRateRate[9] << endl;

        // Target Auxiliary results
        choice       = XPCFI_TARG_EXTRA_AUX_ALL;
        targetType   = XPCFI_USER_TARGET_TYPE;
        targetNumber = 0;

        targetId.extraAux( choice,
                           targetType,
                           targetNumber,
                           auxResults,
                           auxResultsRate,
                           auxResultsRateRate );

        cout << "  INPUT" << endl;
        cout << "- Choice Flag          : " << choice << endl;

        cout << "  OUTPUT" << endl;
        cout << "- Curvature Radius at target's nadir                                     = " <<  auxResults[0] << endl;
        cout << "- Distance: target's nadir to satellites's nadir                         = " <<  auxResults[1] << endl;
        cout << "- Distance target's nadir to ground track                                = " <<  auxResults[2] << endl;
        cout << "- Distance SSP to point in the ground track nearest to the target's nadir= " <<  auxResults[3] << endl;
        cout << "- MLST at target                                                         = " <<  auxResults[4] << endl;
        cout << "- TLST at target                                                         = " <<  auxResults[5] << endl;
        cout << "- RA throught the atmosphere                                             = " <<  auxResults[6] << endl;
        cout << "- Dec. throught the atmosphere                                           = " <<  auxResults[7] << endl;
        cout << "- Curvature Radius rate at target's nadir                                = " <<  auxResultsRate[0] << endl;
        cout << "- Distance rate: target's nadir to satellites's nadir                    = " <<  auxResultsRate[1] << endl;
        cout << "- Distance rate target's nadir to ground track                           = " <<  auxResultsRate[2] << endl;
        cout << "- Distance rate SSP to point in the ground track nearest to the target's nadir= " <<  auxResultsRate[3] << endl;
        cout << "- Target's nadir velocity (relative to the Earth). North                 = " <<  auxResultsRate[8] << endl;
        cout << "- Target's nadir velocity (relative to the Earth). East                  = " <<  auxResultsRate[9] << endl;
        cout << "- Target's nadir velocity (relative to the Earth). Azimuth               = " <<  auxResultsRate[10] << endl;
        cout << "- Target's nadir velocity (relative to the Earth). Magnitude             = " <<  auxResultsRate[11] << endl;
        cout << "- Curvature Radius rate rate at target's nadir                           = " <<  auxResultsRateRate[0] << endl;
        cout << "- Distance rate rate: target's nadir to satellites's nadir               = " <<  auxResultsRateRate[1] << endl;
        cout << "- Distance rate rate target's nadir to ground track                      = " <<  auxResultsRateRate[2] << endl;
        cout << "- Distance rate rate SSP to point in the ground track nearest to the target's nadir= " <<  auxResultsRateRate[3] << endl;

        // Target: extraTargetToSun

        choice        = XPCFI_DER_2ND;
        targetType    = XPCFI_USER_TARGET_TYPE;
        targetNumber  = 0;
        iray          = XPCFI_NO_REF;
        freq          =        1.e10;

        targetId.extraTargetToSun( choice,
                                   targetType,
                                   targetNumber,
                                   iray,
                                   freq,
                                   sunResults,
                                   sunResultsRate,
                                   sunResultsRateRate );

        cout << "  INPUT" << endl;
        cout << "- Choice Flag          : " << choice << endl;
        cout << "- Ray Tracing Model    : " << iray << endl;
        cout << "- Frequency            : " << freq << endl;

        cout << "  OUTPUT" << endl;
        cout << "- Topocentric Azimuth.       : " << sunResults[0] << endl;
        cout << "- Topocentric Elevation.     : " << sunResults[1] << endl;
        cout << "- Topocentric Azimuth rate.  : " << sunResultsRate[0] << endl;
        cout << "- Topocentric Elevation rate : " << sunResultsRate[1] << endl;
        cout << "- Topocentric Az. rate rate  : " << sunResultsRateRate[0] << endl;
        cout << "- Topocentric Elev. rate rate: " << sunResultsRateRate[1] << endl;
        cout << "- Tangent Altitude           : " << sunResults[2] << endl;
        cout << "- Target to sun visibility.  : " << sunResults[3] << endl;

        // Target: extraTargetToMoon

        choice       = XPCFI_DER_2ND;
        targetType   = XPCFI_USER_TARGET_TYPE;
        targetNumber = 0;
        iray         = XPCFI_NO_REF;
        freq         =        1.e10;

        targetId.extraTargetToMoon( choice,
                                    targetType,
                                    targetNumber,
                                    iray,
                                    freq,
                                    moonResults,
                                    moonResultsRate,
                                    moonResultsRateRate);

        cout << "  INPUT" << endl;
        cout << "- Choice Flag          : " << choice << endl;
        cout << "- Ray Tracing Model    : " << iray << endl;
        cout << "- Frequency            : " << freq << endl;

        cout << "  OUTPUT" << endl;
        cout << "- Topocentric Azimuth.       : " << moonResults[0] << endl;
        cout << "- Topocentric Elevation.     : " << moonResults[1] << endl;
        cout << "- Topocentric Azimuth rate.  : " << moonResultsRate[0] << endl;
        cout << "- Topocentric Elevation rate : " << moonResultsRate[1] << endl;
        cout << "- Topocentric Az. rate rate  : " << moonResultsRateRate[0] << endl;
        cout << "- Topocentric Elev. rate rate: " << moonResultsRateRate[1] << endl;
        cout << "- Tangent Altitude           : " << moonResults[2] << endl;
        cout << "- Target to moon visibility. : " << moonResults[3] << endl;

        // Target::extraEfTarget

        choice       = XPCFI_DER_2ND;
        targetType   = XPCFI_USER_TARGET_TYPE;
        targetNumber = 0;
        freq         = 1.e10;

        targetId.extraEfTarget( choice,
                                targetType,
                                targetNumber,
                                freq,
                                efTargetResultsRate,
                                efTargetResultsRateRate );

        cout << "  INPUT" << endl;
        cout << "- Choice flag              : " << choice << endl;
        cout << "  OUTPUT" << endl;

        cout << "- EF target to satellite range rate             : " <<  efTargetResultsRate[1] << endl;
        cout << "- EF target to satellite azimuth rate (TOP)     : " <<  efTargetResultsRate[2] << endl;
        cout << "- EF target to satellite elevation rate (TOP)   : " <<  efTargetResultsRate[3] << endl;
        cout << "- Satellite to EF target azimuth rate (TOP)     : " <<  efTargetResultsRate[4] << endl;
        cout << "- Satellite to EF target elevation rate (TOP)   : " <<  efTargetResultsRate[5] << endl;
        cout << "- Satellite to EF target azimuth rate (attitude): " <<  efTargetResultsRate[6] << endl;
        cout << "- Satellite to EF target elev. rate (attitude)  : " <<  efTargetResultsRate[7] << endl;
        cout << "- 2 way doppler shift of signal                 : " <<  efTargetResultsRate[0] << endl;
        cout << "- EF target to satellite range rate rate        : " <<  efTargetResultsRateRate[1] << endl;
        cout << "- EF target to satellite az. rate rate (TOP)    : " <<  efTargetResultsRateRate[2] << endl;
        cout << "- EF target to satellite elev. rate rate (TOP)  : " <<  efTargetResultsRateRate[3] << endl;
        cout << "- Satellite to EF target az. rate rate (TOP)    : " <<  efTargetResultsRateRate[4] << endl;
        cout << "- Satellite to EF target elev. rate rate (TOP)  : " <<  efTargetResultsRateRate[5] << endl;
        cout << "- Satellite to EF target az. rate rate (att)    : " <<  efTargetResultsRateRate[6] << endl;
        cout << "- Satellite to EF target elev. rate rate (att)  : " <<  efTargetResultsRateRate[7] << endl;

      }//end try

      catch (CfiError cfiError)
      {
        //If an exception is thrown, there have been errors during execution
        vector<string> errorMessages;

        // Get error messages
        cfiError.getMsg(errorMessages);

        // Pring Error messages
        for (long i = 0; i < errorMessages.size(); i++)
        {
          cout << errorMessages[i] << endl;
        }
      }

      return 0;

    }