WsfNASA_BreakupModel.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2019 Infoscitex, a DCS 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.
// ****************************************************************************
 
#ifndef WSFNASABREAKUPMODEL_HPP
#define WSFNASABREAKUPMODEL_HPP
 
#include "WsfSatelliteBreakupModel.hpp"
 
class WsfNASA_BreakupModel : public WsfSatelliteBreakupModel
{
public:
   explicit WsfNASA_BreakupModel(WsfSimulation& aSimulation);
   ~WsfNASA_BreakupModel() override = default;
 
   size_t   GetFragmentCount() const override;
   Fragment GetFragment(size_t aIndex) const override;

   const std::string& GetExplosionProgenitor() const { return mProgenitorOne.mName; }

   double GetExplosionMass() const { return mProgenitorOne.mMass; }

   const std::string& GetCollisionProgenitorOne() const { return mProgenitorOne.mName; }

   double GetCollisionProgenitorOneMass() const { return mProgenitorOne.mMass; }

   const std::string& GetCollisionProgenitorTwo() const { return mProgenitorTwo.mName; }

   double GetCollisionProgenitorTwoMass() const { return mProgenitorTwo.mMass; }

   double GetCollisionMass() const { return mCollisionMass; }

   const std::string& GetDebrisName() const { return mDebrisName; }

   double GetExplosionS_Factor() const { return mExplosionS_Factor; }

   double GetLargeFragmentMassFraction() const { return mLargeFragmentFraction; }

   bool IsModeledAsSpacecraft() const { return mModelAsSpacecraft; }

   double GetMinFragmentSize() const { return mMinFragmentSize; }

   void SetDebrisName(const std::string& aDebrisName) { mDebrisName = aDebrisName; }

   void SetExplosionS_Factor(double aS_Factor) { mExplosionS_Factor = aS_Factor; }

   void SetLargeFragmentMassFraction(double aLargeFragmentFraction)
   {
      mLargeFragmentFraction = std::min(1.0, std::max(0.0, aLargeFragmentFraction));
   }

   void SetModeledAsSpacecraft(bool aModelAsSpacecraft) { mModelAsSpacecraft = aModelAsSpacecraft; }

   void SetMinFragmentSize(double aMinSize) { mMinFragmentSize = aMinSize; }

   static std::vector<double> PackInputParameters(double aMass, double aSize);
 
private:
   struct Progenitor
   {
      std::string mName{};       
      UtVec3d     mLocation{};   
      UtVec3d     mVelocity{};   
      double      mMass{-1.0};   
      double      mLength{-1.0}; 
   };
 
   // Explosive breakup modeling
   bool     ModelExplosion(WsfPlatform& aPlatform, const std::vector<double>& aParams) override;
   bool     FinalizeExplosionModel(WsfPlatform& aPlatform, const std::vector<double>& aParams);
   Fragment GenerateExplosiveFragment(double aLc, int aId);
   Fragment GenerateExplosiveLargeFragment(double         aMinLc,
                                           double         aMassRemaining,
                                           bool           aIsLast,
                                           int            aId,
                                           const UtVec3d& aLocation,
                                           const UtVec3d& aVelocity);
 
   // Collisional breakup modeling
   bool     ModelCollision(WsfPlatform&               aTargetPlatform,
                           const std::vector<double>& aTargetParams,
                           WsfPlatform&               aImpactorPlatform,
                           const std::vector<double>& aImpactorParams) override;
   bool     FinalizeCollisionModel(WsfPlatform&               aTargetPlatform,
                                   const std::vector<double>& aTargetParams,
                                   WsfPlatform&               aImpactorPlatform,
                                   const std::vector<double>& aImpactorParams);
   bool     ModelCatastrophicCollision();
   bool     ModelNonCatastrophicCollision();
   double   ModelCollisionDebris(double aTotalMass, const Progenitor& aProgenitor, bool aGenerateLargeFragments = true);
   Fragment GenerateCollisionalFragment(double aLc, int aId, const UtVec3d& aLocation, const UtVec3d& aVelocity);
   Fragment GenerateCollisionalLargeFragment(double         aMinLc,
                                             double         aMassRemaining,
                                             bool           aIsLast,
                                             int            aId,
                                             const UtVec3d& aLocation,
                                             const UtVec3d& aVelocity);
   Fragment GenerateCrateredFragment(const Progenitor& aProgenitor);
   std::pair<Progenitor, Progenitor> SolveCollisionProblem(const Progenitor& aSmall, const Progenitor& aLarge) const;
 
   // Utilities for dealing with velocities
   UtVec3d     GenerateRandomVelocity(double aMagnitude);
   static void EnsureMomentumConservation(std::vector<Fragment>& aFragments);
   static void EnsureMomentumConservation(std::vector<Fragment>::iterator aStart, std::vector<Fragment>::iterator aEnd);
 
   // NASA model routines
   double        ExplosionN(double aLc) const;
   double        InverseExplosionN(double aCn) const;
   bool          IsCatastrophicCollision() const;
   double        CatastrophicCollisionMass() const;
   double        NonCatastrophicCollisionMass() const;
   void          ComputeCollisionMass();
   static double CollisionN(double aLc, double aCollisionMass);
   static double InverseCollisionN(double aCn, double aCollisionMass);
   static double LimitedLerp(double aValue, double aValueMin, double aValueMax, double aRangeMin, double aRangeMax);
   static double BlendFunctionWeight(double aLc);
   double        AoverM_SmallSize(double aLambdaC);
   double        AoverM_RocketBodyTermOne(double aLambdaC);
   double        AoverM_RocketBodyTermTwo(double aLambdaC);
   double        AoverM_RocketBody(double aLc);
   double        AoverM_SpacecraftTermOne(double aLambdaC);
   double        AoverM_SpacecraftTermTwo(double aLambdaC);
   double        AoverM_Spacecraft(double aLc);
   static double AfromLc(double aLc);
   double        DeltaV_Explosion(double aAoverM);
   double        DeltaV_Collision(double aAoverM);

   Progenitor mProgenitorOne{};

   Progenitor mProgenitorTwo{};
 
   std::string           mDebrisName{};           
   std::vector<Fragment> mFragments{};            
   double                mMinFragmentSize{0.1};   
   double                mExplosionS_Factor{1.0}; 
   double                mLargeFragmentFraction{0.5}; 
   double                mCollisionRelativeSpeed{0.0};    
   double                mCollisionMass{-1.0};            
   bool                  mIsCatastrophicCollision{false}; 
   bool                  mModelAsSpacecraft{true};        
};
 
#endif // WSFNASABREAKUPMODEL_HPP