Mass propagation

Tudat/Astrodynamics/Aerodynamics/aerodynamicAcceleration.h

@@ -184,6 +184,7 @@ class AerodynamicAcceleration : public basic_astrodynamics::AccelerationModel< E
         return computeAerodynamicAcceleration(
                     0.5 * currentDensity_ * currentAirspeed_ * currentAirspeed_,
                     currentReferenceArea_, currentForceCoefficients_, currentMass_ );
+
     }
 
     //! Update member variables used by the aerodynamic acceleration model.

Tudat/Astrodynamics/Aerodynamics/aerodynamicCoefficientInterface.h

@@ -41,6 +41,7 @@
 #ifndef TUDAT_AERODYNAMIC_COEFFICIENT_INTERFACE_H
 #define TUDAT_AERODYNAMIC_COEFFICIENT_INTERFACE_H
 
+#include <iostream>
 #include <stdexcept>
 #include <vector>
 

Tudat/Astrodynamics/BasicAstrodynamics/CMakeLists.txt

@@ -76,6 +76,7 @@ set(BASICASTRODYNAMICS_HEADERS
   "${SRCROOT}${BASICASTRODYNAMICSDIR}/bodyShapeModel.h"
   "${SRCROOT}${BASICASTRODYNAMICSDIR}/oblateSpheroidBodyShapeModel.h"
   "${SRCROOT}${BASICASTRODYNAMICSDIR}/sphericalBodyShapeModel.h"
+  "${SRCROOT}${BASICASTRODYNAMICSDIR}/massRateModel.h"
   "${SRCROOT}${BASICASTRODYNAMICSDIR}/unifiedStateModelElementConversions.h"
 )
 

Tudat/Astrodynamics/BasicAstrodynamics/accelerationModel.h

@@ -46,7 +46,7 @@
 #define TUDAT_ACCELERATION_MODEL_H
 
 #include <map>
-#include <vector>
+#include <unordered_map>
 
 #include <boost/shared_ptr.hpp>
 
@@ -103,13 +103,19 @@ class AccelerationModel
      */
     virtual void updateMembers( const double currentTime = TUDAT_NAN ) = 0;
 
+    //! Function to reset the current time
+    /*!
+     * Function to reset the current time of the acceleration model.
+     * \param currentTime Current time (default NaN).
+     */
     virtual void resetTime( const double currentTime = TUDAT_NAN )
     {
         currentTime_ = currentTime;
     }
 
 protected:
 
+    //! Previous time to which acceleration model was updated.
     double currentTime_;
 
 protected:
@@ -137,29 +143,31 @@ typedef boost::shared_ptr< AccelerationModel2d > AccelerationModel2dPointer;
  * \tparam AccelerationDataType Data type used to represent accelerations
  *          (default=Eigen::Vector3d).
  * \param accelerationModel Acceleration model that is to be evaluated.
+ * \param currentTime Time at which acceleration model is to be updated.
  * \return Acceleration that is obtained following the member update.
  */
 template < typename AccelerationDataType >
 AccelerationDataType updateAndGetAcceleration(
-        boost::shared_ptr< AccelerationModel< AccelerationDataType > > accelerationModel )
+        const boost::shared_ptr< AccelerationModel< AccelerationDataType > > accelerationModel,
+        const double currentTime = TUDAT_NAN )
 {
     // Update members.
-    accelerationModel->updateMembers( );
+    accelerationModel->updateMembers( currentTime );
 
     // Evaluate and return acceleration.
     return accelerationModel->getAcceleration( );
 }
 
 //! Typedef defining a list of accelerations acting on a single body, key is the name of each
 //! body exerting a acceletation, value is a list of accelerations exerted by that body.
-typedef std::map< std::string, std::vector<
+typedef std::unordered_map< std::string, std::vector<
 boost::shared_ptr< basic_astrodynamics::AccelerationModel< Eigen::Vector3d > > > >
 SingleBodyAccelerationMap;
 
 //! Typedef defining a list of accelerations acting on a set of bodies, key is the name of each
 //! body undergoing a acceletation, value is SingleBodyAccelerationMap, defining all accelerations
 //! acting on it.
