Simulation.h

Go to the documentation of this file.

/*
    Copyright (C) 2010-2012
    Johannes Feuser <feuser@uni-bremen.de>
    This file is part of the openETCS library.

    The openETCS library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    any later version.

    The openETCS library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with the openETCS library.  If not, see <http://www.gnu.org/licenses/>.
*/

/*!
 *  \author Johannes Feuser <feuser@uni-bremen.de>
 *  \brief classes for simulative usage
 */

#ifndef __OETCS_DF_PS_SIM_SIMULATION_H__
#define __OETCS_DF_PS_SIM_SIMULATION_H__


#include <iostream>

#include "../../Configuration.h"
#include "../AdaptorStubsMOC.h"
#include <mutex>
#include <thread>
#include <QBitArray>


namespace oETCS { namespace DF { namespace PS { namespace SIM { class CEmergencyBrake; } } } }


namespace oETCS {

namespace DF {

namespace PS {

namespace SIM {


/*!
 *  \brief simulative odometer class
 */
class COdometer : public ::oETCS::DF::PS::COdometer 
{
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] dInitialPosition optional initial position (default 0.0) in [m]
     *  \param[in] dInitialVelocity optional initial velocity (default 0.0) in [km/h]
     */
    explicit COdometer(const double & dInitialPosition = 0.0, const double & dInitialVelocity = 0.0) throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~COdometer() throw();
    
    

    /*!
     *  \brief gets the current absolute position
     *
     *  Calculates the position by integrating the current speed over the
     *  time difference from the last calculation time point m_LastCalculation.
     *
     *  \return current absolute position in [m]
     */
    virtual double GetAbsolutePosition();
    
    

    /*!
     *  \brief gets the current velocity
     *
     *  \return current velocity in [km/h]
     */
    virtual double GetVelocity();
    
    

    /*!
     *  \brief sets the current velocity
     *
     *  Also calculates the position by integrating the old speed over the
     *  time difference from the last calculation time point m_LastCalculation.
     *  
     *  \param[in] dVelocity new velocity in [km/s]
     */
    void SetVelocity(const double& dVelocity) throw();
    
    

    /*!
     *  \brief resets the position
     *
     *  Also resets the last calculation time to now.
     *
     *  \param[in] dPosition optinal position in [m] 
     */
    void ResetPosition(const double& dPosition = 0) throw();
    
    


  private:
    /*!
     *  \brief value of the current velocity in [km/h]
     */
    double m_dVelocity;
    
    

    /*!
     *  \brief current position in [m]
     */
    double m_dPosition;
    
    

    /*!
     *  \brief last calculation time point for the position
     */
    oETCS::DF::TIME_POINT_T m_LastCalculation;
    
    

    /*!
     *  \brief muteable exclusion for internal states
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class COdometer : public ::oETCS::DF::PS::COdometer



/*!
 *  \brief simulative brake system class for a service brake
 */
class CServiceBrake : public ::oETCS::DF::PS::CServiceBrake 
{
  public:
    /*!
     *  \brief general constructor
     *
     * 
     *  \param[in] pOdometer pointer to the odometer device to be manipulated
     *  \param[in] pEmergencyBrake optional pointer to a emergency brake instance
     *  \param[in] dIntensity optional initial brake intensity in [%]
     *  \param[in] dMass optional initial train mass [kg]
     *  \param[in[ dAdsesion:        optional initial adhesion factor (0...1)
     */
    explicit CServiceBrake(::oETCS::DF::PS::SIM::COdometer * const pOdometer, ::oETCS::DF::PS::SIM::CEmergencyBrake * const pEmergencyBrake = nullptr, const double & dIntensity = 0.0, const double & dMass = 10000, const double & dAdhesion = 1.0) throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CServiceBrake() throw();
    
    

    /*!
     *  \brief gets the activation intensity
     *
     *  \return activation intensity of the service brake in [%]
     */
    virtual double GetIntensity();
    
    

    /*!
     *  \brief sets the activation intensity
     *
     *  \param[in] bIntensity the new activation intensity in [%]
     */
    virtual void SetIntensity(const double& dIntensity);
    
    

    /*!
     *  \brief sets the virtual mass
     *
     *  \param[in] dMass new mass in [kg]
     */
    void SetMass(const double& dMass) throw();
    
    

