WsfCoverageNumberOfGaps.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 WSFCOVERAGENUMBEROFGAPS_HPP
#define WSFCOVERAGENUMBEROFGAPS_HPP
 
#include "wsf_coverage_export.h"
 
#include <map>
#include <vector>
 
#include "WsfCoverageAccessInterval.hpp"
#include "WsfCoverageAsset.hpp"
#include "WsfCoverageMeasure.hpp"
 
namespace wsf
{
namespace coverage
{

class WSF_COVERAGE_EXPORT NumberOfGaps : public Measure
{
public:
   explicit NumberOfGaps(const WsfScenario& aScenario)
      : Measure{aScenario}
   {
      SetType(cTYPE);
   }
   NumberOfGaps(const NumberOfGaps& aOther) = default;
   ~NumberOfGaps() override                 = default;
 
   // Measure overrides
 
   NumberOfGaps* Clone() const override { return new NumberOfGaps{*this}; }
 
   bool ProcessInput(UtInput& aInput) override;
 
   double GetDefaultValue() const override;

   double GetMeasuredValue(const GridAsset& aGridAsset) const override;
 
   void CollectionStarting(Coverage& aCoverage, double aSimTime) override;

   std::string GetValueHeader() const override;
 
   constexpr static const char* cTYPE{"WSF_NUMBER_OF_GAPS_MOE"};

   enum class SubType
   {
      cTOTAL,
      cIN_SPAN,
      cMINIMUM_PER_TIME,
      cMAXIMUM_PER_TIME,
      cMEAN_PER_TIME,
      cIN_SPAN_PER_TIME,
      cUNKNOWN
   };
 
   SubType GetSubType() const { return mSubType; }

   double GetSampleSpan() const { return mSampleSpan; }

   double GetMinParameter() const { return mMinParameter; }

   double GetMaxParameter() const { return mMaxParameter; }
 
private:
   bool InitializeP(Coverage& aCoverage) override;
   void CollectionCompletingP(Coverage& aCoverage, double aSimTime) override;
 
   double ComputeValue(std::vector<AccessInterval>& aGaps) const;
 
   double ComputeTotal(const std::vector<AccessInterval>& aGaps) const;
 
   double ComputeInSpan(const std::vector<AccessInterval>& aGaps) const;
 
   double ComputeMax(const std::vector<AccessInterval>& aGaps) const;
 
   double ComputeMin(const std::vector<AccessInterval>& aGaps) const;
 
   double ComputeMean(const std::vector<AccessInterval>& aGaps) const;
 
   double ComputeSpanPerTime(const std::vector<AccessInterval>& aGaps) const;
 
   void ComputeSampleCount(const std::vector<AccessInterval>& aGaps, std::vector<int>& aSamples) const;
 
   void OnAccessIntervalComplete(const GridAsset& aGridAsset, const FreeAsset& aFreeAsset, const AccessInterval& aInterval);
 
   static SubType GetSubtypeFromIdentifier(const std::string& aIdentifier);

   static int SubtypeHasParameter(SubType aSubType);

   std::map<GridAsset, std::vector<AccessInterval>> mIntervals{};

   std::map<GridAsset, double> mData{};

   UtCalendar mStartEpoch{};

   AccessInterval mCoverageInterval{};

   SubType mSubType{SubType::cUNKNOWN};

   double mSampleSpan{UtCalendar::cSEC_IN_DAY};

   double mMinParameter{-1.0};

   double mMaxParameter{-1.0};
};
 
} // namespace coverage
} // namespace wsf
 
#endif // WSFCOVERAGENUMBEROFGAPS_HPP