WsfCoverageGrid.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 WSFCOVERAGEGRID_HPP
#define WSFCOVERAGEGRID_HPP
 
#include <utility>
 
#include "UtCentralBody.hpp"
#include "UtCloneablePtr.hpp"
#include "WsfCoverageAsset.hpp"
#include "WsfCoverageGridAction.hpp"
#include "WsfCoverageGridPoint.hpp"
#include "WsfObject.hpp"
#include "WsfScenario.hpp"
class WsfSimulation;
 
#include "wsf_coverage_export.h"
 
 
namespace wsf
{
namespace coverage
{
 
class TextOutputWriter;

class WSF_COVERAGE_EXPORT Grid : public WsfObject
{
public:
   explicit Grid(const WsfScenario& aScenario);
   Grid(const Grid& aOther) = default;
   ~Grid() override         = default;
 
   // WsfObject overrides
   Grid* Clone() const override = 0;
   bool  ProcessInput(UtInput& aInput) override;
 
   // Grid Interface

   virtual void PreparePlatforms(WsfSimulation& aSimulation) = 0;

   virtual const Point* GetPoint(PointId aPointId) const = 0;

   virtual std::size_t GetSize() const = 0;

   virtual void Invoke(GridAction& aAction) const = 0;

   virtual GridAsset GetAsset(PointId aPointId) const = 0;

   virtual GridAsset GetAsset(const std::string& aPlatformName) const = 0;

   virtual void HasNullDevice(bool& aAnyNull, bool& aAllNull) const = 0;

   virtual bool CreatesNewPlatforms() const = 0;

   virtual bool IsStructured() const { return false; }

   virtual std::size_t GetNumComponents() const { return 1; }

   virtual std::string GetComponentName(std::size_t aComponentIndex) const { return GetName(); }

   virtual std::pair<std::size_t, std::size_t> GetComponentSizes(std::size_t aComponentIndex) const;

   virtual std::pair<std::size_t, std::size_t> GetPointIndices(PointId aPointId) const;

   virtual void InvokeOnComponent(GridAction& aAction, std::size_t aComponentIndex) const { Invoke(aAction); }
 
   void SetUsedFlag() { mUsedFlag = true; }
   bool IsUsed() const { return mUsedFlag; }
 
   bool Initialize();
   void CategorizeAssets(const WsfSimulation& aSimulation, const std::string& aCategory) const;

   bool IsInitialized() const { return mInitialized; }

   const ut::CentralBody& GetCentralBody() const { return *mCentralBodyPtr; }
 
   void SetCentralBody(const ut::CentralBody& aCentralBody);

   const std::string& GetGridDataFileName() const { return mGridDataFileName; }

   bool GetSuppressGridPlatforms() const { return mSuppressGridPlatforms; }

   void SetSuppressGridPlatforms(bool aSuppress) { mSuppressGridPlatforms = aSuppress; }
 
 
   bool WriteGridDataFile(TextOutputWriter& aWriter) const;
   bool WriteGridDataFile() const;
 
protected:
   virtual bool InitializeP() = 0;
 
   PointId            GetNextAvailableId();
   const WsfScenario& GetScenario() const { return mScenario; }
 
private:
   // Private Grid interface
   virtual void WriteHeaderExtension(TextOutputWriter& aWriter) const {}
   virtual void WriteLineExtension(TextOutputWriter& aWriter, PointId aPointId) const {}
 
   const WsfScenario&                mScenario;
   ut::CloneablePtr<ut::CentralBody> mCentralBodyPtr;
   std::string                       mGridDataFileName{};
   PointId                           mNextPointId{cINVALID_POINT_ID};
   bool                              mInitialized{false};
   bool                              mSuppressGridPlatforms{true};
   bool                              mUsedFlag{false};
   // NOTE: The base class does not impose a certain structure to the storage
   //       of the grid points. That is up to the derived classes to work out
   //       what is most convenient.
};
 
} // namespace coverage
} // namespace wsf
 
#endif // WSFCOVERAGEGRID_HPP