    /*!
     *  \brief sets the virtual adhesion
     *
     *  \param[in] dAdhesion new virtual adhesion factor (0...1)
     */
    void SetAdhesion(const double& dAdhesion) throw();
    
    


  private:
    /*!
     *  \brief thread for setting the velocity depending on the brake intensity
     */
    void OdometerThread() throw();
    
    

    /*!
     *  \brief flag for the execution of the m_pPhysicalCalculation thread
     */
    bool m_bCalculate;
    
    

    /*!
     *  \brief intesity of the applied service brake in [%]
     */
    double m_dIntensity;
    
    

    /*!
     *  \brief virtual mass in [kg] of the train used for braking curve calculation
     */
    double m_dMass;
    
    

    /*!
     *  \brief adhesion factor {0...1) of the train used for braking curve calculation
     */
    double m_dAdhesion;
    
    

    /*!
     *  \brief pointer to the odometer in which the velocity is modified
     */
    ::oETCS::DF::PS::SIM::COdometer* const m_pOdometer;
    
    

    /*!
     *  \brief optional pointer to a emegency brake taken into account for brake curve calculation
     */
    ::oETCS::DF::PS::SIM::CEmergencyBrake* const m_pEmergencyBrake;
    
    

    /*!
     *  \brief pointer to the thread object for the physical model calculation manipulating m_pOdometer
     */
    ::std::thread* m_pPhysicalCalculation;
    
    

    /*!
     *  \brief muteable exclusion for internal states
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class CServiceBrake : public ::oETCS::DF::PS::CServiceBrake



/*!
 *  \brief simulative brake system class for a service brake
 */
class CEmergencyBrake : public ::oETCS::DF::PS::CEmergencyBrake 
{
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] bActive optional initial emergency activation flag
     */
    explicit CEmergencyBrake(const bool & bActive = false) throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CEmergencyBrake() throw();
    
    

    /*!
     *  \brief gets the activation state
     *
     *  \return activation flag of the emergency brake
     */
    virtual bool GetActivation();
    
    

    /*!
     *  \brief sets the activation state
     *
     *  \param[in] bActivated the new activation flag
     */
    virtual void SetActivation(bool bActivated);
    
    


  private:
    /*!
     *  \brief activation flag of the emergency brake
     */
    bool m_bActive;
    
    

    /*!
     *  \brief muteable exclusion for internal states
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class CEmergencyBrake : public ::oETCS::DF::PS::CEmergencyBrake



/*!
 *  \brief simulative class for a balise out system
 */
class CBaliseDeviceOut : virtual public ::oETCS::DF::PS::CBaliseDeviceOut 
{
  public:
    /*!
     *  \brief default/general constructor
     */
    explicit CBaliseDeviceOut() throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CBaliseDeviceOut() throw();
    
    

    /*!
     *  \brief sends a telegram 
     *
     *  \param[in] Bits telegram to send as bits
     */
    virtual void SendTelegram(const ::QBitArray& Bits);
    
    


  private:
    /*!
     *  \brief muteable exclusion for internal states
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class CBaliseDeviceOut : virtual public ::oETCS::DF::PS::CBaliseDeviceOut



/*!
 *  \brief simulative class for a balise in system
 */
class CBaliseDeviceIn : virtual public ::oETCS::DF::PS::CBaliseDeviceIn 
{
  public:
    /*!
     *  \brief default/general constructor
     */
    explicit CBaliseDeviceIn() throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CBaliseDeviceIn() throw();
    
    

    /*!
     *  \brief sets a telegram as received
     *
     *  Emits the NewTelegram(QBitArray) signal.
     *  
     *  \param[in] Bits raw bits of the telegram
     */
    void SetNewInputTelegram(const ::QBitArray& Bits) throw();
    
    


  private:
    /*!
     *  \brief muteable exclusion for internal states
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class CBaliseDeviceIn : virtual public ::oETCS::DF::PS::CBaliseDeviceIn





} // namespace oETCS::DF::PS::SIM

} // namespace oETCS::DF::PS

} // namespace oETCS::DF

} // namespace oETCS

#endif // __ OETCS_DF_PS_SIM_SIMULATION_H__