SensorEchosounder.h

#pragma once
 
#include "SampleClock.h"
#include "SensorFrame.h"
#include "SensorNoise.h"
 
#include <array>
#include <fhsim/simobject/SimObject.h>
#include <fstream>
#include <marenv/marenv.h>
#include <memory>
#include <span>
#include <string>
#include <vector>
 
namespace environment
{
class EnvironmentProvider;
}
 
class SensorEchosounder : public SimObject
{
public:
   struct Settings
   {
      double pingPeriod         = 0.5;    
      double maxRangeDown       = 150.0;  
      double rayStepSize        = 1.0;    
      double rayTolerance       = 0.01;   
      double rangeBias          = 0.02;   
      double rangeNoiseStd      = 0.02;   
      double rangeNoiseRelative = 0.0005; 
 
      double beamWidthDeg = 7.0; 
      int    beamSamples  = 1;   
 
      double binSize                  = 1.0;    
      double svFloorDb                = -140.0; 
      double independentSamplesPerBin = 8.0;    
 
      double minRange          = 1.0;   
      double bottomOffset      = 0.5;   
      double bottomThresholdDb = -30.0; 
 
      unsigned int noiseSeed = 0; 
   };
 
   struct Reading
   {
      double seafloorDistance = 0.0; 
      double seafloorDepth    = 0.0; 
      double altitude         = 0.0; 
      double valid            = 0.0; 
      double pingTime         = 0.0; 
   };
 
   struct Species
   {
      std::string         name;         
      int                 handle = -1;  
      std::string         speciesKey;   
      double              lengthCm = 0.0; 
      std::vector<double> sigmaBsPerKg; 
   };
 
   SensorEchosounder(std::string simObjectName, ISimObjectCreator* creator);
 
   SensorEchosounder(std::string simObjectName, const Settings& settings);
 
   ~SensorEchosounder() override;
 
   static double PerturbRange(double trueRange, const Settings& settings, SensorNoise& noise);
 
   static bool IsValidRaySearch(double rayStepSize, double rayTolerance);
 
   static bool IsValidMaxRange(double maxRange);
 
   static double AltitudeOf(double slantRange, const double beamDirection[3]);
 
   static int BinCountOf(double range, double binSize);
 
   static double SampleRangeOf(int bin, double binSize, double beamRange);
 
   static double DownSampleRangeOf(int bin, double binSize, double bottomRange, double clearance);
 
   static double BottomClearance(double rayTolerance, const double beamDirection[3]);
 
   static double BeamPattern(double offAxisRad, double beamWidthDeg);
 
   static void SampleDirections(const double axis[3], int beamSamples, double ringAngleRad, std::vector<std::array<double, 3>>& directions);
 
   static int DetectBottomBin(const std::vector<double>& svLinear, double binSize, double beamRange, double minRange, double thresholdDb);
 
   static double IntegrateOverWindow(std::span<const double> perBin, double binSize, double beamRange, double windowStart, double windowEnd);
 
   static std::string FieldStatusWarning(const std::string& sensorName, const std::string& fieldName, double depth, marenv::Status status);
 
   static double NoiseFloorLinear(double noiseSvAt1mDb, double absorptionDbPerKm, double range);
 
   void OdeFcn(const double dT, const double* const adX, double* const adXDot) const override;
 
   void AcceptedStep(const double dT, const double* const adX) override;
 
   void FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const creator) override;
 
#ifdef FH_VISUALIZATION
   void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator) override;
 
   void RenderUpdate(const double dT, const double* const adX) override;
#endif
 
   const Reading& HeldReading() const { return m_reading; }
 
   const Settings& GetSettings() const { return m_settings; }
 
   const std::vector<Species>& GetSpecies() const { return m_species; }
 
   int PingsTaken() const { return m_pingsTaken; }
 
   const std::vector<double>& Frequencies() const { return m_frequencykHz; }
 
protected:
   const double* OutSeafloorDistance(const double dT, const double* const adX);
   const double* OutSeafloorDepth(const double dT, const double* const adX);
   const double* OutAltitude(const double dT, const double* const adX);
   const double* OutValid(const double dT, const double* const adX);
   const double* OutPingTime(const double dT, const double* const adX);
   const double* OutSa(const double dT, const double* const adX, const int index);
   const double* OutIntegratedBiomass(const double dT, const double* const adX, const int index);
 
private:
   struct FieldWarnings
   {
      bool outOfRange = false; 
      bool error      = false; 
   };
 
   void ReadFrequencyArrays(ISimObjectCreator* const creator);
 
   void PrepareFrequencyConstants();
 
   void ReadFileParameters(ISimObjectCreator* const creator);
 
   void RefuseRemovedParameters(ISimObjectCreator* const creator);
 
   void ResolveEnvironment(ISimObjectCreator* const creator);
 
   void ResolveSpecies(ISimObjectCreator* const creator);
 
   void Ping(double dT, const double* const adX);
 
   double MeasureBottom(double dT, const double position[3], const double beamDown[3]);
 
   void UpdateAbsorption(double dT, const double position[3], const double direction[3], double beamRange);
 
   void FormPingColumns(double dT, const double position[3], const double direction[3], double bottomRange);
 
   void WriteRow(double dT, const double position[3], size_t channel, const std::vector<double>& svLinear);
 
   void OpenFileAndWriteHeader(ISimObjectCreator* const creator);
 
   void Warn(const std::string& text) const;
 
   SensorFrame m_frame;     
   SampleClock m_pingClock; 
   SensorNoise m_noise;     
   Settings    m_settings;  
 
   std::string m_name; 
 
   std::vector<std::string> m_speciesFieldNames;    
   bool                     m_autoDiscover = false; 
   std::vector<Species>     m_species;              
   std::string              m_parameterLibrary;     
 
   std::vector<double> m_frequencykHz;        
   std::vector<double> m_beamWidthDeg;        
   std::vector<double> m_absorptionDbPerKm;   
   bool                m_absorptionGiven = false; 
   std::vector<double> m_bottomBackscatterDb; 
   std::vector<double> m_noiseSvAt1mDb;       
   std::vector<double> m_svBiasDb;            
 
   bool        m_writeFile = true;      
   std::string m_fileName;              
   int         m_flushEveryNPings = 20; 
   int         m_svPrecision      = 2;  
 
   std::unique_ptr<std::ofstream> m_stream; 
 
   environment::EnvironmentProvider* m_environment = nullptr; 
   PrintDuringExec*                  m_print       = nullptr; 
 
   bool m_hasPorts   = false; 
   int  m_pingsTaken = 0;     
 
   FieldWarnings m_fieldWarned; 
 
   Reading             m_reading;           
   std::vector<double> m_sa;                
   std::vector<double> m_integratedBiomass; 
 
   double              m_halfWidthRad = 0.0;      
   std::vector<double> m_ringWeight;              
   std::vector<double> m_svBiasLinear;            
   std::vector<double> m_bottomBackscatterLinear; 
 
   std::vector<std::array<double, 3>> m_directions;
   std::vector<double> m_axisConcentration;
   std::vector<double> m_ringConcentration;
   std::vector<std::vector<double>> m_svLinear;
   std::string m_row;
 
#ifdef FH_VISUALIZATION
   Ogre::SceneManager* m_sceneMgr   = nullptr; 
   Ogre::SceneNode*    m_beamNode   = nullptr; 
   Ogre::ManualObject* m_beamObject = nullptr; 
#endif
};