SensorCtd.h

#pragma once
 
#include "SampledSensor.h"
 
#include <fhsim/simobject/SimObject.h>
#include <fhsim_environment/ScalarField.h>
#include <string>
 
namespace environment
{
class EnvironmentProvider;
}
 
class SensorCtd : public SimObject
{
public:
   struct Channel
   {
      double timeConstant = 0.0; 
      double bias         = 0.0; 
      double noiseStd     = 0.0; 
      double resolution   = 0.0; 
   };
 
   struct Settings
   {
      Channel      temperature  = {0.07, 0.002, 0.0005, 0.0}; 
      Channel      salinity     = {0.06, 0.005, 0.002, 0.0};  
      Channel      depth        = {0.02, 0.05, 0.02, 0.0};    
      double       samplePeriod = 0.0625;                     
      unsigned int noiseSeed    = 0;                          
   };
 
   struct Reading
   {
      double temperature = 0.0;             
      double salinity    = 0.0;             
      double depth       = 0.0;             
      double pressure    = 0.0;             
      double position[3] = {0.0, 0.0, 0.0}; 
   };
 
   SensorCtd(std::string simObjectName, ISimObjectCreator* creator);
 
   SensorCtd(std::string simObjectName, const Settings& settings);
 
   static double LagDerivative(double fieldValue, double lagState, double timeConstant);
 
   static double MeasuredValueOf(double lagState, double fieldValue, double timeConstant);
 
   static double Quantize(double value, double resolution);
 
   static double PressureOf(double depth);
 
   static double Perturb(double trueValue, const Channel& channel, SensorNoise& noise);
 
   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 InitialConditionSetup(const double dT, const double* const adCurrentIC,
         double* const adUpdatedIC, ISimObjectCreator* const creator) override;
 
   void FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const creator) override;
 
   bool SampleIfDue(double t, double temperature, double salinity, double depth, const double position[3]);
 
   void Update(double temperature, double salinity, double depth, const double position[3]);
 
   const Reading& HeldReading() const { return m_reading; }
 
   const Settings& GetSettings() const { return m_settings; }
 
   double NextSampleTime() const { return m_sampler.NextSampleTime(); }
 
protected:
   const double* OutTemperature(const double dT, const double* const adX);
 
   const double* OutSalinity(const double dT, const double* const adX);
 
   const double* OutDepth(const double dT, const double* const adX);
 
   const double* OutPressure(const double dT, const double* const adX);
 
   const double* OutMeasurement(const double dT, const double* const adX);
 
   const double* OutPosition(const double dT, const double* const adX);
 
private:
   struct FieldValues
   {
      double temperature       = 0.0;   
      double salinity          = 0.0;   
      bool   temperatureUsable = false; 
      bool   salinityUsable    = false; 
   };
 
   int FieldHandle(const std::string& name, environment::field::Quantity quantity) const;
 
   void ReportMissingField(ISimObjectCreator* creator, const std::string& name, const std::string& quantity, const std::string& parameter) const;
 
   void HoldUnusableChannels(const FieldValues& field, const Reading& held);
 
   void ResolveEnvironment(ISimObjectCreator* const creator);
 
   FieldValues FieldValuesAt(double dT, const double position[3]) const;
 
   void StoreReading(double temperature, double salinity, double depth, const double position[3]);
 
   void SeedHeldReading(double dT, const double* const adX);
 
   static void SetInitialConditionIfUnset(const double* const adCurrentIC, double* const adUpdatedIC,
         int stateIndex, double value);
 
   SampledSensor m_sampler;  
   Settings      m_settings; 
 
   std::string m_temperatureFieldName; 
   std::string m_salinityFieldName;    
 
   int m_temperatureHandle = -1; 
   int m_salinityHandle    = -1; 
 
   int m_IStateLagT = 0; 
   int m_IStateLagS = 0; 
   int m_IStateLagD = 0; 
 
   Reading m_reading;                          
   double  m_measurement[3] = {0.0, 0.0, 0.0}; 
};