WsfHighEnergyLaser.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.
// ****************************************************************************
 
#ifndef WSFHIGHENERGYLASER_HPP
#define WSFHIGHENERGYLASER_HPP
 
#include "wsf_mil_export.h"
 
#include <mutex>
 
class UtInput;
#include "WsfAtmosphericTurbulence.hpp"
#include "WsfDirectedEnergyWeapon.hpp"
#include "WsfException.hpp"
class WsfGeoPoint;
#include "WsfObject.hpp"
#include "WsfObjectTypeList.hpp"

class WSF_MIL_EXPORT WsfHighEnergyLaser : public WsfDirectedEnergyWeapon::Beam
{
public:
   WsfHighEnergyLaser(WsfScenario& aScenario);
   WsfHighEnergyLaser(const WsfHighEnergyLaser& aSrc);
   WsfHighEnergyLaser& operator=(const WsfHighEnergyLaser&) = delete;
   ~WsfHighEnergyLaser() override                           = default;
 
   WsfDirectedEnergyWeapon::Beam* Clone() const override = 0;
 
   bool ProcessInput(UtInput& aInput) override;
 
   virtual bool Initialize(WsfDirectedEnergyWeapon* aWeaponPtr);
 
   virtual void OutputConfiguration() const {};
 
   WsfDirectedEnergyWeapon* GetWeapon() const { return mWeaponPtr; }
 
   // Controlling methods for the laser.
   virtual void BeginLasing(double aSimTime, size_t aTargetIndex, const std::string& aTargetOffsetName = "");
 
   void UpdateLasing(double aSimTime); // same track as before
 
   virtual void EndLasing(double aSimTime);

   bool IsLasing() const { return mIsLasing; }

   double GetIncidenceAngle() const override { return mIncidenceAngle; }

   virtual bool TargetOccluded() const { return mTargetOccluded; }

   virtual bool TestLasing(double aDuration, size_t aTargetIndex, const std::string& aTargetOffset = "")
   {
      return false;
   }

   virtual bool TestLasing(double aDuration, const WsfGeoPoint& aSourceLocation, const WsfGeoPoint& aTargetLocation)
   {
      return false;
   }

   virtual double RequiredDurationEnergy(double aEnergy, const WsfGeoPoint& aSourceLocation, const WsfGeoPoint& aTargetLocation)
   {
      return 0.0;
   }

   virtual double RequiredDurationFluence(double             aEnergyDensity,
                                          const WsfGeoPoint& aSourceLocation,
                                          const WsfGeoPoint& aTargetLocation)
   {
      return 0.0;
   }

   virtual double RequiredDurationEnergy(double aEnergy, int aTargetIndex, const std::string& aTargetOffset = "")
   {
      return 0.0;
   }

   virtual double RequiredDurationFluence(double aEnergyDensity, size_t aTargetIndex, const std::string& aTargetOffset = "")
   {
      return 0.0;
   }

   virtual bool UpdateEngagementGeometry(double             aSimTime,
                                         size_t             aTargetIndex,
                                         const std::string& aTargetOffset = "",
                                         bool               aAddJitter    = true);

   double GetDamageRadius() const { return mDamageRadius; }

   double GetDefaultDamageRadius() const { return mDefaultDamageRadius; }

   virtual void SetDamageRadius(double aDamageRadius) { mDamageRadius = aDamageRadius; }
 
   virtual void SetAtmosphericStructure(const std::string& aAtmosphericStructure)
   {
      mTurbulenceModel.SetCN2Form(aAtmosphericStructure);
   }

   double GetJitter() const { return mJitterExpectedValue; }

   void SetJitter(double aJitter) { mJitterExpectedValue = aJitter; }

   size_t GetTargetIndex() const { return mTargetIndex; }

   double GetTargetRange() const { return mTargetRange; }

   void SetBeamQuality(double aBeamQuality) { mBeamQuality = aBeamQuality; }

   virtual double GetWindowStrehl() const { return 1.0; }

   virtual void SetWindowStrehl(double aWindowStrehl) {}

   virtual double GetAeroStrehl() const { return 1.0; }

   virtual void SetAeroStrehl(double aAeroStrehl) {}

   virtual double GetSystemStrehl() const { return 1.0; }

   virtual void SetSystemStrehl(double aSystemStrehl) {}

   virtual double GetSystemTransmission() const { return 1.0; }
 
   WsfSimulation* GetSimulation() const;
 
protected:
   void Propagate(double aSimTime) override = 0; // Pure virtual; define in child classes
 
   WsfDirectedEnergyWeapon* mWeaponPtr; 
   bool                     mSysInit;
 
   bool   mCalculateIncidence;
   double mIncidenceAngle;
 
   size_t      mTargetIndex;
   WsfStringId mTargetOffsetName;
 
   bool   mTargetOccluded;
   double mTargetRange;
 
   bool   mIsLasing;
   bool   mDebug;
   double mLastUpdateTime;
   double mDamageRadius;
   double mDefaultDamageRadius;
   double mJitterExpectedValue;
   double mBeamQuality;
 
   wsf::AtmosphericTurbulence mTurbulenceModel;
};
 
class WsfHighEnergyLaserTypes : public WsfObjectTypeList<WsfHighEnergyLaser>
{
public:

   static WSF_MIL_EXPORT WsfHighEnergyLaserTypes&       Get(WsfScenario& aScenario);
   static WSF_MIL_EXPORT const WsfHighEnergyLaserTypes& Get(const WsfScenario& aScenario);
 
   WsfHighEnergyLaserTypes(WsfScenario& aScenario);
   ~WsfHighEnergyLaserTypes() override = default;
   WsfHighEnergyLaser* Create(const std::string& aName) const;
};
 
#endif