XWsfRoadTraffic.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company.
// ****************************************************************************
 
#ifndef XWSFROADTRAFFIC_HPP
#define XWSFROADTRAFFIC_HPP
 
#include "wsf_export.h"
 
#include <string>
#include <vector>
 
class UtInput;
#include "UtCallbackHolder.hpp"
#include "UtRandom.hpp"
class WsfMover;
class WsfPlatform;
class WsfRoadMover;
#include "WsfRoute.hpp"
class WsfRouteNetwork;
#include "WsfSimulationExtension.hpp"
#include "XWsfRouteNetwork.hpp"

class WSF_EXPORT XWsfRoadTraffic : public WsfSimulationExtension
{
public:
   struct Data;
 
   XWsfRoadTraffic(const Data& aData)
      : mData(aData)
   {
   }
 
   ~XWsfRoadTraffic() override;
 
   bool Initialize() override;
 
   void AdvanceTime(double aSimTime);
 
   using WsfSimulationExtension::GetScenario;
 
   struct SGroundTraffic
   {
      int          mIdentifier        = 0;       
      WsfStringId  mVehicleTypeId     = nullptr; 
      bool         mAlive             = false;   
      bool         mVehicleOffRoad    = false;   
      bool         mStationary        = false;   
      int          mNetwork           = -1;      
      double       mRouteDist         = 0.0;     
      double       mSpeed             = 0.0;     
      double       mTravelTime        = 0.0;     
      double       mStartTime         = 0.0;     
      double       mDeadTime          = 0.0;     
      double       mOffRoadTime       = 0.0;     
      WsfPlatform* mRoadPlatform      = nullptr;
      size_t       mRoadPlatformIndex = 0;
      bool         mConvoyVehicle     = false; 
   };

   struct WeightedRegionInput
   {
      double mLatitude    = 0.0;
      double mLongitude   = 0.0;
      double mInnerRadius = 0.0;
      double mOuterRadius = 0.0;
      double mInnerWeight = 0.0;
      double mOuterWeight = 0.0;
   };

   class VehicleInput
   {
   public:
      VehicleInput() = default;
      VehicleInput(WsfStringId aTypeId)
         : mTypeId(aTypeId)
      {
      }
 
      WsfStringId mTypeId     = nullptr; 
      int         mCount      = 0;       
      double      mFraction   = 0.0;     
      double      mMeanSpeed  = 0.0;     
      double      mSigmaSpeed = 0.0;     
   };

   struct ConvoyInput
   {
      double                    mStartLatitude      = 0.0;
      double                    mStartLongitude     = 0.0;
      double                    mEndLatitude        = 0.0;
      double                    mEndLongitude       = 0.0;
      double                    mSpacing            = 0.0;
      double                    mSpeed              = 0.0;
      double                    mPauseTime          = 0.0;
      bool                      mUseClosestWaypoint = false;
      std::vector<VehicleInput> mVehicleInput;
   };

   class WeightedRouteSegment
   {
   public:
      WeightedRouteSegment() = default;
      WeightedRouteSegment(WsfRoute* aRoutePtr, const WsfWaypoint& aNode1, const WsfWaypoint& aNode2)
         : mRoutePtr(aRoutePtr)
         , mNode1(aNode1)
         , mNode2(aNode2)
      {
      }
 
      WsfRoute*   mRoutePtr = nullptr;
      WsfWaypoint mNode1;
      WsfWaypoint mNode2;
      double      mNode1Weight      = 0.0;
      double      mNode2Weight      = 0.0;
      double      mSegmentWeight    = 0.0;
      double      mCumulativeWeight = 0.0;

      bool operator==(double aWeight) const
      {
         return ((aWeight >= mCumulativeWeight) && (aWeight < (mCumulativeWeight + mSegmentWeight)));
      }
 
      bool operator<(const WeightedRouteSegment& aSegment) const { return (mSegmentWeight < aSegment.mSegmentWeight); }
   };

   class RoadTrafficNetworkInput : public XWsfRouteNetwork::NetworkInput
   {
   public:
      RoadTrafficNetworkInput() = default;
      RoadTrafficNetworkInput(WsfStringId aNetworkId)
         : NetworkInput(aNetworkId)
      {
      }
 
      NetworkInput* Clone() const noexcept override { return new RoadTrafficNetworkInput{*this}; }
 
