SensorEchosounder.h

#pragma once
 
#include "SampleClock.h"
#include "SensorFrame.h"
#include "SensorNoise.h"
 
#include <fhsim/simobject/SimObject.h>
#include <fstream>
#include <marenv/marenv.h>
#include <memory>
#include <string>
#include <vector>
 
namespace environment
{
class EnvironmentProvider;
}
 
class SensorEchosounder : public SimObject
{
public:
   struct Settings
   {
      double pingPeriod         = 0.5;    
      double maxRangeDown       = 150.0;  
      double maxRangeUp         = 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; 
 
      double binSize                  = 1.0;    
      double svFloorDb                = -140.0; 
      double independentSamplesPerBin = 8.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;   
      double      massKg           = 0.0;  
      double      lengthM          = 0.0;  
      double      tsRefDb          = 0.0;  
      double      refFreqkHz       = 38.0; 
      double      slopeDbPerOctave = 0.0;  
   };
 
   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 TargetStrengthDb(const Species& species, double frequencykHz);
 
   static double BackscatterCrossSection(const Species& species, double frequencykHz);
 
   static std::string FieldStatusWarning(const std::string& sensorName, const char* beamLabel,
         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);
 
private:
   struct BeamFieldWarnings
   {
      bool outOfRange = false; 
      bool error      = false; 
   };
 
   void ReadFrequencyArrays(ISimObjectCreator* const creator);
 
   void ReadFileParameters(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 WriteBeam(double dT, const double position[3], const double direction[3],
         const char* beamLabel, double beamRange, double bottomRange, BeamFieldWarnings& warned);
 
   static double RangeToSurface(const double position[3], const double direction[3], double maxRange);
 
   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::vector<double> m_frequencykHz;        
   std::vector<double> m_absorptionDbPerKm;   
   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;     
 
   BeamFieldWarnings m_downFieldWarned; 
   BeamFieldWarnings m_upFieldWarned;   
 
   Reading m_reading; 
 
   std::vector<double> m_binConcentration;
 
   std::string m_row;
 
#ifdef FH_VISUALIZATION
   Ogre::SceneManager* m_sceneMgr   = nullptr; 
   Ogre::SceneNode*    m_beamNode   = nullptr; 
   Ogre::ManualObject* m_beamObject = nullptr; 
#endif
};