-typedef std::map< std::string, SingleBodyAccelerationMap > AccelerationMap;
+typedef std::unordered_map< std::string, SingleBodyAccelerationMap > AccelerationMap;
 
 } // namespace basic_astrodynamics
 } // namespace tudat

Tudat/Astrodynamics/BasicAstrodynamics/accelerationModelTypes.cpp

@@ -89,6 +89,27 @@ AvailableAcceleration getAccelerationModelType(
 
 }
 
+//! Function to identify the type of a mass rate model.
+AvailableMassRateModels getMassRateModelType(
+        const boost::shared_ptr< MassRateModel > massRateModel )
+{
+    // Nominal type is undefined
+    AvailableMassRateModels massRateType = undefined_mass_rate_model;
+
+    // Check for each mass rate mdoel type implemented as AvailableMassRateModels.
+    if( boost::dynamic_pointer_cast< basic_astrodynamics::CustomMassRateModel >(
+                massRateModel ) != NULL )
+    {
+        massRateType = custom;
+    }
+    else
+    {
+        throw std::runtime_error(
+                    "Error, mass rate model not identified when getting mass rate model type." );
+    }
+    return massRateType;
+}
+
 
 } // namespace basic_astrodynamics
 

Tudat/Astrodynamics/BasicAstrodynamics/accelerationModelTypes.h

@@ -40,6 +40,7 @@
 #include "Tudat/Astrodynamics/Gravitation/sphericalHarmonicsGravityModel.h"
 #include "Tudat/Astrodynamics/Gravitation/thirdBodyPerturbation.h"
 #include "Tudat/Astrodynamics/Aerodynamics/aerodynamicAcceleration.h"
+#include "Tudat/Astrodynamics/BasicAstrodynamics/massRateModel.h"
 
 
 namespace tudat
@@ -65,6 +66,17 @@ enum AvailableAcceleration
     third_body_spherical_harmonic_gravity
 };
 
+//! List of model types for body mass rates.
+/*!
+*  List of model types for body mass rates available in simulations. Mass rate models not defined by this
+*  given enum cannot be used for automatic mass rate model setup.
+*/
+enum AvailableMassRateModels
+{
+    undefined_mass_rate_model,
+    custom
+};
+
 //! Function to identify the derived class type of an acceleration model.
 /*!
  *  Function to identify the derived class type of an acceleration model. The type must be defined
@@ -76,6 +88,16 @@ AvailableAcceleration getAccelerationModelType(
         const boost::shared_ptr< basic_astrodynamics::AccelerationModel< Eigen::Vector3d > >
         accelerationModel );
 
+//! Function to identify the type of a mass rate model.
+/*!
+ *  Function to identify the type of a mass rate model. The type must be defined
+ *  in the AvailableMassRateModels enum to be recognized by this function.
+ *  \param massRateModel Mass rate model of which the type is to be identified.
+ *  \return Type of the massRateModel, as identified by AvailableMassRateModels enum.
+ */
+AvailableMassRateModels getMassRateModelType(
+        const boost::shared_ptr< MassRateModel > massRateModel );
+
 
 } // namespace basic_astrodynamics
 

Tudat/Astrodynamics/BasicAstrodynamics/massRateModel.h

