WsfArticulatedPart.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 WSFARTICULATEDPART_HPP
#define WSFARTICULATEDPART_HPP
 
#include "UtCallback.hpp"
#include "UtEntityPart.hpp"
class UtInput;
#include "wsf_export.h"
 
#include "UtMath.hpp"
#include "WsfComponent.hpp"
class WsfMaskingPattern;
class WsfPlatform;
#include "WsfPlatformPart.hpp"
class WsfScenario;
#include "WsfSinglePlatformObserver.hpp"

class WSF_EXPORT WsfArticulatedPart : public WsfPlatformPart, public UtEntityPart, public WsfSinglePlatformObserver
{
public:
   static constexpr double cINFINITE_SLEW_RATE = 1.0E+12 * UtMath::cRAD_PER_DEG;
   static constexpr double cALMOST_FULL_CIRCLE = 359.999 * UtMath::cRAD_PER_DEG;

   enum SlewMode
   {
      cSLEW_FIXED = 0, //<! The part cannot be slewed
      cSLEW_AZ    = 1, //<! The part can be slewed only in azimuth
      cSLEW_EL    = 2, //<! The part can be slewed only in elevation
      cSLEW_AZ_EL = 3  //<! The part can be slewed in both azimuth and elevation
   };
 
   enum SlewDirection
   {
      cUNDEFINED = 0, //<! The slew direction is undefined
      cPOSITIVE  = 1, //<! Slew direction is through positive angle
      cNEGATIVE  = 2  //<! Slew direction is through negative angle
   };
 
   enum // slewState
   {
      cNOT_CUED         = 0x0000,
      cMIN_AZ           = 0x0001,
      cMAX_AZ           = 0x0002,
      cMIN_EL           = 0x0004,
      cMAX_EL           = 0x0008,
      cAT_LIMIT_AZ_MASK = 0x0003,
      cAT_LIMIT_EL_MASK = 0x000B,
      cAT_LIMIT_MASK    = 0x000F, // "and" (&) with this for any at limit state
      cCUED_AZ          = 0x0010,
      cCUED_EL          = 0x0020,
      cCUED_AZ_EL       = 0x0030, // = cCUED_AZ + cCUED_EL
      cCUED_MASK        = 0x0030  // "and" (&) with this for any cued state
   };
 
   enum CueType
   {
      cCUED_TO_NOTHING,  
      cCUED_TO_LOCATION, 
      cCUED_TO_ANGLE     
   };
 
   WsfArticulatedPart(const WsfScenario& aScenario, int aPartType);
   WsfArticulatedPart(const WsfArticulatedPart& aSrc);
   ~WsfArticulatedPart() override;


   const int* GetComponentRoles() const override;
   void*      QueryInterface(int aRole) override;
 
   const char* GetScriptClassName() const override;
   bool        Initialize(double aSimTime) override;
   bool        ProcessInput(UtInput& aInput) override;
   void        SetPlatform(WsfPlatform* aPlatformPtr) override;
 
   virtual void UpdatePosition(double aSimTime);



   void OnPlatformUpdated(double /* aSimTime */, WsfPlatform* /*aPlatformPtr*/) override { InvalidateTransform(); }



   SlewMode GetSlewMode() const { return mSlewMode; }

   double GetAzSlewRate() const { return mAzSlewRate; }
   double GetElSlewRate() const { return mElSlewRate; }

   double GetMaxAzSlewRate() const { return mMaxAzSlewRate; }
   double GetMaxElSlewRate() const { return mMaxElSlewRate; }

   double GetMinAzSlew() const { return mMinAzSlew; }
   double GetMaxAzSlew() const { return mMaxAzSlew; }
   double GetMinElSlew() const { return mMinElSlew; }
   double GetMaxElSlew() const { return mMaxElSlew; }

   int GetSlewState() const { return mSlewState; }

   void SetSlewMode(SlewMode aSlewMode) { mSlewMode = aSlewMode; }
 
