WsfCoverage.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2020 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFCOVERAGECOVERAGE_HPP
#define WSFCOVERAGECOVERAGE_HPP
 
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
#include "UtCalendar.hpp"
#include "UtCallback.hpp"
#include "UtCloneablePtr.hpp"
#include "WsfCoverageAccessInterval.hpp"
#include "WsfCoverageAsset.hpp"
#include "WsfCoverageAssetSpecification.hpp"
#include "WsfCoverageIntervalConstraint.hpp"
#include "WsfCoverageMeasure.hpp"
#include "WsfCoverageRawDataOutput.hpp"
#include "WsfObject.hpp"
#include "WsfScenario.hpp"
class WsfSimulation;
 
#include "wsf_coverage_export.h"
 
namespace wsf
{
namespace coverage
{
 
class Grid;

class WSF_COVERAGE_EXPORT Coverage : public WsfObject
{
public:
   explicit Coverage(const WsfScenario& aScenario)
      : mScenario(aScenario)
   {
      mStartEpoch.SetDate(1900, 1, 1);
      mEndEpoch.SetDate(1900, 1, 1);
   }
   Coverage(const Coverage& aOther) = default;
   ~Coverage() override             = default;
 
   // WsfObject overrides
   Coverage* Clone() const override = 0;
   bool      ProcessInput(UtInput& aInput) override;
 
   // Main coverage methods
   bool Initialize(WsfSimulation& aSimulation);
   bool ResolveAssets(WsfSimulation& aSimulation);
   void CategorizePlatforms(const WsfSimulation& aSimulation);
   void PendingStart(WsfSimulation& aSimulation);
   void Finalize(double aSimTime, const UtCalendar& aSimStartEpoch);
 
   // The observable event signatures
   using AccessIntervalStartCallback    = UtCallbackListN<void(const GridAsset&, const FreeAsset&, double)>;
   using AccessIntervalEndCallback      = UtCallbackListN<void(const GridAsset&, const FreeAsset&, double)>;
   using AccessIntervalCompleteCallback = UtCallbackListN<void(const GridAsset&, const FreeAsset&, const AccessInterval&)>;

   AccessIntervalStartCallback& AccessIntervalStart() { return mIntervalStart; }

   AccessIntervalEndCallback& AccessIntervalEnd() { return mIntervalEnd; }

   AccessIntervalCompleteCallback& AccessIntervalComplete() { return mIntervalComplete; }

   const Grid* GetGrid() const { return mGridPtr; }

   const std::string& GetOutputDir() const { return mOutputDir; }

   bool InCoverageInterval(double aSimTime) const { return mCoverageInterval.Contains(aSimTime); }

   double GetStartTime() const { return mCoverageInterval.GetStart(); }

   double GetEndTime() const { return mCoverageInterval.GetEnd(); }

   const UtCalendar& GetStartEpoch() const { return mStartEpoch; }

   bool IsStartEpochDefined() const { return mStartEpoch.GetYear() > 1900; }

   const UtCalendar& GetEndEpoch() const { return mEndEpoch; }

   bool IsEndEpochDefined() const { return mEndEpoch.GetYear() > 1900; }

   bool IsAsset(const WsfPlatform* aPlatformPtr) const
   {
      return IsFreeAsset(aPlatformPtr) || IsGridAsset(aPlatformPtr);
   }

   bool IsFreeAsset(const WsfPlatform* aPlatformPtr) const
   {
      return aPlatformPtr && aPlatformPtr->IsCategoryMember(mFreeAssetCategory);
   }

   bool IsGridAsset(const WsfPlatform* aPlatformPtr) const
   {
      return aPlatformPtr && aPlatformPtr->IsCategoryMember(mGridAssetCategory);
   }

   bool IsPlatformOfType(const std::string& aPlatformName, const std::string& aPlatformType) const;

   bool IsPlatformDeviceOfType(const std::string& aPlatformName,
                               const std::string& aDeviceName,
                               const std::string& aDeviceType) const;
 
protected:
   void SetGrid(const Grid* aGridPtr) { mGridPtr = aGridPtr; }
 
