WsfOpticalPath.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 WSFOPTICALPATH_HPP
#define WSFOPTICALPATH_HPP
 
#include "wsf_mil_export.h"
 
#include <string>
#include <vector>
 
class Integrand;
#include "UtGenericMappedList.hpp"
#include "UtIntegrand.hpp"
class UtInput;
class WsfEM_Xmtr;
class WsfOpticalPathCoefficientTypes;
class WsfScenario;

class WSF_MIL_EXPORT WsfOpticalPath
{
public:
   friend class WsfOpticalPathCoefficientTypes;
   WsfOpticalPath(); // Use for deferred initialization of coefficients
   WsfOpticalPath(const WsfOpticalPathCoefficientTypes& aTypes,
                  unsigned                              aWavelength,
                  unsigned                              aAtmosphereModel = 2,
                  unsigned                              aHazeMode        = 1);
 
   class Coefficients;
 
   WsfOpticalPath(const WsfOpticalPath::Coefficients* aCoefficientsPtr); // For use with legacy code.
 
   virtual ~WsfOpticalPath() = default;
 
   enum Type
   {
      cABS,  
      cSCAT, 
      cBOTH  
   };
 
   bool Initialize(WsfOpticalPathCoefficientTypes& aTypes,
                   unsigned                        aWavelength_nm,
                   unsigned                        aAtmosphereModel = 2,
                   unsigned                        aHazeModel       = 1);
 
   double GetAttenuation(double aSlantRange, double aTargetHeight, double aShootHeight);

   class WSF_MIL_EXPORT Coefficients
   {
   public:
      Coefficients()          = default;
      virtual ~Coefficients() = default;
 
      // virtual Coefficients* Clone() const = 0;
 
      virtual double GetExtinction(double aAltitude, Type aType = cBOTH) const = 0;
   };
 

   class WSF_MIL_EXPORT LaserCoefficients : public Coefficients
   {
   public:
      friend class WsfOpticalPathCoefficientTypes;
      LaserCoefficients();
      ~LaserCoefficients() override = default;
 
      const Coefficients& GetCoefficients(const std::string& aWavelength_nm,
                                          unsigned           aAtmosphereModel = 2,
                                          unsigned           aHazeModel       = 1);
 
      double GetExtinction(double aAltitude, Type aType) const override;

      const std::vector<double>& GetAltitudes() const { return mAltitude; }
      const std::vector<double>& GetAttenuationCoefficients() const { return mAbs; }
      const std::vector<double>& GetScatteringCoefficients() const { return mScat; }
 
   protected:
   private:
      friend class WsfOpticalAttenuation; 
 
      double mWavelength; 
      int    mAtmosphereModel;       
      int mHazeModel;                
      std::vector<double> mAltitude; 
      std::vector<double> mAbs;      
      std::vector<double> mScat;     
   };

   class WSF_MIL_EXPORT Integrand : public UtIntegrand
   {
   public:
      Integrand(double aSlantRange, double aTargetHeight, double aPlatformHeight, const Coefficients& aCoeffs, Type aType)
         : mSlantRange(aSlantRange)
         , mTargetHeight(aTargetHeight)
         , mPlatformHeight(aPlatformHeight)
         , mCoeffs(aCoeffs)
         , mType(aType)
      {
      }
 
      double Function(double aRange) override;
 
   private:
      double Height(double aRangeFromPlatform, double aTotalSlantRange, double aTargetHeight, double aPlatformHeight);
 
      double              mSlantRange;
      double              mTargetHeight;
      double              mPlatformHeight;
      const Coefficients& mCoeffs;
      Type                mType;
   };
 
   WsfOpticalPath(const WsfOpticalPathCoefficientTypes& aTypes,
                  double                                aWavelength,
                  unsigned                              aAtmosphereModel = 2,
                  unsigned                              aHazeMode        = 1);
 
private:
   const Coefficients* mCoeffsPtr;
};
 
class WsfOpticalPathCoefficientTypes
{
public:

   static WSF_MIL_EXPORT WsfOpticalPathCoefficientTypes&       Get(WsfScenario& aScenario);
   static WSF_MIL_EXPORT const WsfOpticalPathCoefficientTypes& Get(const WsfScenario& aScenario);
 
   using Coefficients = WsfOpticalPath::LaserCoefficients;
 
   WSF_MIL_EXPORT bool LoadType(UtInput& aInput);
 
   WSF_MIL_EXPORT const Coefficients& GetCoefficients(unsigned aWavelength_nm,
                                                      unsigned aAtmosphereModel = 2,
                                                      unsigned aHazeModel       = 1) const;
 
   WSF_MIL_EXPORT const Coefficients& GetCoefficients(double   aWavelength,
                                                      unsigned aAtmosphereModel = 2,
                                                      unsigned aHazeModel       = 1) const;
 
private:
   UtStdMappedList<Coefficients, std::string> mCoeffs;
};
#endif