WsfEM_Interaction.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 WSFEM_INTERACTION_HPP
#define WSFEM_INTERACTION_HPP
 
#include "wsf_export.h"
 
#include <iosfwd>
#include <ostream>
 
#include "UtLog.hpp"
#include "UtScriptAccessible.hpp"
#include "WsfComponentList.hpp"
class WsfEM_Antenna;
class WsfEM_Interaction;
class WsfEM_Rcvr;
class WsfEM_Xmtr;
class WsfEM_XmtrRcvr;
class WsfEnvironment;
class WsfPlatform;
#include "WsfStringId.hpp"
 

class WSF_EXPORT WsfEM_InteractionComponent : public WsfComponentT<WsfEM_Interaction>
{
   friend class WsfEM_Interaction;
 
public:
   virtual void Print(ut::log::MessageStream& aMsgStream, WsfEM_Interaction& aEM_Interaction) {}
   virtual void PrintStatus(ut::log::MessageStream& aMsgStream, WsfEM_Interaction& aEM_Interaction) {}
   virtual void Reset() {}
 
   // These are called from WsfEventOutput::PrintEM_Interaction.
   // It is a bit of a hack in that only addresses event_output in a very specific way.
   virtual bool PrintEventOutput(std::ostream& aStream) { return false; }
   virtual void PrintEventOutput_Powers(std::ostream& aStream) {}
 
   virtual bool PrintCSV_EventOutput(std::ostream& aStream) { return false; }
   virtual bool PrintCSV_EventOutput_Powers(std::ostream& aStream) { return false; }
};
 
class WSF_EXPORT WsfEM_Interaction : public UtScriptAccessible
{
public:
   using Component     = WsfEM_InteractionComponent;
   using ComponentList = WsfComponentListT<WsfEM_InteractionComponent>;

   enum
   {
      cRCVR_RANGE_LIMITS    = 0x00000001, 
      cRCVR_ALTITUDE_LIMITS = 0x00000002, 
      cRCVR_ANGLE_LIMITS    = 0x00000004, 
      cRCVR_HORIZON_MASKING = 0x00000008, 
      cRCVR_TERRAIN_MASKING = 0x00000010, 
      cXMTR_RANGE_LIMITS    = 0x00000020, 
      cXMTR_ALTITUDE_LIMITS = 0x00000040, 
      cXMTR_ANGLE_LIMITS    = 0x00000080, 
      cXMTR_HORIZON_MASKING = 0x00000100, 
      cXMTR_TERRAIN_MASKING = 0x00000200, 
      cSIGNAL_LEVEL         = 0x00000400, 
      cSTATUS_MASK          = 0x0000FFFF  
   };
 
   enum Geometry
   {
      cXMTR_TO_TARGET,
      cTARGET_TO_RCVR,
      cXMTR_TO_RCVR
   };

   struct LocationData
   {
      double mLat{0.0};                 
      double mLon{0.0};                 
      double mAlt{0.0};                 
      double mLocWCS[3]{0.0, 0.0, 0.0}; 
      bool   mIsValid{false};           
   };

   struct RelativeData
   {
      double mRange{-1.0}; 
 
      double mTrueUnitVecWCS[3]{0.0, 0.0, 0.0}; 
      double mTrueAz{0.0};                      
      double mTrueEl{0.0};                      
 
      double mUnitVecWCS[3]{0.0, 0.0, 0.0}; 
      double mAz{0.0};                      
      double mEl{0.0};                      
   };

   struct BeamData
   {
      double mAz{0.0};

      double mEl{0.0};

      double mGain{-1.0};

      double mEBS_Az{0.0};

      double mEBS_El{0.0};

