adsbDataManager.h

Go to the documentation of this file.

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

#pragma once


#include <vrfutil/adsbTrack.h>
#include <vrfcore/adsbDataServiceInterface.h>
#include <vrfutil/localVertexList.h>
#include <vrfutil/scriptGeometry.h>
#include <vlpi/entityType.h>

#include <atomic>
#include <tbb/spin_mutex.h> 
#include <tbb/spin_rw_mutex.h>
#include <tbb/task_arena.h>
#include <memory>

#include "vrfobjcore/vrfobjcoreDefines.h"

class DtSimulationServices;
class DtEntityType;
class DtAdsbTrack;
class DtAdsbDataManagerJob;

namespace MAKVRinTerra
{
   class DtFeatureGeometry;
}

using DtPathPointIter = std::map<double, DtAdsb::DtPathPoint>::const_iterator;
using DtTrackTypeMap = std::map<int, DtEntityType>;

class DT_DLL_vrfobjcore DtAdsbDataManager : public DtAdsbDataServiceInterface
{
public:
   typedef std::unordered_map<DtIcaoAddress, DtAdsbTrack*> DtAdsbTrackMap;

   DtAdsbDataManager(DtSimulationServices* simServices);
   
   virtual ~DtAdsbDataManager() override;

   class DtAdsbManagerTrackHandle;
   class DtAdsbManagerPointHandle;
      
   virtual bool init();

   virtual double simTime();

   static void tickCallback(void* usr);

   virtual void tick();

   virtual bool isDataLoading() const override;

   virtual bool isFileLoadError() const override;

   //\copydoc DtAdsbDataServiceInterface::findTracksInArea()
   virtual DtAdsbDataJob::Ptr findTracksInArea(const DtVertexList& areaVertices,
      bool unownedOnly = true) override;

   //\copydoc DtAdsbDataServiceInterface::findTracksInAreaDuringTime()
   virtual DtAdsbDataJob::Ptr findTracksInAreaDuringTime(const DtVertexList & areaVertices,
      double startSimTime, double endSimTime, bool unownedOnly) override;


   //\copydoc DtAdsbDataServiceInterface::trackInfo()
   virtual DtTrackHandlePtr trackHandleForAddress(DtIcaoAddress trackId) const override;

   virtual const DtAdsbTrack* trackObject(DtIcaoAddress trackId) const;
   virtual DtAdsbTrack* trackObject(DtIcaoAddress trackId);


   //\copydoc DtAdsbDataServiceInterface::takeOwnershipOfTrack()
   virtual DtAdsbDataJob::Ptr requestOwnershipOfTracks(
      const DtIcaoAddrSet& trackIds, const double lastSimTime) override;

   //\copydoc DtAdsbDataServiceInterface::releaseOwnershipOfTrack()
   virtual DtAdsbDataJob::Ptr releaseOwnershipOfTracks(const DtIcaoAddrSet& trackIds) override;

   //\copydoc DtAdsbDataServiceInterface::adsbTimeFromSimTime()
   virtual double adsbTimeFromSimTime(double simTime) const override;

   //\copydoc DtAdsbDataServiceInterface::stringForEpochTime()
   virtual std::string stringForEpochTime(double t) const override;
   
   //\copydoc DtAdsbDataServiceInterface::simTimeFromAdsbTime()
   virtual double simTimeFromAdsbTime(double adsbTime) const override;

   //\copydoc DtAdsbDataServiceInterface::finalDataSimTime()
   virtual double finalDataSimTime() const override;

   //\copydoc DtAdsbDataServiceInterface::firstPointAfterTime()
   virtual DtPointHandlePtr firstPointAfterTime(
      const DtTrackHandlePtr track, double simTime) const override;

   //\copydoc DtAdsbDataServiceInterface::firstPointAfterTime()
   virtual DtPointHandlePtr firstPointAfterTime(
      const DtAdsbTrack* track, double simTime) const;


