weatherStateProvider.h

Go to the documentation of this file.

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



#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/simObjectReference.h"
#include <vrfobjparam/illuminationObjectParameters.h>
#include <vrfutil/rwWindLevels.h>

#include <vrfExtObjects/vrfWeatherStateEnums.h>
#include <vrfExtObjects/vrfCloudLayerStateEnums.h>

#include <matrix/vlVector.h>
#include <geometry/chord.h>

class DtSimulationServices;

enum DtVrfTurbulenceLevel : int
{
   DtNoTurbulence = 0,
   DtLightTurbulence,
   DtModeratTurbulence,
   DtHeavyTurbulence,
   DtExtremeTurbulence
};

struct AtmosphericStateSegment
{
public:
   double airPressure() { return myAirPressure; }
   void setAirPressure(double airPressure) { myAirPressure = airPressure; }

   double airTemperature() { return myAirTemperature; }
   void setAirTemperature(double airTemperature) { myAirTemperature = airTemperature; }

   double airPressureAltitude() { return myAirPressureAltitude; }
   void setAirPressureAltitude(double airPressureAltitude) { myAirPressureAltitude = airPressureAltitude; }

   double airTemperatureAltitude() { return myAirTemperatureAltitude; }
   void setAirTemperatureAltitude(double airTemperatureAltitude) { myAirTemperatureAltitude = airTemperatureAltitude; }

   bool airPressureAltitudeIsSeaLevel() { return myAirPressureAltitudeIsSeaLevel; }
   void setAirPressureAltitudeIsSeaLevel(bool seaLevel) { myAirPressureAltitudeIsSeaLevel = seaLevel; }

   bool airTemperatureAltitudeIsSeaLevel() { return myAirTemperatureAltitudeIsSeaLevel; }
   void setAirTemperatureAltitudeIsSeaLevel(bool seaLevel) { myAirTemperatureAltitudeIsSeaLevel = seaLevel; }

   double humidity() { return myHumidity; }
   void setHumidity(double humidity) { myHumidity = humidity; }

   double windDirection() { return myWindDirection; }
   void setWindDirection(double windDirection) { myWindDirection = windDirection; }

   double windSpeed() { return myWindSpeed; }
   void setWindSpeed(double windSpeed) { myWindSpeed = windSpeed; }

   DtVrfTurbulenceLevel airTurbulence() { return myAirTurbulence; }
   void setAirTurbulence(const DtVrfTurbulenceLevel& airTurbulence) { myAirTurbulence = airTurbulence; }

   double airVisibility() { return myAirVisibility; }
   void setAirVisibility(double airVisibility) { myAirVisibility = airVisibility; }

   DtVector localPosition() { return myLocalPosition; }
   void setLocalPosition(const DtVector& localPosition) { myLocalPosition = localPosition; }

private:
   double myAirPressure;
   double myAirTemperature;
   double myAirPressureAltitude;
   double myAirTemperatureAltitude;
   bool myAirPressureAltitudeIsSeaLevel;
   bool myAirTemperatureAltitudeIsSeaLevel;
   double myHumidity;
   double myWindDirection;
   double myWindSpeed;
   DtVrfTurbulenceLevel myAirTurbulence;
   double myAirVisibility;
   DtVector myLocalPosition;
};

struct CloudStateSegment
{
public:
   CloudStateSegment()
   {
      myCloudType = CloudLayerCloudType::DtCloudLayerUndefined;
      myCoverFraction = 0;
      myVisibility = 0;
      myBottomAltitude = 0;
      myTopAltitude = 0;
      myStartPosition = DtVector(0, 0, 0);
      myDistance = 0;
   }

   CloudLayerCloudType cloudType() const { return myCloudType; }
   void setCloudType(const CloudLayerCloudType& cloudType) { myCloudType = cloudType; }

   double coverFraction() const { return myCoverFraction; }
   void setCoverFraction(double coverFraction) { myCoverFraction = coverFraction; }

   double visibility() const { return myVisibility; }
   void setVisibility(double visibility) { myVisibility = visibility; }

   double bottomAltitude() const { return myBottomAltitude; }
   void setBottomAltitude(double bottomAltitude) { myBottomAltitude = bottomAltitude; }

   double topAltitude() const { return myTopAltitude; }
   void setTopAltitude(double topAltitude) { myTopAltitude = topAltitude; }

   DtVector startPosition() const { return myStartPosition; }
   void setStartPosition(const DtVector& startPosition) { myStartPosition = startPosition; }

   double distance() const { return myDistance; }
   void setDistance(double distance) { myDistance = distance; }

private:
   CloudLayerCloudType myCloudType;
   double myCoverFraction; 
   double myVisibility; 
   double myBottomAltitude; 
   double myTopAltitude; 
   DtVector myStartPosition;
   double myDistance;
};

