SOSM_Sensor.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI//REL TO USA ONLY
//
// 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 SOSM_SENSOR_HPP
#define SOSM_SENSOR_HPP
 
#include "sosm_export.h"
 
#include <memory>
#include <string>
#include <vector>
 
class SOSM_Atmosphere;
#include "SOSM_CoreBase.hpp"
class SOSM_Interaction;
#include "SOSM_ScalarTable2D.hpp"
#include "SOSM_Selector.hpp"
class SOSM_Target;

class SOSM_EXPORT SOSM_Sensor : public SOSM_CoreBase
{
public:
   SOSM_Sensor(SOSM_Manager* aManagerPtr);
   SOSM_Sensor(const SOSM_Sensor& aSrc);
   ~SOSM_Sensor() override;
   SOSM_Sensor& operator=(const SOSM_Sensor&) = delete;
 
   SOSM_Sensor* Clone() const;
 
   bool Initialize() override;
 
   void InputComplete() override;
 
   bool ProcessInput(UtInput& aInput) override;
 
   void ComputeIntegratedAtmosphericData(SOSM_Interaction& aInteraction,
                                         float&            aBackgroundRadiance_xR,
                                         float&            aForegroundRadiance_xR,
                                         float&            aTransmittance_xR);
 
   void ComputeIntegratedTargetData(SOSM_Target*      aTargetPtr,
                                    SOSM_Interaction& aInteraction,
                                    float&            aTargetIntensity_xR,
                                    float&            aProjectedArea);
 
   float ComputeProbabilityOfDetection(float aTargetIrradiance, SOSM_Interaction& aInteraction) const;
 
   float ComputeTargetIrradiance(SOSM_Target* aTargetPtr, SOSM_Interaction& aInteraction);

   SOSM_Atmosphere* GetAtmosphere() const { return mAtmospherePtr; }

   float GetAverageResponse() const { return mSharedDataPtr->mAverageResponse; }

   float GetDetectionThresholdAboveHorizon() const { return mSharedDataPtr->mDetectionThresholdAboveHorizon; }

   float GetDetectionThresholdBelowHorizon() const { return mSharedDataPtr->mDetectionThresholdBelowHorizon; }

   std::vector<float> GetIntegrationFactor() const { return mSharedDataPtr->mIntegFactor; }

   float GetNoiseEquivalentIrradiance() const { return mSharedDataPtr->mNoiseEquivalentIrradiance; }
 
   void GetResponseCurve(std::vector<float>& aWavelength, std::vector<float>& aResponse) const;

   void GetWavelengthLimits(float& aLowerWavelength, float& aUpperWavelength) const
   {
      aLowerWavelength = mSharedDataPtr->mLowerWavelength;
      aUpperWavelength = mSharedDataPtr->mUpperWavelength;
   }
 
   static double ComputeProbabilityOfDetection(double aSignal, double aNoise, double aThreshold);
 
   SOSM_Manager* GetManager() const { return mManagerPtr; }
 
private:
   class ResponsePoint
   {
   public:
      bool operator<(const ResponsePoint& aRhs) const { return (mWavelength < aRhs.mWavelength); }
      bool operator==(const ResponsePoint& aRhs) const { return (mWavelength == aRhs.mWavelength); }

      float mWavelength;
      float mResponse;
   };

   class SharedData : public SOSM_SpectralObject
   {
   public:
      SharedData();
 
      float ComputeAverageResponse(const TblIndVarU<float>& aWavelengthVar,
                                   const TblDepVar1<float>& aResponseVar,
                                   float                    aLowerWavelength,
                                   float                    aUpperWavelength);
      void  InputComplete(SOSM_Sensor& aSensor);
      bool  ProcessInput(UtInput& aInput, SOSM_Sensor& aSensor);
      float ReadWavenumber(UtInput& aInput);
      void  ShowResponse(SOSM_Sensor& aSensor, const std::vector<float>& aResponse);

      std::vector<ResponsePoint> mResponseCurve;

      float mLowerWavelength;

      float mUpperWavelength;

      float mNoiseEquivalentIrradiance;

      float mDetectionThresholdAboveHorizon;

      float mDetectionThresholdBelowHorizon;

      std::shared_ptr<SOSM_ScalarTable2D> mInstallationAdjustmentTablePtr;
 
      std::string mAtmosphereType;

      bool mShowResponse;

      std::vector<float> mIntegFactor;

      std::vector<float> mTransFactor;

      float mFirstIntervalFraction;

      float mLastIntervalFraction;

      float mSumIntervalSize;

      float mAverageResponse;
   };
 
   SOSM_Manager* mManagerPtr;

   std::shared_ptr<SharedData> mSharedDataPtr;

   SOSM_Atmosphere* mAtmospherePtr;

   SOSM_Selector mAtmosphereSelector;
};
 
#endif