   void SetSlewRates(double aAzSlewRate, double aElSlewRate);

   void SetAzSlewLimits(double aMinAzSlew, double aMaxAzSlew)
   {
      mMinAzSlew = aMinAzSlew;
      mMaxAzSlew = aMaxAzSlew;
   }

   void SetElSlewLimits(double aMinElSlew, double aMaxElSlew)
   {
      mMinElSlew = aMinElSlew;
      mMaxElSlew = aMaxElSlew;
   }

   void SetAzimuthSlewDirection(SlewDirection aAzSlewDirection) { mAzSlewDirection = aAzSlewDirection; }
 
   bool IsSlewing() const;

   bool WithinSlewLimits(double aThisToTgtAz, double aThisToTgtEl) const
   {
      return ((aThisToTgtAz >= mMinAzSlew) && (aThisToTgtAz <= mMaxAzSlew) && (aThisToTgtEl >= mMinElSlew) &&
              (aThisToTgtEl <= mMaxElSlew));
   }




   SlewMode GetCueMode() const { return mCueMode; }

   double GetAzCueRate() const { return mAzCueRate; }
   double GetElCueRate() const { return mElCueRate; }
   double GetMinAzCue() const { return mMinAzCue; }
   double GetMaxAzCue() const { return mMaxAzCue; }
   double GetMinElCue() const { return mMinElCue; }
   double GetMaxElCue() const { return mMaxElCue; }

   void SetCueMode(SlewMode aCueMode) { mCueMode = aCueMode; }

   void SetCueRates(double aAzCueRate, double aElCueRate)
   {
      mAzCueRate = aAzCueRate;
      mElCueRate = aElCueRate;
   }

   void SetAzCueLimits(double aMinAzCue, double aMaxAzCue)
   {
      mMinAzCue = aMinAzCue;
      mMaxAzCue = aMaxAzCue;
   }

   void SetElCueLimits(double aMinElCue, double aMaxElCue)
   {
      mMinElCue = aMinElCue;
      mMaxElCue = aMaxElCue;
   }



   double GetRoll() const { return mRoll; }
   void   SetRoll(double aRoll);
 
   double GetPitch() const { return mPitch; }
   void   SetPitch(double aPitch);
 
   double GetYaw() const { return mYaw; }
   void   SetYaw(double aYaw);
 
   double GetTilt() const { return mTilt; }
   void   SetTilt(double aTilt);
 
   void GetCurrentOrientationECS(double& aYaw, double& aPitch, double& aRoll);
 
   void GetLOS_UnitVectorWCS(double aUnitLOS_WCS[3]);


   CueType GetCueType() const { return mCueType; }

   bool IsCued() const { return mCueType != cCUED_TO_NOTHING; }
 
   void ClearCueing();
 
   bool GetActualCuedOrientation(double& aAzimuth, double& aElevation) const;
 
   void GetCurrentCuedOrientation(double& aAzimuth, double& aElevation) const;
 
   bool GetCuedLocationWCS(double aCuedLocationWCS[3]) const;
 
   void SetCuedLocationWCS(const double aCuedLocationWCS[3]);
 
   bool GetCuedOrientation(double& aAzimuth, double& aElevation) const;
 
   void SetCuedOrientation(double aAzimuth, double aElevation);
 
   void GetAbsoluteCuedOrientation(double& aAzimuth, double& aElevation, double aBaseNED[3]);
 
   void ClearTransientCue();
 
   bool TransientCueActive() const { return mTransientCueActive; }
 
   bool GetTransientCuedLocationWCS(double aCuedLocationWCS[3]) const;
 
   void SetTransientCuedLocationWCS(const double aCuedLocationWCS[3]);


   WsfStringId GetMaskingPatternState() const { return mMaskingPatternStateId; }
   void SetMaskingPatternState(WsfStringId aMaskingPatternStateId) { mMaskingPatternStateId = aMaskingPatternStateId; }
   double GetMaskingPatternFactor(double aViewAzPCS, double aViewElPCS, const double aViewVecWCS[3]);


