Propagators

Tudat/Astrodynamics/Aerodynamics/CMakeLists.txt

@@ -43,6 +43,7 @@ set(AERODYNAMICS_SOURCES
   "${SRCROOT}${AERODYNAMICSDIR}/hypersonicLocalInclinationAnalysis.cpp"
   "${SRCROOT}${AERODYNAMICSDIR}/tabulatedAtmosphere.cpp"
   "${SRCROOT}${AERODYNAMICSDIR}/customAerodynamicCoefficientInterface.cpp"
+  "${SRCROOT}${AERODYNAMICSDIR}/flightConditions.cpp"
 )
 
 # Set the header files.
@@ -61,6 +62,8 @@ set(AERODYNAMICS_HEADERS
   "${SRCROOT}${AERODYNAMICSDIR}/tabulatedAtmosphere.h"
   "${SRCROOT}${AERODYNAMICSDIR}/standardAtmosphere.h"
   "${SRCROOT}${AERODYNAMICSDIR}/customAerodynamicCoefficientInterface.h"
+  "${SRCROOT}${AERODYNAMICSDIR}/flightConditions.h"
+  "${SRCROOT}${AERODYNAMICSDIR}//UnitTests/testApolloCapsuleCoefficients.h"
 )
 
 if(USE_NRLMSISE00)
@@ -77,7 +80,7 @@ setup_tudat_library_target(tudat_aerodynamics "${SRCROOT}{AERODYNAMICSDIR}")
 # Add unit tests.
 add_executable(test_AerodynamicMomentAndAerodynamicForce "${SRCROOT}${AERODYNAMICSDIR}/UnitTests/unitTestAerodynamicMomentAndAerodynamicForce.cpp")
 setup_custom_test_program(test_AerodynamicMomentAndAerodynamicForce "${SRCROOT}${AERODYNAMICSDIR}")
-target_link_libraries(test_AerodynamicMomentAndAerodynamicForce tudat_aerodynamics ${Boost_LIBRARIES})
+target_link_libraries(test_AerodynamicMomentAndAerodynamicForce tudat_simulation_setup tudat_aerodynamics tudat_reference_frames tudat_ephemerides tudat_basic_mathematics ${Boost_LIBRARIES})
 
 add_executable(test_AerodynamicsNamespace "${SRCROOT}${AERODYNAMICSDIR}/UnitTests/unitTestAerodynamicsNamespace.cpp")
 setup_custom_test_program(test_AerodynamicsNamespace "${SRCROOT}${AERODYNAMICSDIR}")

Tudat/Astrodynamics/Aerodynamics/UnitTests/testApolloCapsuleCoefficients.h