@@ -0,0 +1,136 @@
+/*    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.
+ */
+
+#ifndef TUDAT_MASSRATEMODEL_H
+#define TUDAT_MASSRATEMODEL_H
+
+#include <map>
+#include <vector>
+#include <iostream>
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <Eigen/Core>
+
+#include "Tudat/Mathematics/BasicMathematics/mathematicalConstants.h"
+
+namespace tudat
+{
+namespace basic_astrodynamics
+{
+
+//! Base class for determining the rate of change of a body's mass, to be used in numerical integration.
+/*!
+ *  Base class for determining the rate of change of a body's mass, to be used in numerical integration. Specific types
+ *  of mass rate models are to be implemented in derived classes
+ */
+class MassRateModel
+{
+public:
+
+    //! Constructor
+    MassRateModel( ):
+        currentTime_( TUDAT_NAN ), currentMassRate_( TUDAT_NAN ){ }
+
+    //! Destructor
+    virtual ~MassRateModel( ) { }
+
+    //! Function to retrieve current mass rate
+    /*!
+     * Function to retrieve current mass rate, as set by last call to updateMembers (implemented in derived class)
+     * \return Current mass rate
+     */
+    virtual double getMassRate( )
+    {
+        return currentMassRate_;
+    }
+
+    //! Update member variables used by the mass rate model, and internally compute mass rate.
+    /*!
+     * Updates member variables used by the mass rate model, and internally compute mass rate. In the case of mass rate
+     * models containing varying parameters, function-pointers returning such a parameter (for instance
+     * the Cartesian state of a body) will be set as a member variable.
+     * This function evaluates such function-pointers and updates member variables to the 'current'
+     * values of these parameters. Only these current values, not the function-pointers are then
+     * used for the actual computation function.
+     * \param currentTime Time at which acceleration model is to be updated.
+     */
+    virtual void updateMembers( const double currentTime = TUDAT_NAN ) = 0;
+
+    //! Function to reset the current time
+    /*!
+     * Function to reset the current time of the acceleration model.
+     * \param currentTime Current time (default NaN).
+     */
+    virtual void resetTime( const double currentTime = TUDAT_NAN )
+    {
+        currentTime_ = currentTime;
+    }
+
+protected:
+
+    //! Previous time to which mass rate model was updated.
+    double currentTime_;
+
+    //! Current mass rate, as set by last call to updateMembers (implemented in derived class)
+    double currentMassRate_;
+
+private:
+};
+
+//! Derived class for determining the rate of change of a body's mass, user-defined by a function pointer.
+/*!
+ *  Derived class for determining the rate of change of a body's mass, user-defined by a function pointer.
+ *  This class can be used for any kind of mass rate model for which the user can define the dependency as a function
+ *  of time.
+ */
+class CustomMassRateModel: public MassRateModel
+{
+public:
+
+    //! Constructor.
+    /*!
+     * Constructor
+     * \param massRateFunction Function returning mass rate as a function of time.
+     */
+    CustomMassRateModel(
+            const boost::function< double( const double ) > massRateFunction ):
+    massRateFunction_( massRateFunction ){ }
+
+    //! Destructor.
+    ~CustomMassRateModel( ){ }
+
+    //! Update member variables used by the mass rate model and compute the mass rate
+    /*!
+     * Update member variables used by the mass rate model and compute the mass rate
+     * \param currentTime Time at which acceleration model is to be updated.
+     */
+    void updateMembers( const double currentTime = TUDAT_NAN )
+    {
+        // Check if update is needed.
+        if( !( currentTime_ == currentTime ) )
+        {
+            currentMassRate_ = massRateFunction_( currentTime );
+        }
+    }
+
+private:
+
+    //! Function returning mass rate as a function of time.
+    boost::function< double( const double ) > massRateFunction_;
+
+};
+
+
+} // namespace basic_astrodynamics
+
+} // namespace tudat
+
+#endif // TUDAT_MASSRATEMODEL_H

Tudat/Astrodynamics/ElectroMagnetism/cannonBallRadiationPressureAcceleration.cpp

@@ -57,27 +57,5 @@ Eigen::Vector3d computeCannonBallRadiationPressureAcceleration(
                 radiationPressure, vectorToSource, area, radiationPressureCoefficient ) / mass;
 }
 