   void SetIsPrivate(bool aIsPrivate) { mIsPrivate = aIsPrivate; }
   bool IsPrivate() const { return mIsPrivate; }


   void SetPositionRateECS(const double aDX, const double aDY, const double aDZ);
 
   void GetCurrentPositionRateECS(double& aDX, double& aDY, double& aDZ) const;
 
   double GetDX() const { return mDX; }
   double GetDY() const { return mDY; }
   double GetDZ() const { return mDZ; }
 
   void EnableArticulationUpdates(double aSimTime, double aInterval);
   void DisableArticulationUpdates(double aSimTime);

   void SetArticulationUpdateInterval(double aUpdateInterval) { mArticulationUpdateInterval = aUpdateInterval; }
 
   double GetArticulationUpdateInterval() const { return mArticulationUpdateInterval; }

   unsigned int GetArticulationUpdateEventEpoch() const { return mArticulationUpdateEventEpoch; }

   void IncrementArticulationUpdateEventEpoch() { ++mArticulationUpdateEventEpoch; }

   bool ArticulationUpdateEventActive() const { return mArticulationUpdateEventActive; }

   void SetArticulationUpdateEventActive(bool aUpdateEventActive)
   {
      mArticulationUpdateEventActive = aUpdateEventActive;
   }


   virtual double TimeToCue(double aDesiredAz, double aDesiredEl) const;
 
   UtCallbackListN<void(double)> SlewComplete;
 
protected:
   bool FullCircle() const { return ((mMaxAzSlew - mMinAzSlew) >= cALMOST_FULL_CIRCLE); }
 
   virtual double GetAzimuthRotationRate() const;
   virtual double GetElevationRotationRate() const;
 
   void SlewToOrientation(double aSimTime, double aDesiredAz, double aDesiredEl);
 
   virtual void TimeToRotate(double& aDeltaAz,
                             double& aDeltaEl,
                             double& aAzRate,
                             double& aElRate,
                             double& aTimeToAz,
                             double& aTimeToEl) const;
 
   void UpdateCuedOrientation(double aSimTime);
 
   bool UpdateOrientation(double aSimTime);


   WsfMaskingPattern* mMaskingPatternPtr;
   WsfStringId        mMaskingPatternName;
   WsfStringId        mMaskingPatternStateId;


   double mYaw;
   double mPitch;
   double mRoll;


   double mDX;
   double mDY;
   double mDZ;

   double mTilt;


   double mAzSlewRate;
   double mElSlewRate;
   double mMaxAzSlewRate;
   double mMaxElSlewRate;
   double mMinAzSlew;
   double mMaxAzSlew;
   double mMinElSlew;
   double mMaxElSlew;
 
   SlewMode      mSlewMode;
   SlewDirection mAzSlewDirection;
   int           mSlewState;


   double mAzCueRate;
   double mElCueRate;
   double mMinAzCue;
   double mMaxAzCue;
   double mMinElCue;
   double mMaxElCue;

   SlewMode mCueMode;

   CueType mCueType;
   bool    mTransientCueActive; 
 
   double mCuedLocationWCS[3];          
   double mCuedAz;                      
   double mCuedEl;                      
   double mTransientCuedLocationWCS[3]; 


   double mActualCuedAz;
   double mActualCuedEl;
 
   double mCurrentAz;
   double mCurrentEl;
 
   double mLastAzElUpdateTime; 
 
   double mLastUpdateTime; 

   bool mSlewMethodCoordinated;

   bool mIsSlewing;

   bool mIsPrivate;
 
private:
   WsfArticulatedPart& operator=(const WsfArticulatedPart& aRhs) = delete;

   double       mArticulationUpdateInterval;
   unsigned int mArticulationUpdateEventEpoch;
   bool         mArticulationUpdateEventActive;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfArticulatedPart, cWSF_COMPONENT_ARTICULATED_PART)
 
#endif