      void VerifyData(UtInput& aInput) override
      {
         NetworkInput::VerifyData(aInput);
 
         double                              sum = 0.0;
         std::vector<VehicleInput>::iterator vehItr;
         for (vehItr = mVehicleInput.begin(); vehItr != mVehicleInput.end(); ++vehItr)
         {
            sum += vehItr->mFraction;
         }
         if (fabs(1.0 - sum) > 10E-3)
         {
            throw UtInput::BadValue(aInput, "XWsfRoadTraffic the sum of all the vehicle 'fraction' values must be 1.0");
         }
      }
 
      double                           mMinDistOffRoad  = 0.0; 
      double                           mMaxDistOffRoad  = 0.0; 
      double                           mPauseTime       = 0.0; 
      double                           mMaxSpeed        = 0.0; 
      double                           mMeanTravelTime  = 0.0; 
      double                           mSigmaTravelTime = 0.0; 
      double                           mTotalDist       = 0.0; 
      std::vector<VehicleInput>        mVehicleInput;        
      std::vector<WeightedRegionInput> mWeightedRegionInput; 

      std::vector<WeightedRouteSegment> mWeightedRouteSegments;
 
      std::vector<ConvoyInput> mConvoyInput; 
 
   protected:
      RoadTrafficNetworkInput(const RoadTrafficNetworkInput& aSrc) = default;
   };
 
   enum EndOfPath
   {
      cRESPAWN,
      cREVERSE_DIRECTION
   };

   struct Data : public XWsfRouteNetwork
   {
      bool      mProcessedInput  = false;
      bool      mDebug           = false;
      bool      mVerbose         = false;
      EndOfPath mEndOfPathOption = cRESPAWN;
      // Vector of vehicles.
      std::vector<SGroundTraffic> mTraffic;
      double                      mNextUpdateTime = 0.0; // Simulation time when the next update
                                                         // (platform add, delete, pause, etc) is required.
      int mNextVehicleIdentifier = 0;
      int mNumVehiclesActive     = 0;
      int mMaxVehiclesActive     = 0;

      Networks& GetNetworks() { return mNetworks; }
      const Networks& GetNetworks() const { return mNetworks; }
 
      using XWsfRouteNetwork::ProcessCommand;
   };
 
protected:
   XWsfRoadTraffic(const XWsfRoadTraffic& aSrc) = delete;
   XWsfRoadTraffic& operator=(const XWsfRoadTraffic& aRhs) = delete;
 
private:
   void BuildWeightedRouteSegmentList(WsfRouteNetwork& aRouteNetwork, RoadTrafficNetworkInput& aNetwork);
 
   double CalculateNodeWeight(const WeightedRegionInput& aWeightedRegion, const WsfWaypoint& aNode);
 
   void AddPlatformToSimulation(double aSimTime, int aVehicleNumber);
 
   int AllocateVehicle(WsfStringId aVehicleTypeId);
 
   bool GetRandomWaypoint(const RoadTrafficNetworkInput& aNetwork,
                          WsfWaypoint&                   aWaypoint,
                          WsfWaypoint&                   aRouteSegEndWpt1,
                          WsfWaypoint&                   aRouteSegEndWpt2);
 
   bool CreateRandomPath(const RoadTrafficNetworkInput& aNetwork, WsfRoute& aPath);
 
   double CreateRandomPathForVehicle(const RoadTrafficNetworkInput& aNetwork, int aVehicleNumber);
 
   void GoOffRoad(const RoadTrafficNetworkInput& aNetwork, int aVehicleNumber);
 
   void ClearVehicleList();
 
   bool CreateVehicle(const RoadTrafficNetworkInput& aNetworkInput, double aCreateTime, int& aVehicleNumber);
 
   bool CreateConvoyVehicle(WsfStringId aVehicleType, int& aVehicleNumber);
 
   void DeletePlatformFromSimulation(double aSimTime, int aVehicleNumber);
 
   void ReverseVehicleRoute(int aVehicleNumber, double aSimTime);
 
   bool ValidateVehicleTypes(RoadTrafficNetworkInput& aNetwork);
 
   WsfMover* GetMover(WsfPlatform* aMoverPtr);

   Data             mData;
   UtCallbackHolder mCallbacks;
};
 
#endif