WsfDirectedEnergyWeapon.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 WSFDIRECTEDENERGYWEAPON_HPP
#define WSFDIRECTEDENERGYWEAPON_HPP
 
#include "wsf_mil_export.h"
 
#include "WsfImplicitWeapon.hpp"
#include "WsfMilComponentRoles.hpp"

class WSF_MIL_EXPORT WsfDirectedEnergyWeapon : public WsfImplicitWeapon
{
public:
   WsfDirectedEnergyWeapon(const WsfScenario& aScenario);
   WsfDirectedEnergyWeapon& operator=(const WsfDirectedEnergyWeapon&) = delete;
   ~WsfDirectedEnergyWeapon() override;
 
   WsfWeapon* Clone() const override { return new WsfDirectedEnergyWeapon(*this); }
 
   class Beam;

   Beam* GetBeam() const { return mBeamPtr; }
 
   void SetBeam(Beam* aBeamPtr);
 
   FireResult Fire(double aSimTime, const FireTarget& aTarget, const FireOptions& aSettings) override;
 
   void CeaseFire(double aSimTime) override;

   virtual bool IsFiring() const;
 
   void EngagementComplete(double aSimTime, WsfWeaponEngagement* aEngagementPtr) override;


   WsfComponent* CloneComponent() const override { return Clone(); }
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;

   class WSF_MIL_EXPORT Beam : public WsfObject
   {
   public:
      Beam();
      Beam(const Beam& aSrc);
      Beam& operator=(const Beam&) = delete;
      ~Beam() override             = default;
 
      bool ProcessInput(UtInput& aInput) override;
 
      void Initialize();

      virtual void Propagate(double /*aSimTime*/){}; // Should define in child classes

      Beam* Clone() const override { return new Beam(*this); }

      double GetPeakFluence() const { return mPeakFluence; }

      void SetPeakFluence(double aPeakFluence) { mPeakFluence = aPeakFluence; }

      double GetEdgeFluence() const { return mEdgeFluence; }

      void SetEdgeFluence(double aEdgeFluence) { mEdgeFluence = aEdgeFluence; }

      double GetEdgeRadius() const { return mEdgeRadius; }

      void SetEdgeRadius(double aEdgeRadius) { mEdgeRadius = aEdgeRadius; }

      double GetSemiMinorAxis() const { return mSpotSize; }

      void SetSpotRadius(double aRadius) { mSpotSize = aRadius; }

      double GetSpotRadius() const { return mSpotSize; }
 
      double GetSemiMajorAxis() const;

      virtual double GetIncidenceAngle() const { return mIncidenceAngle; }
 
      virtual void SetIncidenceAngle(double aIncidenceAngle);

      virtual double GetWavelength() const { return mWavelength; }

      unsigned GetWavelength_nm() const { return mWavelength_nm; }

      virtual void SetWavelength(double aWavelength);

      virtual double GetApertureDiameter() const { return mApertureDiameter; } // todo deconflict with diameter

      virtual void SetApertureDiameter(double aApertureDiameter) { mApertureDiameter = aApertureDiameter; }

      virtual double GetInitialPower() const { return mInitialPower; }

      virtual void SetInitialPower(double aInitialPower) { mInitialPower = aInitialPower; }

      double GetPeakIrradiance() const { return mPeakIrradiance; }

      void SetPeakIrradiance(double aPeakIrradiance) { mPeakIrradiance = aPeakIrradiance; }

      double GetAverageIrradiance() const { return mAverageIrradiance; }

      void SetAverageIrradiance(double aAverageIrradiance) { mAverageIrradiance = aAverageIrradiance; }

      double GetEdgeIrradiance() const { return mEdgeIrradiance; }

      void SetEdgeIrradiance(double aEdgeIrradiance) { mEdgeIrradiance = aEdgeIrradiance; }

      virtual double GetPulseRepetitionFrequency() const { return mPulseRepetitionFrequency; }

      virtual void SetPulseRepetitionFrequency(double aPRF) { mPulseRepetitionFrequency = aPRF; }

      virtual double GetPulseWidth() const { return mPulseWidth; }

      virtual void SetPulseWidth(double aPulseWidth) { mPulseWidth = aPulseWidth; }
 
      virtual double GetEnergyDensity() const;

      double GetEnergy() const { return mEnergyInSpot; }

      void SetEnergy(double aEnergy) { mEnergyInSpot = aEnergy; }

      double GetAveragePower() const { return mAveragePower; }

      void SetAveragePower(double aAveragePower) { mAveragePower = aAveragePower; }
 
      void GetOffsetLocationECS(double aLocationECS[3]) const;
 
      void SetOffsetLocationECS(const double aLocationECS[3]);
 
   private:
      double       mAveragePower;
      double       mInitialPower;
      double       mEnergyInSpot;
      double       mPeakFluence;
      double       mEdgeFluence;
      double       mPeakIrradiance;
      double       mAverageIrradiance;
      double       mEdgeIrradiance;
      double       mPulseRepetitionFrequency;
      double       mPulseWidth;
      double       mEdgeRadius;
      double       mSpotSize;
      double       mIncidenceAngle;
      double       mCosIncidenceAngle;
      double       mWavelength;
      unsigned int mWavelength_nm;
      double       mApertureDiameter;
      double       mOffsetLocationECS[3];
   };
 
protected:
   WsfDirectedEnergyWeapon(const WsfDirectedEnergyWeapon& aSrc);
 
   virtual bool BeginEngagement(double aSimTime, EngagementData* aEngagementDataPtr);
 
private:
   Beam* mBeamPtr;
   bool  mIsFiring;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfDirectedEnergyWeapon, cWSF_COMPONENT_DIRECTED_ENERGY_WEAPON)
 
#endif