@@ -0,0 +1,90 @@
+#ifndef TUDAT_TESTAPOLLOCAPSULECOEFFICIENTS_H
+#define TUDAT_TESTAPOLLOCAPSULECOEFFICIENTS_H
+
+#include "Tudat/Mathematics/BasicMathematics/mathematicalConstants.h"
+#include "Tudat/Astrodynamics/Aerodynamics/hypersonicLocalInclinationAnalysis.h"
+#include "Tudat/Mathematics/GeometricShapes/capsule.h"
+
+namespace tudat
+{
+namespace unit_tests
+{
+
+using basic_mathematics::Vector6d;
+using mathematical_constants::PI;
+using std::vector;
+using namespace aerodynamics;
+
+boost::shared_ptr< HypersonicLocalInclinationAnalysis > getApolloCoefficientInterface( )
+{
+
+    // Create test capsule.
+    boost::shared_ptr< geometric_shapes::Capsule > capsule
+            = boost::make_shared< geometric_shapes::Capsule >(
+                4.694, 1.956, 2.662, -1.0 * 33.0 * PI / 180.0, 0.196 );
+
+    vector< int > numberOfLines;
+    vector< int > numberOfPoints;
+    vector< bool > invertOrders;
+    numberOfLines.resize( 4 );
+    numberOfPoints.resize( 4 );
+    invertOrders.resize( 4 );
+
+    // Set number of analysis points.
+    numberOfLines[ 0 ] = 31;
+    numberOfPoints[ 0 ] = 31;
+    numberOfLines[ 1 ] = 31;
+    numberOfPoints[ 1 ] = 31;
+    numberOfLines[ 2 ] = 31;
+    numberOfPoints[ 2 ] = 10;
+    numberOfLines[ 3 ] = 11;
+    numberOfPoints[ 3 ] = 11;
+    invertOrders[ 0 ] = 0;
+    invertOrders[ 1 ] = 0;
+    invertOrders[ 2 ] = 0;
+    invertOrders[ 3 ] = 0;
+
+    Eigen::Vector3d momentReference;
+    momentReference( 0 ) = -0.6624;
+    momentReference( 1 ) = 0.0;
+    momentReference( 2 ) = -0.1369;
+
+    std::vector< std::vector< double > > independentVariableDataPoints;
+    independentVariableDataPoints.resize( 3 );
+    independentVariableDataPoints[ 0 ] = getDefaultHypersonicLocalInclinationMachPoints( "Full" );
+    std::vector< double > angleOfAttackPoints;
+    angleOfAttackPoints.resize( 7 );
+
+    for ( int i = 0; i < 7; i++ )
+    {
+        angleOfAttackPoints[ i ] = static_cast< double >( i - 6 ) * 5.0 * PI / 180.0;
+    }
+
+    independentVariableDataPoints[ 1 ] = angleOfAttackPoints;
+    independentVariableDataPoints[ 2 ] =
+            getDefaultHypersonicLocalInclinationAngleOfSideslipPoints( );
+    std::vector< std::vector< int > > selectedMethods;
+    selectedMethods.resize( 2 );
+    selectedMethods[ 0 ].resize( 4 );
+    selectedMethods[ 1 ].resize( 4 );
+
+    selectedMethods[ 0 ][ 0 ] = 1;
+    selectedMethods[ 0 ][ 1 ] = 5;
+    selectedMethods[ 0 ][ 2 ] = 5;
+    selectedMethods[ 0 ][ 3 ] = 1;
+    selectedMethods[ 1 ][ 0 ] = 6;
+    selectedMethods[ 1 ][ 1 ] = 3;
+    selectedMethods[ 1 ][ 2 ] = 3;
+    selectedMethods[ 1 ][ 3 ] = 3;
+
+    // Create analysis object and capsule database.
+    return boost::make_shared< HypersonicLocalInclinationAnalysis >(
+                independentVariableDataPoints, capsule, numberOfLines, numberOfPoints,
+                invertOrders, selectedMethods, PI * pow( capsule->getMiddleRadius( ), 2.0 ),
+                3.9116, momentReference );
+}
+
+}
+
+}
+#endif // TUDAT_TESTAPOLLOCAPSULECOEFFICIENTS_H

Tudat/Astrodynamics/Aerodynamics/UnitTests/unitTestAerodynamicMomentAndAerodynamicForce.cpp

@@ -66,6 +66,7 @@
 #include "Tudat/Astrodynamics/Aerodynamics/customAerodynamicCoefficientInterface.h"
 #include "Tudat/Astrodynamics/Aerodynamics/aerodynamicAcceleration.h"
 #include "Tudat/Astrodynamics/Aerodynamics/aerodynamicRotationalAcceleration.h"
+#include "Tudat/SimulationSetup/createFlightConditions.h"
 
 namespace tudat
 {
@@ -76,6 +77,7 @@ namespace unit_tests
 BOOST_AUTO_TEST_SUITE( test_aerodynamic_acceleration_force_moment_models )
 
 using namespace aerodynamics;
+using namespace simulation_setup;
 
 //! Test implementation of aerodynamic force and acceleration models.
 BOOST_AUTO_TEST_CASE( testAerodynamicForceAndAcceleration )

Tudat/Astrodynamics/Aerodynamics/UnitTests/unitTestCoefficientGenerator.cpp

@@ -52,13 +52,14 @@
 #include <Eigen/Core>
 
 #include "Tudat/Mathematics/BasicMathematics/mathematicalConstants.h"
-
 #include "Tudat/Astrodynamics/Aerodynamics/hypersonicLocalInclinationAnalysis.h"
 #include "Tudat/Astrodynamics/Aerodynamics/customAerodynamicCoefficientInterface.h"
 #include "Tudat/Mathematics/BasicMathematics/linearAlgebraTypes.h"
 #include "Tudat/Mathematics/GeometricShapes/capsule.h"
 #include "Tudat/Mathematics/GeometricShapes/sphereSegment.h"
 
+#include "Tudat/Astrodynamics/Aerodynamics/UnitTests/testApolloCapsuleCoefficients.h"
+
 namespace tudat
 {
 namespace unit_tests
@@ -274,20 +275,8 @@ BOOST_AUTO_TEST_CASE( testAerodynamicCoefficientGenerator )
     }
 }
 
