TestKeplerian.cpp

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////////////////////////////////
/*! \file TestKeplerian.cpp
 *  \brief Implementation of the Keplerian orbit state representation.
 *  \author $Author: jayhawk_hokie $
 *  \version $Revision: 1.2 $
 *  \date    $Date: 2006/08/25 15:50:37 $
 *//////////////////////////////////////////////////////////////////////////////////////////////////
/* 
 *
 */
//////////////////////////////////////////////////////////////////////////////////////////////////

#include "TestKeplerian.h"
#include "MappingMeanOsculatingOrbitElements.h"

namespace O_SESSAME {

/*! \brief Default Deconstructor */
TestKeplerian::~TestKeplerian()
{
}


/*! \brief Return a pointer to a new instance of a TestKeplerian orbit state representation type.
 *
 *  This is used to request memory for a new instance of a Keplerian. It is necessary 
 *      when attempting to get a pointer from the abstract data type OrbitStateRepresentation 
 *      and the actual representation type isn't known.
 * @return a pointer to a new allocation of memory for the Keplerian object.
 */
TestKeplerian* TestKeplerian::NewPointer()
{
    return new TestKeplerian();
}


/*! \brief Return a pointer to a copy of the Keplerian orbit state representation instance.
 *
 *  This is used to request memory for a copy of this instance of Keplerian. It is necessary 
 *      when attempting to get a pointer from the abstract data type OrbitStateRepresentation 
 *      and the actual representation type isn't known.
 * @return a pointer to a copy of the Keplerian object.
 */
TestKeplerian* TestKeplerian::Clone()
{
    return new TestKeplerian(*this);
}


/*! \brief Create a TestKeplerian orbit state representation and test the Keplerian functions.
 *
 */
TestKeplerian::TestKeplerian() : m_OrbitalElementCheck( NUM_KEPLERIAN_ELEMENTS ), m_PositionVelocityCheck( NUM_KEPLERIAN_ELEMENTS )
{
}


/*! \brief A function to check the Keplerian class.
 *
 */
void TestKeplerian::Check()
{
        /* Check the Keplerian Class */
        cout << "\nChecking the Keplerian Class... " << endl;

        /* First Check */
        cout << "Checking Low Earth Orbit: Keplerian -> ECI, then ECI -> Keplerian. " << endl;

        m_OrbitalElementCheck(1) = 6800 ;
        m_OrbitalElementCheck(2) = 0.05 ;
        m_OrbitalElementCheck(3) = Deg2Rad( 50.0 ) ;
        m_OrbitalElementCheck(4) = Deg2Rad( 60.0 ) ;
        m_OrbitalElementCheck(5) = Deg2Rad( 20.0 ) ;
        m_OrbitalElementCheck(6) = Deg2Rad( 10.0 ) ;

        /* Check conversion */
        Keplerian2ECI2Keplerian( );



        /* Second Check */
        cout << "\nChecking Low Earth Orbit Circular Orbit: Keplerian -> ECI, then ECI -> Keplerian. " << endl;

        m_OrbitalElementCheck(1) = 6800 ;
        m_OrbitalElementCheck(2) = 0.0 ;
        m_OrbitalElementCheck(3) = Deg2Rad( 30.0 ) ;
        m_OrbitalElementCheck(4) = Deg2Rad( 10.0 ) ;
        m_OrbitalElementCheck(5) = Deg2Rad( 0.0 ) ;
        m_OrbitalElementCheck(6) = Deg2Rad( 40.0 ) ;

        /* Check conversion */
        Keplerian2ECI2Keplerian( );
        
        /* Third Check */
        cout << "\nChecking Low Earth Equatorial Orbit: Keplerian -> ECI, then ECI -> Keplerian. " << endl;

        m_OrbitalElementCheck(1) = 6800 ;
        m_OrbitalElementCheck(2) = 0.1 ;
        m_OrbitalElementCheck(3) = Deg2Rad( 0.0 ) ;
        m_OrbitalElementCheck(4) = Deg2Rad( 0.0 ) ;
        m_OrbitalElementCheck(5) = Deg2Rad( 0.0 ) ;
        m_OrbitalElementCheck(6) = Deg2Rad( 10.0 ) ;

        /* Check conversion */
        Keplerian2ECI2Keplerian( );
        
        /* Forth Check */
        cout << "\nChecking Low Earth Circular Equatorial Orbit: Keplerian -> ECI, then ECI -> Keplerian. " << endl;

        m_OrbitalElementCheck(1) = 6800 ;
        m_OrbitalElementCheck(2) = 0.0 ;
        m_OrbitalElementCheck(3) = Deg2Rad( 0.0 ) ;
        m_OrbitalElementCheck(4) = Deg2Rad( 0.0 ) ;
        m_OrbitalElementCheck(5) = Deg2Rad( 0.0 ) ;
        m_OrbitalElementCheck(6) = Deg2Rad( 70.0 ) ;

        /* Check conversion */
        Keplerian2ECI2Keplerian( );


        /* Check OsculatingOrbitalElements Class */
        cout << "\n\nChecking the OsculatingOrbitalElements Class... " << endl;

        m_OrbitalElementCheck(1) = 6800 ;
        m_OrbitalElementCheck(2) = 0.1 ;
        m_OrbitalElementCheck(3) = Deg2Rad( 10.0 ) ;
        m_OrbitalElementCheck(4) = Deg2Rad( 20.0 ) ;
        m_OrbitalElementCheck(5) = Deg2Rad( 30.0 ) ;
        m_OrbitalElementCheck(6) = Deg2Rad( 40.0 ) ;

        Keplerian _Orbit;
        _Orbit.SetKeplerianRepresentationTrueAnomaly( m_OrbitalElementCheck );

        OsculatingOrbitalElements _OsculatingOrbit;
        _OsculatingOrbit.SetOsculatingOrbitalElements( _Orbit );
        
        Keplerian _meanOrbit;
        _meanOrbit = _OsculatingOrbit.GetMeanOrbitalElements( );
 
        _OsculatingOrbit.SetMeanOrbitalElements ( _meanOrbit );
        Keplerian _Orbit2;
        _Orbit2 = _OsculatingOrbit.GetOsculatingOrbitalElements( );
 
        cout << "Initial Osculating Keplerian Vector: " << endl;
        DisplayKeplerian( _Orbit );
        cout << "Final Osculating Keplerian Vector: " << endl;
        DisplayKeplerian( _Orbit2 );
        cout << "Previous Vectors should be the same if the Osculating functions are working" << endl;
        bool _status;
        _status = CompareKeplerian( _Orbit, _Orbit2 );
        ErrorCheck( _status );

        return;
}


void TestKeplerian::Keplerian2ECI2Keplerian( )
{
        bool status;    
        Keplerian _check( m_OrbitalElementCheck );

        Vector positionVelocity(6);
        positionVelocity = _check.GetPositionVelocity(); // IJK frame
        
        Keplerian _compare;
        _compare.SetPositionVelocity( positionVelocity );

        /* Display Results */
        cout << "Keplerian Initial Vector: " << endl;
        DisplayKeplerian( _check );
        cout << "Position and Velocity conversion from Keplerian Vector: " << endl;
        DisplayPositionVelocity( positionVelocity );
        cout << "Keplerian Vector from position and velocity conversion: " << endl;
        DisplayKeplerian( _compare );

        status = CompareKeplerian( _check, _compare );
        ErrorCheck( status );

        return;
}       

bool TestKeplerian::CompareKeplerian( Keplerian _keplerianA, Keplerian _keplerianB )
{
        if( abs( _keplerianA.GetSemimajorAxis() -  _keplerianB.GetSemimajorAxis() ) > 0.001 )
                return false;  
        if( abs( _keplerianA.GetEccentricity() -  _keplerianB.GetEccentricity() ) > 0.001 )
                return false;  
        if( abs( _keplerianA.GetInclination() -  _keplerianB.GetInclination() ) > 0.001 )
                return false;  
        if( abs( _keplerianA.GetLongAscNode() -  _keplerianB.GetLongAscNode() ) > 0.001 )
                return false;  
        if( abs( _keplerianA.GetArgPerigee() -  _keplerianB.GetArgPerigee() ) > 0.001 )
                return false;  
        if( abs( _keplerianA.GetTrueAnomaly() -  _keplerianB.GetTrueAnomaly() ) > 0.001 )
                return false;  
        if( abs( _keplerianA.GetEccentricAnomaly() -  _keplerianB.GetEccentricAnomaly() ) > 0.001 )
                return false;  
        if( abs( _keplerianA.GetMeanAnomaly() -  _keplerianB.GetMeanAnomaly() ) > 0.001 )
                return false;  
        else
                return true;
}

void TestKeplerian::ErrorCheck( bool _status )
{
        if ( _status == true )
                cout << "------ Check Good ------ " << endl;
        else
                cout <<  "********* WARNING: Check Bad *********** " << endl;
        return;
}

void TestKeplerian::DisplayKeplerian( Keplerian _keplerian )
{

        cout << "Display of Keplerian Variables:\n " 
                << "Semimajor Axis (km): "      << _keplerian.GetSemimajorAxis()
                << " Eccentricity (~): "        << _keplerian.GetEccentricity()
                << " Inclination (rad): "       << _keplerian.GetInclination()
                << " Long Ascending Node (rad): " << _keplerian.GetLongAscNode()
                << " Argument of Perigee (rad): " << _keplerian.GetArgPerigee()
                << " True Anomaly (rad): "      << _keplerian.GetTrueAnomaly()
                << " Eccentric Anomaly (rad): " << _keplerian.GetEccentricAnomaly()
                << " Mean Anomaly (-): "        << _keplerian.GetMeanAnomaly()
                << endl;
}

void TestKeplerian::DisplayPositionVelocity( Vector _positionVelocity )
{
        cout << "ECI Reference Frame-\n Position (km): " 
                << ~_positionVelocity( _(1,3) )
                << " Velocity (km/s): " << ~_positionVelocity( _(4,6) )
                << endl;

}

} // close namespace O_SESSAME

// Do not change the comments below - they will be added automatically by CVS
/*****************************************************************************
*       $Log: TestKeplerian.cpp,v $
*       Revision 1.2  2006/08/25 15:50:37  jayhawk_hokie
*       Added tests for the OsculatingOrbitalElements Class.
*       
*       Revision 1.1  2006/08/23 21:49:52  jayhawk_hokie
*       Initial submission.
*       
*
*
*
******************************************************************************/

---