WsfConstellationMaker.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 WSFCONSTELLATIONMAKER_HPP
#define WSFCONSTELLATIONMAKER_HPP
 
#include <memory>
 
class UtCalendar;
#include "UtPath.hpp"
class UtScript;
#include "UtUnitTypes.hpp"
 
class WsfConstellation;
#include "WsfConstellationOptions.hpp"
class WsfPlatform;
class WsfScriptContext;
class WsfSimulation;

class WsfConstellationMaker
{
public:
   static std::unique_ptr<WsfConstellationMaker> CreateWalkerDelta(unsigned int aNumTotalSats,
                                                                   unsigned int aNumPlanes,
                                                                   unsigned int aWalkerF);
   static std::unique_ptr<WsfConstellationMaker> CreateWalkerStar(unsigned int aNumTotalSats,
                                                                  unsigned int aNumPlanes,
                                                                  unsigned int aWalkerF);
   static std::unique_ptr<WsfConstellationMaker> CreateGeneral(unsigned int aNumPlanes,
                                                               unsigned int aNumSatsPerPlane,
                                                               UtAngleValue aAnomalyAlias,
                                                               UtAngleValue aRAAN_Range);
 
   void              WriteToFile() const;
   WsfConstellation* Create(double            aCreationTime,
                            WsfSimulation&    aSimulation,
                            WsfScriptContext& aContext,
                            UtScript*         aFilterScriptPtr,
                            UtScript*         aSetupScriptPtr) const;
   bool              DetectConjunction() const;

   bool IsSetup() const { return mOptions.IsSetup(); }

   std::string Validate() const { return mOptions.ValidateSetup(); }

   bool IsWalkerDelta() const { return mOptions.IsWalkerDelta(); }

   bool IsWalkerStar() const { return mOptions.IsWalkerStar(); }

   bool IsGeneral() const { return mOptions.IsGeneral(); }

   unsigned int GetNumTotalSats() const { return mOptions.GetTotalSats(); }

   unsigned int GetNumPlanes() const { return mOptions.GetNumPlanes(); }

   unsigned int GetSatsPerPlane() const { return mOptions.GetSatsPerPlane(); }
 
   // Return the Walker inter-plane phasing parameter angle of constellations produced by this object.
   unsigned int GetWalkerF() const { return mOptions.GetWalkerF(); }

   const UtAngleValue& GetAnomalyAlias() const { return mOptions.GetAnomalyAlias(); }

   const UtAngleValue& GetRAAN_Range() const { return mOptions.GetRAAN_Range(); }

   const UtLengthValue& GetSemiMajorAxis() const { return mOptions.GetSemiMajorAxis(); }

   const UtLengthValue& GetCircularAltitude() const { return mOptions.GetCircularAltitude(); }

   const UtTimeValue& GetOrbitalPeriod() const { return mOptions.GetOrbitalPeriod(); }

   double GetRevolutionsPerDay() const { return mOptions.GetRevolutionsPerDay(); }

   const UtAngleValue& GetInclination() const { return mOptions.GetInclination(); }

   const UtAngleValue& GetInitialRAAN() const { return mOptions.GetInitialRAAN(); }

   const UtAngleValue& GetInitialAnomaly() const { return mOptions.GetInitialAnomaly(); }

   const std::string& GetConstellationName() const { return mOptions.GetConstellationName(); }

   const std::string& GetPlatformType() const { return mOptions.GetPlatformType(); }

   const UtPath& GetBasePath() const { return mOptions.GetBasePath(); }

   void SetSemiMajorAxis(const UtLengthValue& aSemiMajorAxis) { mOptions.SetSemiMajorAxis(aSemiMajorAxis); }

   void SetCircularAltitude(const UtLengthValue& aCircularAltitude) { mOptions.SetCircularAltitude(aCircularAltitude); }

   void SetOrbitalPeriod(const UtTimeValue& aOrbitalPeriod) { mOptions.SetOrbitalPeriod(aOrbitalPeriod); }

   void SetRevolutionsPerDay(double aRevolutionsPerDay) { mOptions.SetRevolutionsPerDay(aRevolutionsPerDay); }

   void SetInclination(const UtAngleValue& aInclination) { mOptions.SetInclination(aInclination); }

   void SetInitialRAAN(const UtAngleValue& aInitialRAAN) { mOptions.SetInitialRAAN(aInitialRAAN); }

   void SetInitialAnomaly(const UtAngleValue& aInitialAnomaly) { mOptions.SetInitialAnomaly(aInitialAnomaly); }

   void SetConstellationName(const std::string& aName) { mOptions.SetConstellationName(aName); }

   void SetPlatformType(const std::string& aPlatformType) { mOptions.SetPlatformType(aPlatformType); }

   void SetBasePath(const UtPath& aBasePath) { mOptions.SetBasePath(aBasePath); }
 
private:
   explicit WsfConstellationMaker(const WsfConstellationOptions& aOptions)
      : mOptions{aOptions}
   {
   }
 
   std::string GetGeneratedName() const;
   void        CreateContainingFolder() const;
 
   WsfPlatform*      CheckTypeExistence(WsfSimulation& aSimulation) const;
   void              CheckNameCollisions(const WsfSimulation& aSimulation) const;
   bool              FilterMember(WsfScriptContext& aContext,
                                  UtScript*         aFilterScriptPtr,
                                  double            aSimTime,
                                  unsigned int      aPlane,
                                  unsigned int      aSatellite) const;
   WsfConstellation* AddMembersToSimulation(double            aCreationTime,
                                            WsfSimulation&    aSimulation,
                                            WsfScriptContext& aContext,
                                            UtScript*         aFilterScriptPtr,
                                            WsfPlatform*      aPlatformType) const;
   void SetupMemberElements(WsfPlatform* aMemberPtr, unsigned int aPlane, unsigned int aSat, const UtCalendar& aEpoch) const;
   void SetupMembers(WsfScriptContext& aContext,
                     UtScript*         aFilterScriptPtr,
                     double            aSimTime,
                     WsfConstellation* aConstellationPtr) const;
 
   WsfConstellationOptions mOptions;
};
 
#endif // WSFCONSTELLATIONMAKER_HPP