weatherStateComponent.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include "vrfStateData/stateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include <vrfExtObjects/vrfWeatherStateEnums.h>
#include <matrix/vlVector.h>
#include <vrfutil/rwWindLevels.h>
#include <vrfOM/sets/writeWeatherStateRepository.hpp>
#include <vrfOM/sets/readWeatherStateRepository.hpp>
#include <vrfOM/sets/readThermoclineLayerRepository.hpp>

namespace makVrf
{
   class DT_DLL_vrfStateData DtWeatherStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::WeatherStateComponent)

      DtWeatherStateComponent(DtStateData* storage)
      : DtFrameStateInterface(storage)
      , myWindLevels("wind-levels")
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, airTurbidity, AirTurbidity)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, ambientAirTemperature, AmbientAirTemperature)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, ambientAirPressure, AmbientAirPressure)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVrfWeatherCloudState, cloudState, CloudState)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, precipitationIntensity, PrecipitationIntensity)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVrfWeatherPrecipitationType, precipitationType, PrecipitationType)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, priority, Priority)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, underwaterVisibility, UnderwaterVisibility)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, surfaceTransparency, SurfaceTransparency)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, waterCurrentSpeed, WaterCurrentSpeed)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, waterCurrentDirection, WaterCurrentDirection)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, ambientWaterTemperature, AmbientWaterTemperature)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, snowAccumulation, SnowAccumulation)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, rainAccumulation, RainAccumulation)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, snowMinimumAltitude, SnowMinimumAltitude)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, snowRoadAccumulation, SnowRoadAccumulation)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, tidalOffset, TidalOffset)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, tidalDirection, TidalDirection)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, swellState, SwellState)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, swellStateDirection, SwellStateDirection)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, seaState, SeaState)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, seaStateDirection, SeaStateDirection)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, windDrivenSeaStateEnabled, WindDrivenSeaStateEnabled)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, choppiness, Choppiness)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, surgeDepth, SurgeDepth)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, fogHeight, FogHeight)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, flags, Flags)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, lightningPresent, LightningPresent)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVector, fogColor, FogColor)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, airTemperatureAltitude, AirTemperatureAltitude)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, airPressureAltitude, AirPressureAltitude)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, airTemperatureAltitudeIsSeaLevel, AirTemperatureAltitudeIsSeaLevel)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, airPressureAltitudeIsSeaLevel, AirPressureAltitudeIsSeaLevel)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, seaLevelWaterConcentration, SeaLevelWaterConcentration)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer1Depth, ThermoclineLayer1Depth)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer1Permeability, ThermoclineLayer1Permeability)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer2Depth, ThermoclineLayer2Depth)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer2Permeability, ThermoclineLayer2Permeability)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer3Depth, ThermoclineLayer3Depth)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer3Permeability, ThermoclineLayer3Permeability)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer4Depth, ThermoclineLayer4Depth)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer4Permeability, ThermoclineLayer4Permeability)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer5Depth, ThermoclineLayer5Depth)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer5Permeability, ThermoclineLayer5Permeability)


      virtual const double visibility(double atAlt = 0.) const { throw DtUnimplementedMethod("visibility(atAltidude) is not implemented by this class."); };
      virtual void setVisibility(const double&) { throw DtUnimplementedMethod("setVisibility(double) is not implemented by this class."); };
      virtual void setVisibility(const double& atAlt, const double&) { throw DtUnimplementedMethod("setVisibility(const double& atAlt, const double& vis) is not implemented by this class."); };

      virtual const double windSpeed(double atAlt = 0.) const { throw DtUnimplementedMethod("windSpeed(atAltidude) is not implemented by this class."); };
      virtual void setWindSpeed(const double&) { throw DtUnimplementedMethod("setWindSpeed(double) is not implemented by this class."); };
      virtual void setWindSpeed(const double& atAlt, const double&) { throw DtUnimplementedMethod("setWindSpeed(const double& atAlt, const double& vis) is not implemented by this class."); };

      virtual const double windDirection(double atAlt = 0.) const { throw DtUnimplementedMethod("windDirection(atAltidude) is not implemented by this class."); };
      virtual void setWindDirection(const double&) { throw DtUnimplementedMethod("setWindDirection(double) is not implemented by this class."); };
      virtual void setWindDirection(const double& atAlt, const double&) { throw DtUnimplementedMethod("setWindDirection(const double& atAlt, const double& vis) is not implemented by this class."); };

      virtual const int obscurant(double atAlt = 0.) const { throw DtUnimplementedMethod("obscurant(atAltidude) is not implemented by this class."); };
      virtual void setObscurant(double atAlt, const int&) { throw DtUnimplementedMethod("setObscurant(double, int) is not implemented by this class."); };

      virtual void addWindLevel(double altitude, double windSpeed, double windDirection,
         double visibleDistance, int obscurant, int cloudType, double cloudDensity, double skyCoverage) { throw DtUnimplementedMethod("addWindLevel is not implemented by this class."); };
      virtual void clearWindLevels() { throw DtUnimplementedMethod("clearWindLevels is not implemented by this class."); };

      virtual void removeWindLevel(double baseAltitude) { throw DtUnimplementedMethod("removeWindLevel is not implemented by this class."); };

      virtual bool windSpeedAndDirectionAtAltitude(double altMSL, double& windSpeed, double& windDirection) const  { throw DtUnimplementedMethod("windSpeedAndDirectionAtAltitude is not implemented by this class."); };
      virtual void setWindSpeedAndDirectionAtAltitude(const double& altMSL, const double& windSpeed, const double& windDirection)  { throw DtUnimplementedMethod("setWindSpeedAndDirectionAtAltitude is not implemented by this class."); };

      virtual bool visibilityAndObscurantAtAltitude(double altMSL, double& distance, int& obs) const  { throw DtUnimplementedMethod("visibilityAndObscurantAtAltitude is not implemented by this class."); };
      virtual void setVisibilityAndObscurantAtAltitude(const double& altMSL, const double& distance, const int& obs)  { throw DtUnimplementedMethod("setVisibilityAndObscurantAtAltitude is not implemented by this class."); };

      virtual void setWindLevels(const DtRwWindLevels&){ throw DtUnimplementedMethod("setWindLevels is not implemented by this class."); };
      virtual const DtRwWindLevels& windLevels() const { throw DtUnimplementedMethod("windLevels is not implemented by this class."); };

   protected:
      DtRwWindLevels myWindLevels;
   };

   class DT_DLL_vrfStateData DtWeatherStateComponentNextFrame : public DtWeatherStateComponent
   {
   public:
      DtWeatherStateComponentNextFrame(DtStateData*);

      const double airTurbidity() const;
      void setAirTurbidity(const double&);

      const double ambientAirTemperature() const;
      void setAmbientAirTemperature(const double&);

      const double ambientAirPressure() const;
      void setAmbientAirPressure(const double&);

      const DtVrfWeatherCloudState cloudState() const;
      void setCloudState(const DtVrfWeatherCloudState&);

      const double precipitationIntensity() const;
      void setPrecipitationIntensity(const double&);

      const DtVrfWeatherPrecipitationType precipitationType() const;
      void setPrecipitationType(const DtVrfWeatherPrecipitationType&);

      const double windSpeed(double atAlt = 0.) const;
      void setWindSpeed(const double&);
      void setWindSpeed(const double& atAlt, const double&);

      const double windDirection(double atAlt = 0.) const;
      void setWindDirection(const double&);
      void setWindDirection(const double& atAlt, const double&);

      const int priority() const;
      void setPriority(const int&);

      const double visibility(double atAltitude) const;
      void setVisibility(const double&);
      void setVisibility(const double&, const double&);

      const int obscurant(double atAltitude) const;
      void setObscurant(double baseAlt, const int&);

      const double underwaterVisibility() const;
      void setUnderwaterVisibility(const double&);

      const double surfaceTransparency() const;
      void setSurfaceTransparency(const double&);

      const double waterCurrentSpeed() const;
      void setWaterCurrentSpeed(const double&);

      const double waterCurrentDirection() const;
      void setWaterCurrentDirection(const double&);

      const double ambientWaterTemperature() const;
      void setAmbientWaterTemperature(const double&);

      const double snowAccumulation() const;
      void setSnowAccumulation(const double&);

      const double rainAccumulation() const;
      void setRainAccumulation(const double&);

      const double snowMinimumAltitude() const;
      void setSnowMinimumAltitude(const double&);

      const double snowRoadAccumulation() const;
      void setSnowRoadAccumulation(const double&);

      const double tidalOffset() const;
      void setTidalOffset(const double&);

      const bool tidalDirection() const;
      void setTidalDirection(const bool&);

      const int swellState() const;
      void setSwellState(const int&);

      const double swellStateDirection() const;
      void setSwellStateDirection(const double&);

      const int seaState() const;
      void setSeaState(const int&);

      const double seaStateDirection() const;
      void setSeaStateDirection(const double&);

      const bool windDrivenSeaStateEnabled() const;
      void setWindDrivenSeaStateEnabled(const bool&);

      const double choppiness() const;
      void setChoppiness(const double&);

      const double surgeDepth() const;
      void setSurgeDepth(const double&);

      const double fogHeight() const;
      void setFogHeight(const double&);

      const unsigned int flags() const;
      void setFlags(const unsigned int&);

      const bool lightningPresent() const;
      void setLightningPresent(const bool&);

      const DtVector fogColor() const;
      void setFogColor(const DtVector&);

      const double thermoclineLayer1Depth() const;
      void setThermoclineLayer1Depth(const double&);

      const double thermoclineLayer1Permeability() const;
      void setThermoclineLayer1Permeability(const double&);

      const double thermoclineLayer2Depth() const;
      void setThermoclineLayer2Depth(const double&);

      const double thermoclineLayer2Permeability() const;
      void setThermoclineLayer2Permeability(const double&);

      const double thermoclineLayer3Depth() const;
      void setThermoclineLayer3Depth(const double&);

      const double thermoclineLayer3Permeability() const;
      void setThermoclineLayer3Permeability(const double&);

      const double thermoclineLayer4Depth() const;
      void setThermoclineLayer4Depth(const double&);

      const double thermoclineLayer4Permeability() const;
      void setThermoclineLayer4Permeability(const double&);

      const double thermoclineLayer5Depth() const;
      void setThermoclineLayer5Depth(const double&);

      const double thermoclineLayer5Permeability() const;
      void setThermoclineLayer5Permeability(const double&);

      const double airTemperatureAltitude() const;
      void setAirTemperatureAltitude(const double&);

      const double airPressureAltitude() const;
      void setAirPressureAltitude(const double&);

      const bool airTemperatureAltitudeIsSeaLevel() const;
      void setAirTemperatureAltitudeIsSeaLevel(const bool&);

      const bool airPressureAltitudeIsSeaLevel() const;
      void setAirPressureAltitudeIsSeaLevel(const bool&);

      const double seaLevelWaterConcentration() const;
      void setSeaLevelWaterConcentration(const double&);


      void addWindLevel(double altitude, double windSpeed, double windDirection, double visibleDistance, int obscurant, int cloudType, double cloudDensity, double skyCoverage);
      void clearWindLevels();

      void removeWindLevel(double baseAltitude);

      bool windSpeedAndDirectionAtAltitude(double altMSL, double& windSpeed, double& windDirection) const;
      void setWindSpeedAndDirectionAtAltitude(const double& altMSL, const double& windSpeed, const double& windDirection);

      bool visibilityAndObscurantAtAltitude(double altMSL, double& distance, int& obs) const;
      void setVisibilityAndObscurantAtAltitude(const double& altMSL, const double& distance, const int& obs);

      void setWindLevels(const DtRwWindLevels&);
      const DtRwWindLevels& windLevels() const;

      virtual void makeWritable();

      virtual void makeReadOnly();

      void advancedFrame() { myFirstWeatherSet = false; };

   protected:
      VRF::WriteThermoclineLayerRepository thermoclineLayer(int) const;

      VRF::WriteThermoclineLayerRepository getOrCreateThermoclineLayer(int);

   protected:
      virtual void setupWindLevels();

   protected:
      VRF::WriteWeatherStateRepository myWriteWeatherStateRepository;
      DtStateData* myStateData;
      bool myFirstWeatherSet;
   };

   class DT_DLL_vrfStateData DtWeatherStateComponentCurrentFrame : public DtWeatherStateComponent
   {
   public:
      DtWeatherStateComponentCurrentFrame(DtStateData*);
      virtual ~DtWeatherStateComponentCurrentFrame();

      const double airTurbidity() const;
      const double ambientAirTemperature() const;
      const double ambientAirPressure() const;
      const DtVrfWeatherCloudState cloudState() const;
      const double precipitationIntensity() const;
      const DtVrfWeatherPrecipitationType precipitationType() const;
      const double windSpeed(double atAlt = 0.) const;
      const double windDirection(double atAlt = 0.) const;
      const int priority() const;
      const double visibility(double atAltitude = 0.) const;
      const int obscurant(double atAltitude) const;
      const double underwaterVisibility() const;
      const double surfaceTransparency() const;
      const double waterCurrentSpeed() const;
      const double waterCurrentDirection() const;
      const double ambientWaterTemperature() const;
      const double snowAccumulation() const;
      const double rainAccumulation() const;
      const double snowMinimumAltitude() const;
      const double snowRoadAccumulation() const;
      const double tidalOffset() const;
      const bool tidalDirection() const;
      const int swellState() const;
      const double swellStateDirection() const;
      const int seaState() const;
      const double seaStateDirection() const;
      const bool windDrivenSeaStateEnabled() const;
      const double choppiness() const;
      const double surgeDepth() const;
      const double fogHeight() const;
      const DtVector fogColor() const;
      const unsigned int flags() const;
      const bool lightningPresent() const;
      const double thermoclineLayer1Depth() const;
      const double thermoclineLayer1Permeability() const;
      const double thermoclineLayer2Depth() const;
      const double thermoclineLayer2Permeability() const;
      const double thermoclineLayer3Depth() const;
      const double thermoclineLayer3Permeability() const;
      const double thermoclineLayer4Depth() const;
      const double thermoclineLayer4Permeability() const;
      const double thermoclineLayer5Depth() const;
      const double thermoclineLayer5Permeability() const;
      const double airTemperatureAltitude() const;
      const double airPressureAltitude() const;
      const bool airTemperatureAltitudeIsSeaLevel() const;
      const bool airPressureAltitudeIsSeaLevel() const;
      const double seaLevelWaterConcentration() const;

      bool windSpeedAndDirectionAtAltitude(double altMSL, double& windSpeed, double& windDirection) const;

      bool visibilityAndObscurantAtAltitude(double altMSL, double& distance, int& obs) const;

      const DtRwWindLevels& windLevels() const;

      bool readComponentValid() const;
      bool findReadComponent();

   protected:
      VRF::ReadThermoclineLayerRepository thermoclineLayer(int) const;

   protected:
      friend class DtWeatherStateComponentImplementation;
      virtual void updateWindLevels();

      void advanceFrame(const DtWeatherStateComponentNextFrame& data)
      {
         myWindLevels = data.windLevels();
      }

   protected:
      VRF::ReadWeatherStateRepository myReadWeatherStateRepository;
      DtStateData* myStateData;
      unsigned int myCallbackHandle;
   };

   class DT_DLL_vrfStateData DtWeatherStateComponentImplementation : public DtDoubleBufferedStateComponent<DtWeatherStateComponent>
   {
   public:
      DtWeatherStateComponentImplementation(DtStateData* sd);

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      void updateDataStorage()
      {
         if (!myFoundComponent)
         {
            myFoundComponent = myCurrentFrameState.findReadComponent();
         }

         if (myNextFrameState.isWritable())
         {
            myNextFrameState.advancedFrame();
            myCurrentFrameState.advanceFrame(myNextFrameState);
         }

         myCurrentFrameState.emitComponentUpdated();
      }

      virtual void updateStateData(DtStateData* sd) override
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtWeatherStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

      virtual bool forceAdvance() override;

      virtual void firstFrameAdvance() override;

   protected:
      DtWeatherStateComponentCurrentFrame myCurrentFrameState;
      DtWeatherStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   typedef DtStateComponentCreator<DtWeatherStateComponentImplementation> DtWeatherStateComponentCreator;
}