-//! Get radiation pressure acceleration.
-Eigen::Vector3d CannonBallRadiationPressureAcceleration::getAcceleration( )
-{
-    return computeCannonBallRadiationPressureAcceleration(
-                currentRadiationPressure_, currentVectorToSource_, currentArea_,
-                currentRadiationPressureCoefficient_, currentMass_ );
-}
-
-//! Update member variables used by the radiation pressure acceleration model.
-void CannonBallRadiationPressureAcceleration::updateMembers( const double currentTime )
-{
-    if( !( this->currentTime_ == currentTime ) )
-    {
-        currentVectorToSource_ = ( sourcePositionFunction_( )
-                                   - acceleratedBodyPositionFunction_( ) ).normalized( );
-        currentRadiationPressure_ = radiationPressureFunction_( );
-        currentRadiationPressureCoefficient_ = radiationPressureCoefficientFunction_( );
-        currentArea_ = areaFunction_( );
-        currentMass_ = massFunction_( );
-    }
-}
-
 } // namespace electro_magnetism
 } // namespace tudat

Tudat/Astrodynamics/ElectroMagnetism/cannonBallRadiationPressureAcceleration.h

@@ -172,7 +172,12 @@ class CannonBallRadiationPressureAcceleration: public basic_astrodynamics::Accel
      * \return Radiation pressure acceleration.
      * \sa computeCannonBallRadiationPressureAcceleration().
      */
-    Eigen::Vector3d getAcceleration( );
+    Eigen::Vector3d getAcceleration( )
+    {
+        return computeCannonBallRadiationPressureAcceleration(
+                    currentRadiationPressure_, currentVectorToSource_, currentArea_,
+                    currentRadiationPressureCoefficient_, currentMass_ );
+    }
 
     //! Update member variables used by the radiation pressure acceleration model.
     /*!
@@ -181,7 +186,28 @@ class CannonBallRadiationPressureAcceleration: public basic_astrodynamics::Accel
      * not the function-pointers are then used by the getAcceleration( ) function.
      * \param currentTime Time at which acceleration model is to be updated.
      */
-    void updateMembers( const double currentTime = TUDAT_NAN );
+    void updateMembers( const double currentTime = TUDAT_NAN )
+    {
+        if( !( this->currentTime_ == currentTime ) )
+        {
+            currentVectorToSource_ = ( sourcePositionFunction_( )
+                                       - acceleratedBodyPositionFunction_( ) ).normalized( );
+            currentRadiationPressure_ = radiationPressureFunction_( );
+            currentRadiationPressureCoefficient_ = radiationPressureCoefficientFunction_( );
+            currentArea_ = areaFunction_( );
+            currentMass_ = massFunction_( );
+        }
+    }
+
+    //! Function to retrieve the function pointer returning mass of accelerated body.
+    /*!
+     * Function to retrieve the function pointer returning mass of accelerated body.
+     * \return Function pointer returning mass of accelerated body.
+     */
+    boost::function< double( ) > getMassFunction( )
+    {
+        return massFunction_;
+    }
 
 private:
 

Tudat/Astrodynamics/ElectroMagnetism/radiationPressureInterface.h

@@ -175,6 +175,16 @@ class RadiationPressureInterface{
         return radiationPressureCoefficient_;
     }
 
+    //! Function to reset the radiation pressure coefficient of the target body.
+    /*!
+     *  Function to reset the radiation pressure coefficient of the target body.
+     *  \param radiationPressureCoefficient The new radiation pressure coefficient of the target body.
+     */
+    void resetRadiationPressureCoefficient( const double radiationPressureCoefficient )
+    {
+        radiationPressureCoefficient_ = radiationPressureCoefficient;
+    }
+
     //! Function to return the function returning the current total power (in W) emitted by the
     //! source body.
     /*!

Tudat/Astrodynamics/Ephemerides/UnitTests/unitTestCompositeEphemeris.cpp

@@ -67,7 +67,7 @@ BOOST_AUTO_TEST_CASE( testCompositeEphemeris )
     double buffer = 5.0 * maximumTimeStep;
 
     // Create bodies needed in simulation
-    std::map< std::string, boost::shared_ptr< Body > > bodyMap = createBodies(
+    NamedBodyMap bodyMap = createBodies(
                 getDefaultBodySettings( bodyNames,initialEphemerisTime - buffer, finalEphemerisTime + buffer ) );
     setGlobalFrameBodyEphemerides( bodyMap, "SSB", "ECLIPJ2000" );