      double mWCS_ToBeamTransform[3][3]{{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
   };
 
   WsfEM_Interaction()           = default;
   ~WsfEM_Interaction() override = default;
 
   virtual unsigned int BeginOneWayInteraction(WsfEM_Rcvr* aRcvrPtr, WsfPlatform* aTgtPtr);
 
   virtual unsigned int BeginOneWayInteraction(WsfEM_Xmtr* aXmtrPtr,
                                               WsfEM_Rcvr* aRcvrPtr,
                                               bool        aCheckXmtrLimits,
                                               bool        aCheckRcvrLimits,
                                               bool        aCheckMaskingFactor = true);
 
   virtual unsigned int BeginTwoWayInteraction(WsfEM_Xmtr* aXmtrPtr, WsfPlatform* aTgtPtr, WsfEM_Rcvr* aRcvrPtr);
 
   virtual unsigned int BeginTwoWayOTH_Interaction(WsfEM_Xmtr*  aXmtrPtr,
                                                   WsfPlatform* aTgtPtr,
                                                   WsfEM_Rcvr*  aRcvrPtr,
                                                   double       aReflectionLocWCS[3]);
 
   virtual unsigned int BeginGenericInteraction(WsfEM_Xmtr* aXmtrPtr, WsfPlatform* aTgtPtr, WsfEM_Rcvr* aRcvrPtr);
 
   double ComputeAttenuationFactor(Geometry aGeometry);
 
   void ComputeMaskingFactor();
 
   void ComputeInfraredSigAzEl();
 
   void ComputeOpticalSigAzEl();
 
   void ComputeRadarSigAzEl();
 
   double ComputeRF_OneWayPower();
 
   double ComputeRF_TwoWayPower(double aCrossSection);
 
   double ComputeRF_ReceivedPower(double aPowerDensity);
 
   double ComputeRF_TransmittedPower();
 
   virtual void ComputeUndefinedGeometry();
 
   double ComputeTargetDopplerFrequency(bool aFilterOwnshipFromDoppler);
 
   double ComputeTargetDopplerSpeed(bool aFilterOwnshipFromDoppler);

   WsfEM_Rcvr* GetReceiver() const { return mRcvrPtr; }

   WsfEM_Xmtr* GetTransmitter() const { return mXmtrPtr; }

   WsfPlatform* GetTarget() const { return mTgtPtr; }
 
   static bool MaskedByHorizon(const WsfEM_Xmtr* aXmtrPtr, const WsfEM_Rcvr* aRcvrPtr);
 
   static bool MaskedByHorizon(const WsfEM_XmtrRcvr* aXmtrRcvrPtr, WsfPlatform* aPlatformPtr, double aEarthRadiusScale);
 
   static bool MaskedByHorizon(const WsfEM_XmtrRcvr* aXmtrRcvrPtr,
                               WsfPlatform*          aPlatformPtr,
                               double                aReflectionPointWCS[3],
                               double                aEarthRadiusScale);
 
   bool MaskedByTerrain();
 
   virtual void Print(ut::log::MessageStream& aMsgStream);
 
   virtual void PrintGeometry(ut::log::MessageStream& aMsgStream);

   virtual void PrintStatus(ut::log::MessageStream& aMsgStream) const;
   virtual void PrintStatusP(ut::log::MessageStream& aMsgStream) const;
 
   double PrintableAngle(double aAngle) const;
 
   virtual void Reset();

   const char* GetScriptClassName() const override { return "WsfEM_Interaction"; }
 
   void SetReceiverBeamPosition();
 
   void SetReceiverBeamPosition(const BeamData& aBeamData);
 
   void SetTransmitterBeamPosition();
 
   void SetTransmitterBeamPosition(const BeamData& aBeamData);
 
   bool WithinFieldOfView(WsfEM_Antenna* aAntennaPtr,
                          LocationData&  aSrcLoc,
                          LocationData&  aTgtLoc,
                          RelativeData&  aSrcToTgt,
                          RelativeData&  aTgtToSrc,
                          bool           aIgnoreLimits = false);
 
   void SetCategory(WsfStringId aCategory) { mCategoryId = aCategory; }
   bool CategoryIsSet() const { return !mCategoryId.Empty(); }
 
   void AddComponent(Component* aComponentPtr) { mComponents.AddComponent(aComponentPtr); }
 
   const ComponentList& GetComponents() const { return mComponents; }

   unsigned int mCheckedStatus{0};

   unsigned int mFailedStatus{0};

   bool mBistatic{false};

   LocationData mXmtrLoc;

   LocationData mRcvrLoc;

   LocationData mTgtLoc;

   RelativeData mRcvrToTgt;

   RelativeData mTgtToRcvr;

   RelativeData mXmtrToTgt;

   RelativeData mTgtToXmtr;

   RelativeData mXmtrToRcvr;

   RelativeData mRcvrToXmtr;

   BeamData mRcvrBeam;

   BeamData mXmtrBeam;

   double mMaskingFactor{1.0};

   double mInfraredSig{-1.0};

   double mInfraredSigAz{0.0};

   double mInfraredSigEl{0.0};

   double mRadarSig{-1.0};

   double mRadarSigAz{0.0};

   double mRadarSigEl{0.0};

   double mOpticalSig{-1.0};

   double mOpticalSigAz{0.0};

   double mOpticalSigEl{0.0};

   double mOpticalReflectivity{-1.0};

   double mXmtdPower{0.0};

   double mPowerDensityAtTarget{0.0};

   double mRcvdPower{0.0};

   double mRcvrNoisePower{0.0};

   double mClutterPower{0.0};

   double mInterferencePower{0.0};

   double mInterferenceFactor{0.0};

   double mSignalToNoise{0.0};

   double mPropagationFactor{0.0};

   double mAbsorptionFactor{0.0};

   double mBackgroundRadiantIntensity{0.0};

   double mContrastRadiantIntensity{0.0};

   double mDetectionThreshold{0.0};

   double mPixelCount{0.0};

   double mEarthRadiusScale{0.0};

   WsfStringId mCategoryId{nullptr};

   double mZoneAttenuationValue{0.0};
 
private:
   void ComputeRF_PropagationFactor();
 
   void ComputeReceiverBeamAspect();
 
   void ComputeTransmitterBeamAspect();
 
   void ComputeZoneAttenuation(WsfPlatform* aFromPtr, WsfPlatform* aTargetPtr, bool aIsTwoWay);
 
   void PrintAbsTargetData(ut::log::MessageStream& aMsgStream,
                           const char*             aPrefix,
                           WsfPlatform*            aTgtPtr,
                           const LocationData&     aLocData);
 
   void PrintRelTargetData(ut::log::MessageStream& aMsgStream,
                           const char*             aPrefix,
                           WsfPlatform*            aTgtPtr,
                           const RelativeData&     aRelData);
 
   void PrintAbsXmtrRcvrData(ut::log::MessageStream& aMsgStream,
                             const char*             aPrefix,
                             WsfEM_XmtrRcvr*         aXmtrRcvrPtr,
                             const LocationData&     aLocData);
 
   void PrintRelXmtrRcvrData(ut::log::MessageStream& aMsgStream,
                             const char*             aPrefix,
                             WsfEM_XmtrRcvr*         aXmtrRcvrPtr,
                             const RelativeData&     aRelData);
 
   void PrintBeamData(ut::log::MessageStream& aMsgStream,
                      const char*             aPrefix,
                      WsfEM_XmtrRcvr*         aXmtrRcvrPtr,
                      const BeamData&         aBeamData);
 
   void PrintLocationData(ut::log::MessageStream& aMsgStream,
                          const char*             aPrefix,
                          WsfPlatform*            aPlatformPtr,
                          const LocationData&     aLocationData) const;
 
   void PrintRange(ut::log::MessageStream& aMsgStream, double aRange) const;
 
 
   WsfEM_Xmtr*  mXmtrPtr{nullptr};
   WsfEM_Rcvr*  mRcvrPtr{nullptr};
   WsfPlatform* mTgtPtr{nullptr};
 
   ComponentList mComponents;
};
 
#endif