   void AddIntervalStartToData(const GridAsset& aGridAsset, const FreeAsset& aFreeAsset, double aSimTime);
   void AddIntervalEndToData(const GridAsset& aGridAsset, const FreeAsset& aFreeAsset, double aSimTime);

   const std::string& GetGridAssetCategory() const { return mGridAssetCategory; }

   const std::string& GetFreeAssetCategory() const { return mFreeAssetCategory; }

   std::set<FreeAsset> mFreeAssets{};

   UtCallbackHolder mCallbacks{};
 
private:
   virtual bool InitializeP(WsfSimulation& aSimulation) = 0;

   virtual bool AreNullDevicesAllowed(bool aGridAssetNull,
                                      bool aAllGridAssetsNull,
                                      bool aFreeAssetNull,
                                      bool aAllFreeAssetsNull) const = 0;

   virtual bool VerifyDeviceP(const WsfPlatform& aPlatform, const std::string& aDeviceName) const = 0;

   virtual bool VerifyDeviceAndType(const WsfPlatform& aPlatform,
                                    const std::string& aDeviceName,
                                    const std::string& aDeviceType) const = 0;

   virtual void PendingStartP(WsfSimulation& aSimulation) = 0;
 
   bool FindGrid(const WsfSimulation& aSimulation);
   bool NullDeviceCheck();
   bool InitializeCoverageInterval(const WsfSimulation& aSimulation);
   bool InitializeMeasures();
   bool AssureFilterFileUniqueness() const;
   bool VerifyDevice(const WsfPlatform& aPlatform, const std::string& aDeviceName) const;
   bool ResolvePlatformFreeAsset(const WsfSimulation& aSimulation, const AssetSpecification::Asset& aAsset);
   bool ResolvePlatformTypeFreeAsset(const WsfSimulation& aSimulation, const AssetSpecification::Asset& aAsset);
   bool ResolveCategoryFreeAssets(const WsfSimulation& aSimulation, const AssetSpecification::Asset& aAsset);
   bool ResolveGroupFreeAssets(const WsfSimulation& aSimulation, const AssetSpecification::Asset& aAsset);
   void StartInterval(double aSimTime);
   void CloseAllOpenIntervals(double aSimTime);
   void ProcessInterval(const GridAsset& aGridAsset, const FreeAsset& aFreeAsset, const AccessInterval& aInterval);
   void CategorizeAssets(const WsfSimulation& aSimulation);
   void WriteOverlayData() const;
 
   // Needed to get at the Measure types
   const WsfScenario&   mScenario;
   const WsfSimulation* mSimulationPtr{nullptr};
 
   // Some basic data
   std::string                                      mGridName{};
   AssetSpecification                               mAssetSpecification{};
   std::map<std::string, ut::CloneablePtr<Measure>> mMeasures{};
 
   // Coverage interval - saved as calendar objects, or sim times
   UtCalendar     mStartEpoch{};
   UtCalendar     mEndEpoch{};
   AccessInterval mCoverageInterval{};
 
   // Output related options
   std::string                     mOutputDir{};
   ut::CloneablePtr<RawDataOutput> mRawData{nullptr};
   std::string                     mOverlayOutputFileName{};
 
   // reference to the grid
   const Grid* mGridPtr{nullptr};
   std::string mGridAssetCategory{};
   std::string mFreeAssetCategory{};
 
   // Interval events to which Measures can subscribe
   AccessIntervalStartCallback    mIntervalStart{};
   AccessIntervalEndCallback      mIntervalEnd{};
   AccessIntervalCompleteCallback mIntervalComplete{};
 
   // The intervals as they are built.
   std::map<GridAsset, std::map<FreeAsset, AccessInterval>> mData{};
 
   // Constraints
   std::vector<IntervalConstraint> mConstraints{};
 
   bool mFinalized{false};
};
 
} // namespace coverage
} // namespace wsf
 
#endif // WSFCOVERAGECOVERAGE_HPP