struct PrecipitationStateSegment
{
public:
   PrecipitationStateSegment()
   {
      myPrecipitationType = DtVrfWeatherPrecipitationType::DtVrfWeatherPrecipitationNone;
      myPrecipitationIntensity = 0;
      myStartPosition = DtVector(0, 0, 0);
      myDistance = 0;
   }

   DtVrfWeatherPrecipitationType precipitationType() { return myPrecipitationType; }
   void setPrecipitationType(const DtVrfWeatherPrecipitationType& precipitationType) { myPrecipitationType = precipitationType; }

   double precipitationIntensity() { return myPrecipitationIntensity; }
   void setPrecipitationIntensity(double precipitationIntensity) { myPrecipitationIntensity = precipitationIntensity; }

   DtVector startPosition() { return myStartPosition; }
   void setStartPosition(const DtVector& startPosition) { myStartPosition = startPosition; }

   double distance() { return myDistance; }
   void setDistance(double distance) { myDistance = distance; }

private:
   DtVrfWeatherPrecipitationType myPrecipitationType;
   double myPrecipitationIntensity;
   DtVector myStartPosition;
   double myDistance;
};

class DT_DLL_vrfobjcore DtWeatherStateProvider
{
private:

   DtWeatherStateProvider(const DtWeatherStateProvider & orig);
   const DtWeatherStateProvider & operator=(const DtWeatherStateProvider &
      orig);
   DtWeatherStateProvider();

public:

   DtWeatherStateProvider(const DtSimulationServices* simManager);

   virtual ~DtWeatherStateProvider();

   virtual bool init();

   virtual void tick();

   virtual const DtSimulationServices* simManager() const;

   static DtWeatherStateProvider* creator(const DtSimulationServices* simMgr);

   
   virtual std::vector<CloudStateSegment> cloudLayers(
      const DtVector& localPosition) const;

   virtual double airVisibility(const DtVector& localPosition) const;

   virtual double visibility(const DtVector& localPosition) const;

   virtual int visibilityObscurant(const DtVector& localPosition) const;

   virtual double averageVisibilityOnChord(const DtChord& path) const;

   virtual double airTemperatureAtAltitude(const double mslTemperature,
      const double altitude) const;

   virtual double airTemperature(const DtVector& localPosition) const;

   virtual double mslTemperatureFromAirTemperatureAtAltitude(const double airTemperature,
      const double altitude) const;

   virtual double airPressureAtAltitude(const double mslPressure,
      const double altitude, const double mslTemperature) const;

   virtual double airPressure(const DtVector& localPosition) const;

   virtual double mslPressureFromAirPressureAtAltitude(const double airPressure,
      const double altitude, const double mslTemperature) const;

   virtual double airTemperatureAltitude(const DtVector& localPosition) const;

   virtual double airPressureAltitude(const DtVector& localPosition) const;

   virtual double humidity(const DtVector& localPosition) const;

   virtual double relativeHumidity(const DtVector& localPosition) const;

   virtual double windSpeed(const DtVector& localPosition) const; 
   virtual double windDirection(const DtVector& localPosition) const; 

   virtual bool windSpeedAndDirectionAtAltitude(const DtVector& localPosition, double altMSL, double& windSpeed, double& windDiection) const; 

   virtual bool visibilityAndObscurantAtAltitude(const DtVector& localPosition, double altMSL, double& visibility, int& obscurant) const; 

   virtual DtRwWindLevels windLevels(const DtVector& localPosition) const;

   virtual DtVrfTurbulenceLevel airTurbulence(const DtVector& localPosition) const;

   virtual void lineQueryAtmosphericState(const DtVector& startPosition,
                                          const DtVector& endPosition,
                                          double minSegmentLength,
                                          size_t maxSegmentCount,
                                          std::vector<AtmosphericStateSegment>& atmosphericStateSegments) const;

   virtual void lineQueryCloudState(const DtVector& startPosition,
                                    const DtVector& endPosition,
                                    std::vector<CloudStateSegment>& cloudStateSegments,
                                    double tolerance = 5.0) const;

   virtual bool lightningPresent(const DtVector& localPosition) const;


   virtual int blowingParticulateMatter(const DtVector& localPosition) const;

   virtual double precipitationIntensity(const DtVector& localPosition) const;
   virtual double averagePrecipitationIntensity(const DtChord&) const;
   virtual DtVrfWeatherPrecipitationType precipitationType(const DtVector& localPosition) const;
   virtual double snowAccumulationDepth(const DtVector& localPosition) const;
   virtual double snowDepthOnRoads(const DtVector& localPosition) const;
   virtual double rainAccumulationDepth(const DtVector& localPosition) const;