   //\copydoc DtAdsbDataServiceInterface::lastPointBeforeTime()
   virtual DtPointHandlePtr lastPointBeforeTime(const DtTrackHandlePtr track, double simTime) const override;

   //\copydoc DtAdsbDataServiceInterface::lastPointBeforeTime()
   virtual DtPointHandlePtr lastPointBeforeTime(
      const DtAdsbTrack* track, double simTime) const;


   virtual void updateSquawkChangedTimestamp(const int icaoAddress, const double& simTime) override;

   //\copydoc DtAdsbDataServiceInterface::clonePoint()
   virtual DtPointHandlePtr clonePoint(const DtPointHandlePtr p) const override;

   //\copydoc DtAdsbDataServiceInterface::getBarometricAltitudeAdjustment()
   virtual double barometricAltitudeAdjustment(const DtVector& localPosition, const double simTime) const override;

   //\copydoc DtAdsbDataServiceInterface::resetData()
   virtual void resetData() override;

   virtual void loadAdsbData(const double startSimTime, const double endSimTime);

   virtual int trackToDebug() const { return myTrackToDebug; }

   virtual void stop();
   virtual bool timeToStop();

protected:

   friend class DtAdsbDataManagerJob;

   virtual void performDataReset();

   virtual void getDataFileName(const int dayOfWeek, const int hourOfDay,
      char* fName);

   virtual void getNextFileDayAndHour(int& day, int& hour);

   virtual void getPreviousFileDayAndHour(int& day, int& hour);

   virtual bool secondTimeGreaterThanFirst(const int day1, const int hour1,
      const int day2, const int hour2);

   virtual void updateSquawkChangedTimestamp(DtAdsbTrack& track, const double simTime);

   enum DtIntervalResult
   {
      Before,
      Inside,
      After
   };
   virtual DtIntervalResult getDayHourForFileContainingTime(const double simTime, int& day, int& hour);

   virtual bool readInfoFile();

   virtual void startAdsbDataLoad(const double startTime, const double endTime);

   virtual void calculateTrackTimeOffset();

   virtual bool readOneDataFile(const int day, const int hour);

private:

   DtAdsbDataManager(const DtAdsbDataManager& orig);
   DtAdsbDataManager& operator=(const DtAdsbDataManager& other);

protected:
   DtAdsbTrackMap myTrackPtrsByIcaoAddress;

   DtIcaoAddrSet myUnusedTracks;

   DtIcaoAddrSet myTracksInUse;

   typedef tbb::spin_mutex QueryQueueMutex;
   mutable QueryQueueMutex myQueryQueueMutex;

   mutable tbb::spin_rw_mutex myAdsbDataMutex;

   typedef std::list<DtAdsbDataJob::Ptr> JobQueue;
   JobQueue myNewDataJobs;
   JobQueue myJobsWaitingForLoad;
   JobQueue myJobsReadyToExecute;

   int myFirstDataFileDayOfWeek;
   int myFirstDataFileHourOfDay;
   int myDataFileTimeInterval;
   DtTime myFirstDataDayStartTime; 
   std::string myBaseFileName;
   int myLastDataFileDayOfWeek;
   int myLastDataFileHourOfDay;

   bool myInfoFileWasRead;

   int myLastLoadedDayOfWeek;
   int myLastLoadedHourOfDay;

   DtSimulationServices* mySimulationServices;
   DtTime myAdsbTimeAtSimTime0;
   DtTime myFirstDataAdsbTime;
   DtTime myFirstDataSimTime;
   DtTime myFinalDataAdsbTime;
   DtTime myFinalDataSimTime;

   DtTime myLatestRequestedTime;
   DtTime myLatestLoadedTime;

   std::atomic<bool> myResetData;
   std::atomic<bool> myLoadInProgress;
   std::atomic<bool> myLoadError;
   std::atomic<bool> myTimeToStop;

   int myTrackToDebug;

   tbb::task_arena myArena;
};