-//! Apollo capsule test case.
-BOOST_AUTO_TEST_CASE( testApolloCapsule )
+boost::shared_ptr< HypersonicLocalInclinationAnalysis > getApolloCoefficientInterface( )
 {
-    // Set units of coefficients.
-    const double expectedValueOfAerodynamicCoefficients0 = -1.51;
-    const double expectedValueOfAerodynamicCoefficients4 = -0.052;
-
-    // Tolerance in absolute units.
-    const double toleranceAerodynamicCoefficients0 = 0.1;
-    const double toleranceAerodynamicCoefficients1 = std::numeric_limits< double >::epsilon( );
-    const double toleranceAerodynamicCoefficients2 = std::numeric_limits< double >::epsilon( );
-    const double toleranceAerodynamicCoefficients3 = std::numeric_limits< double >::epsilon( );
-    const double toleranceAerodynamicCoefficients4 = 0.05;
-    const double toleranceAerodynamicCoefficients5 = std::numeric_limits< double >::epsilon( );
 
     // Create test capsule.
     boost::shared_ptr< geometric_shapes::Capsule > capsule
@@ -341,11 +330,28 @@ BOOST_AUTO_TEST_CASE( testApolloCapsule )
     selectedMethods[ 1 ][ 3 ] = 3;
 
     // Create analysis object and capsule database.
-    boost::shared_ptr< HypersonicLocalInclinationAnalysis > coefficientInterface =
-            boost::make_shared< HypersonicLocalInclinationAnalysis >(
+    return boost::make_shared< HypersonicLocalInclinationAnalysis >(
                 independentVariableDataPoints, capsule, numberOfLines, numberOfPoints,
                 invertOrders, selectedMethods, PI * pow( capsule->getMiddleRadius( ), 2.0 ),
                 3.9116, momentReference );
+}
+//! Apollo capsule test case.
+BOOST_AUTO_TEST_CASE( testApolloCapsule )
+{
+    // Set units of coefficients.
+    const double expectedValueOfAerodynamicCoefficients0 = -1.51;
+    const double expectedValueOfAerodynamicCoefficients4 = -0.052;
+
+    // Tolerance in absolute units.
+    const double toleranceAerodynamicCoefficients0 = 0.1;
+    const double toleranceAerodynamicCoefficients1 = std::numeric_limits< double >::epsilon( );
+    const double toleranceAerodynamicCoefficients2 = std::numeric_limits< double >::epsilon( );
+    const double toleranceAerodynamicCoefficients3 = std::numeric_limits< double >::epsilon( );
+    const double toleranceAerodynamicCoefficients4 = 0.05;
+    const double toleranceAerodynamicCoefficients5 = std::numeric_limits< double >::epsilon( );
+
+    // Create aerodynamic coefficients.
+    boost::shared_ptr< HypersonicLocalInclinationAnalysis > coefficientInterface = getApolloCoefficientInterface( );
 
     // Retrieve coefficients at zero angle of attack for comparison.
     boost::array< int, 3 > independentVariables;

Tudat/Astrodynamics/Aerodynamics/aerodynamicAcceleration.h

@@ -40,6 +40,8 @@
 #ifndef TUDAT_AERODYNAMIC_ACCELERATION_H
 #define TUDAT_AERODYNAMIC_ACCELERATION_H
 
+#include <iostream>
+
 #include <boost/function.hpp>
 #include <boost/lambda/lambda.hpp>
 #include <boost/shared_ptr.hpp>
@@ -190,14 +192,18 @@ class AerodynamicAcceleration : public basic_astrodynamics::AccelerationModel< E
      * Function pointers to retrieve the current values of quantities from which the
      * acceleration is to be calculated are set by constructor. This function calls
      * them to update the associated variables to their current state.
+     * \param currentTime Time at which acceleration model is to be updated.
      */
-    void updateMembers( )
+    void updateMembers( const double currentTime = TUDAT_NAN )
     {
-        currentForceCoefficients_ = coefficientMultiplier_ * this->coefficientFunction_( );
-        currentDensity_ = this->densityFunction_( );
-        currentMass_ = this->massFunction_( );
-        currentAirspeed_ = this->airSpeedFunction_( );
-        currentReferenceArea_ = this->referenceAreaFunction_( );
+        if( !( this->currentTime_ == currentTime ) )
+        {
+            currentForceCoefficients_ = coefficientMultiplier_ * this->coefficientFunction_( );
+            currentDensity_ = this->densityFunction_( );
+            currentMass_ = this->massFunction_( );
+            currentAirspeed_ = this->airSpeedFunction_( );
+            currentReferenceArea_ = this->referenceAreaFunction_( );
+        }
     }
 
 private:

Tudat/Astrodynamics/Aerodynamics/aerodynamicCoefficientInterface.h

@@ -59,7 +59,7 @@ namespace aerodynamics
  *  Enum defining a list of independent variables on which the aerodynamic coefficients can depend.
  *  Note that for a custom coefficient interface with other variables, you may use the
  *  undefined_independent_variable variable type, but at the expense of being able to use the
- *  FlightConditions class to automatically update the aerodynamic coefficients during propagation.
+ *  FlightConditions class to automatically updates the aerodynamic coefficients during propagation.
  */
 enum AerodynamicCoefficientsIndependentVariables
 {
@@ -241,7 +241,27 @@ class AerodynamicCoefficientInterface
         return numberOfIndependentVariables_;
     }
 
+    //! Function that returns whether the coefficients are given in aerodynamic frame.
+    /*!
+     * Function that returns whether the coefficients are given in aerodynamic frame (given in body)
+     * frame if false.
+     * \return Boolean whether coefficients are in aerodynamic frame
+     */
+    bool getAreCoefficientsInAerodynamicFrame( )
+    {
+        return areCoefficientsInAerodynamicFrame_;
+    }
 
+    //! Function that returns whether the coefficients are positive in positive axes directions.
+    /*!
+     * Function that returns whether the coefficients are positive in positive axes directions, i.e.
+     * if positive force (in given frame) gives positive coefficients.
+     * \return Boolean whether coefficients are in positive direction.
+     */
+    bool getAreCoefficientsInNegativeAxisDirection( )
+    {
+        return areCoefficientsInNegativeAxisDirection_;
+    }
 
 protected:
 

Tudat/Astrodynamics/Aerodynamics/aerodynamicForce.cpp

@@ -1,3 +1,13 @@
+/*    Copyright (c) 2010-2016, Delft University of Technology
+ *    All rigths reserved
+ *
+ *    This file is part of the Tudat. Redistribution and use in source and
+ *    binary forms, with or without modification, are permitted exclusively
+ *    under the terms of the Modified BSD license. You should have received
+ *    a copy of the license with this file. If not, please or visit:
+ *    http://tudat.tudelft.nl/LICENSE.
+ */
+
 #include "Tudat/Astrodynamics/Aerodynamics/aerodynamicForce.h"
 
 namespace tudat

Tudat/Astrodynamics/Aerodynamics/customAerodynamicCoefficientInterface.cpp

@@ -1,66 +0,0 @@
-/*    Copyright (c) 2010-2015, Delft University of Technology
- *    All rights reserved.
- *
- *    Redistribution and use in source and binary forms, with or without modification, are
- *    permitted provided that the following conditions are met:
- *      - Redistributions of source code must retain the above copyright notice, this list of
- *        conditions and the following disclaimer.
- *      - Redistributions in binary form must reproduce the above copyright notice, this list of
- *        conditions and the following disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *      - Neither the name of the Delft University of Technology nor the names of its contributors
- *        may be used to endorse or promote products derived from this software without specific
- *        prior written permission.
- *
- *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
- *    OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- *    COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- *    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
- *    GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- *    AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- *    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- *    OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *    Changelog
- *      YYMMDD    Author            Comment
- *      150416    D. Dirkx          File created.
- *
- */
-
-#include <boost/lambda/lambda.hpp>
-
-#include "Tudat/Astrodynamics/Aerodynamics/customAerodynamicCoefficientInterface.h"
-
-namespace tudat
-{
-namespace aerodynamics
-{
-
-//! Function to create an aerodynamic coefficient interface containing constant coefficients.
-boost::shared_ptr< AerodynamicCoefficientInterface >
-createConstantCoefficientAerodynamicCoefficientInterface(
-        const Eigen::Vector3d constantForceCoefficient,
-        const Eigen::Vector3d constantMomentCoefficient,
-        const double referenceLength,
-        const double referenceArea,
-        const double lateralReferenceLength,
-        const Eigen::Vector3d& momentReferencePoint,
-        const bool areCoefficientsInAerodynamicFrame,
-        const bool areCoefficientsInNegativeAxisDirection  )
-{
-    // Create coefficient interface
-    boost::shared_ptr< AerodynamicCoefficientInterface > coefficientInterface =
-            boost::make_shared< CustomAerodynamicCoefficientInterface >(
-                    boost::lambda::constant( constantForceCoefficient ),
-                    boost::lambda::constant( constantMomentCoefficient ),
-                    referenceLength, referenceArea, lateralReferenceLength, momentReferencePoint,
-                std::vector< AerodynamicCoefficientsIndependentVariables >( ),
-                areCoefficientsInAerodynamicFrame, areCoefficientsInNegativeAxisDirection );
-    coefficientInterface->updateCurrentCoefficients( std::vector< double >( ) );
-
-    return coefficientInterface;
-}
-
-} // namespace aerodynamics
-} // namespace tudat