   virtual void lineQueryPrecipitationState(const DtVector& startPosition,
                                            const DtVector& endPosition,
                                            std::vector<PrecipitationStateSegment>& precipitationStateSegments, 
                                            double tolerance = 5.0) const;


   virtual double illuminationFromSky(const DtVector& localPosition) const;
   virtual double illuminationAtTime(const DtVector& localPosition,
      const double dateTime) const;


   virtual double underwaterVisibility(const DtVector& localPosition) const;
   virtual double averageWaterVisibilityOnChord(const DtChord& path) const;
   virtual double waterCurrentSpeed(const DtVector& localPosition) const;
   virtual double waterCurrentDirection(const DtVector& localPosition) const; 
   virtual double waterTemperature(const DtVector& localPosition) const;

   virtual double tidalOffset(const DtVector& localPosition) const;
   virtual unsigned int swellState(const DtVector& localPosition) const;
   virtual double swellDirection(const DtVector& localPosition) const; 
   virtual unsigned int seaState(const DtVector& localPosition) const;
   virtual double seaDirection(const DtVector& localPosition) const; 
   virtual double choppiness(const DtVector& localPosition) const;
   virtual double surgeDepth(const DtVector& localPosition) const;
   virtual double depthOffset(const DtVector& localPosition) const;
   virtual double windFetch(const DtVector& localPosition) const;

   virtual double thermoclineLayer1Depth(const DtVector& localPosition) const;
   virtual double thermoclineLayer1Permeability(const DtVector& localPosition) const;
   virtual double thermoclineLayer2Depth(const DtVector& localPosition) const;
   virtual double thermoclineLayer2Permeability(const DtVector& localPosition) const;
   virtual double thermoclineLayer3Depth(const DtVector& localPosition) const;
   virtual double thermoclineLayer3Permeability(const DtVector& localPosition) const;
   virtual double thermoclineLayer4Depth(const DtVector& localPosition) const;
   virtual double thermoclineLayer4Permeability(const DtVector& localPosition) const;
   virtual double thermoclineLayer5Depth(const DtVector& localPosition) const;
   virtual double thermoclineLayer5Permeability(const DtVector& localPosition) const;


   const DtSimulationServices* simulationServices() const { return mySimulationServices; };

protected:

   std::vector<DtChord> segmentsIntersectingPrecipitationAreas(const DtVector& startPosition,
                                                               const DtVector& endPosition,
                                                               const std::vector<DtSimObjectReference>& weatherObjects,
                                                               double tolerance) const;

   void setPrecipitationStateForWeatherObjectsSegments(const std::vector<DtChord>& chordIntersectingSegments,
                                                       const std::vector<DtSimObjectReference>& weatherObjects,
                                                       std::vector<PrecipitationStateSegment>& precipitationStateSegments,
                                                       std::vector<DtChord>& globalWeatherChordIntersectingSegments,
                                                       double tolerance) const;

   void setPrecipitationStateForGlobalWeatherSegments(const DtVector& startPosition,
                                                      const std::vector<DtChord>& globalWeatherChordIntersectingSegments,
                                                      const std::vector<DtSimObjectReference>& weatherObjects,
                                                      std::vector<PrecipitationStateSegment>& precipitationStateSegments,
                                                      double tolerance) const;

   std::vector<DtChord> segmentsIntersectingCloudLayers(const DtVector& startPosition,
                                                        const DtVector& endPosition,
                                                        const std::vector<DtSimObjectReference>& weatherObjects,
                                                        double tolerance) const;

   void setCloudStateForWeatherObjectsSegments(const std::vector<DtChord>& chordIntersectingSegments,
                                               const std::vector<DtSimObjectReference>& weatherObjects,
                                               std::vector<CloudStateSegment>& cloudStateSegments,
                                               std::vector<DtChord>& globalWeatherChordIntersectingSegments,
                                               double tolerance) const;

   void setCloudStateForGlobalWeatherSegments(const DtVector& startPosition,
                                              const std::vector<DtChord>& globalWeatherChordIntersectingSegments,
                                              const std::vector<DtSimObjectReference>& weatherObjects,
                                              std::vector<CloudStateSegment>& cloudStateSegments,
                                              double tolerance) const;

   bool chordIntersectsExtent(const DtChord& chord,
                              const DtExtent& extent,
                              DtPoint& intersectionEntryPoint,
                              DtPoint& intersectionExitPoint,
                              bool& chordPt0InExtent,
                              bool& chordPt1InExtent) const;

protected:

   virtual double defaultCloudVisibility() const;

   const DtSimulationServices* mySimulationServices;


   double myKoschmiederConstant;
};