StateKeplerian.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstCore/State.hpp"
#include "AstCore/OrbitElement.hpp"
#include "AstCore/TimePoint.hpp"
 
AST_NAMESPACE_BEGIN
 
class StateKeplerian;
using PStateKeplerian = StateKeplerian*;
using HStateKeplerian = SharedPtr<StateKeplerian>;
 
 
enum class ESizeType
{
    eSMA,                   
    eApoAlt,                
    eApoRad,                
    ePeriAlt,               
    ePeriRad,               
    ePeriod,                
    eMeanMotion,            
};
 
enum class EShapeType
{
    eEcc,                   
    eApoAlt,                
    eApoRad,                
    ePeriAlt,               
    ePeriRad,               
};
 
enum class EOrientationType
{
    eRAAN,                  
    eLAN,                   
};
 
enum class EPositionType
{
    eTrueAnomaly,               
    eMeanAnomaly,               
    eEccAnomaly,                
    eArgLat,                    
    eTimePastPeri,              
    eTimePastAscNode,           
    eTimeOfPeriPassage,         
    eTimeOfAscNodePassage,      
};
 
 
 
 
class AST_CORE_API StateKeplerian final: public State
{
public:
    AST_OBJECT(StateKeplerian)
    AST_PROPERT(SMA)
    AST_PROPERT(Period)
    AST_PROPERT(MeanMotion)
    AST_PROPERT(ApoRadForSize)
    AST_PROPERT(ApoAltForSize)
    AST_PROPERT(PeriRadForSize)
    AST_PROPERT(PeriAltForSize)
    AST_PROPERT(Ecc)
    AST_PROPERT(ApoRadForShape)
    AST_PROPERT(ApoAltForShape)
    AST_PROPERT(PeriRadForShape)
    AST_PROPERT(PeriAltForShape)
    AST_PROPERT(Inc)
    AST_PROPERT(RAAN)
    AST_PROPERT(LAN)
    AST_PROPERT(ArgPeri)
    AST_PROPERT(TrueAnomaly)
    AST_PROPERT(MeanAnomaly)
    AST_PROPERT(EccAnomaly)
    AST_PROPERT(ArgLat)
    AST_PROPERT(TimePastPeri)
    AST_PROPERT(TimePastAscNode)
    
    static PStateKeplerian New();
    static HStateKeplerian MakeShared();
    static PStateKeplerian New(const ModOrbElem& modOrbElem);
    static HStateKeplerian MakeShared(const ModOrbElem& modOrbElem);
    static PStateKeplerian NewDefault();
 
    StateKeplerian();
    StateKeplerian(const ModOrbElem& modOrbElem);
    StateKeplerian(const State& state);
    ~StateKeplerian() override = default;
public:
    EStateType getStateType() const override { return EStateType::eKeplerian; }
    errc_t getState(CartState& state) const override;
    errc_t setState(const CartState& state) override;
public:
    void setState(OrbElem& orbElem);
    void getState(OrbElem& orbElem) const;
    errc_t setState(const ModOrbElem& modOrbElem) override { modOrbElem_ = modOrbElem; return eNoError; }
    errc_t getState(ModOrbElem& modOrbElem) const override { modOrbElem = modOrbElem_; return eNoError; }
public:
    void getInnerRepresentationState(array6d& stateInRepresentation) const;
    void getStateInRepresentation(
        ESizeType sizeType, EShapeType shapeType, 
        EOrientationType orientationType, EPositionType positionType,
        array6d& stateInRepresentation
    ) const;
    double getStateParam(int index);
    void setStateParam(int index, double value);
    double getSizeParam() const;
    double getSizeParam(ESizeType sizeType) const;
    void setSizeParam(double sizeParam, ESizeType sizeType);
    void setSizeParam(double sizeParam);
    void setSizeType(ESizeType sizeType);
    double getShapeParam() const;
    double getShapeParam(EShapeType shapeType) const;
    void setShapeParam(double shapeParam, EShapeType shapeType);
    void setShapeParam(double shapeParam);
    void setShapeType(EShapeType shapeType);
    double getOrientationParam() const;
    double getOrientationParam(EOrientationType orientationType) const;
    void setOrientationParam(double orientationParam, EOrientationType orientationType);
    void setOrientationParam(double orientationParam);
    void setOrientationType(EOrientationType orientationType);
    double getPositionParam() const;
    double getPositionParam(EPositionType positionType) const;
    void setPositionParam(double positionParam, EPositionType positionType);
    void setPositionParam(double positionParam);
    void setPositionType(EPositionType positionType);
public:
    double getApoAlt() const;
 
    double getApoRad() const;
 
    double getPeriAlt() const;
 
    double getPeriRad() const;
 
    ESizeType getSizeType() const{return sizeType_;}
    
    EShapeType getShapeType() const{return shapeType_;}
 
    EOrientationType getOrientationType() const{return orientationType_;}
 
    EPositionType getPositionType() const{return positionType_;}
PROPERTIES:
    length_d getSMA() const;
    void setSMA(length_d sma);
 
    time_d getPeriod() const;
    void setPeriod(time_d period);
 
    angvel_d getMeanMotion() const;
    void setMeanMotion(angvel_d meanMotion);
 
    length_d getApoRadForSize() const{return getApoRad();}
    void setApoRadForSize(length_d apoRad);
 
    length_d getApoAltForSize() const{return getApoAlt();}
    void setApoAltForSize(length_d apoAlt);
 
    length_d getPeriRadForSize() const{return getPeriRad();}
    void setPeriRadForSize(length_d periRad);
 
    length_d getPeriAltForSize() const{return getPeriAlt();}
    void setPeriAltForSize(length_d periAlt);
 
    double getEcc() const;
    void setEcc(double ecc);
 
    length_d getApoRadForShape() const{return getApoRad();}
    void setApoRadForShape(length_d apoRad);
 
    length_d getApoAltForShape() const{return getApoAlt();}
    void setApoAltForShape(length_d apoAlt);
 
    length_d getPeriRadForShape() const{return getPeriRad();}
    void setPeriRadForShape(length_d periRad);
    
    length_d getPeriAltForShape() const{return getPeriAlt();}
    void setPeriAltForShape(length_d periAlt);
 
    angle_d getInc() const;
    void setInc(angle_d inc);
 
    angle_d getRAAN() const;
    void setRAAN(angle_d raan);
 
    angle_d getLAN() const;
    void setLAN(angle_d lan);
 
    angle_d getArgPeri() const;
    void setArgPeri(double argPeri);
 
    angle_d getTrueAnomaly() const;
    void setTrueAnomaly(angle_d trueAnomaly);
 
    angle_d getMeanAnomaly() const;
    void setMeanAnomaly(angle_d meanAnomaly);
 
    angle_d getEccAnomaly() const;
    void setEccAnomaly(angle_d eccAnomaly);
 
    angle_d getArgLat() const;
    void setArgLat(angle_d argLat);
 
    time_d getTimePastPeri() const;
    void setTimePastPeri(time_d timePastPeri);
 
    time_d getTimePastAscNode() const;
    void setTimePastAscNode(time_d timePastAscNode);
 
public:
    void getTimeOfPeriPassage(TimePoint& tp) const;
    TimePoint getTimeOfPeriPassage() const;
    void setTimeOfPeriPassage(const TimePoint& tp);
    void setTimeOfPeriPassage(double epochsecond);
 
    void getTimeOfAscNodePassage(TimePoint& tp) const;
    TimePoint getTimeOfAscNodePassage() const;
    void setTimeOfAscNodePassage(const TimePoint& tp);
    void setTimeOfAscNodePassage(double epochsecond);
private:
    void changeEccHoldingOthers(double ecc, const ModOrbElem& originalElem);
    void changePeriRadHoldingOthers(double periRad, const ModOrbElem& originalElem);
    void changeArgPeriHoldingOthers(double argPeri, const ModOrbElem& originalElem);
private:
    void holdLAN(const ModOrbElem& originalElem);
    void holdMeanAnomaly(const ModOrbElem& originalElem);
    void holdEccAnomaly(const ModOrbElem& originalElem);
    void holdArgLat(const ModOrbElem& originalElem);
    void holdTimePastAscNode(const ModOrbElem& originalElem);
    void holdTimePastPeri(const ModOrbElem& originalElem);
protected:
    ModOrbElem modOrbElem_{};                                       
    ESizeType  sizeType_{ESizeType::eSMA};                          
    EShapeType shapeType_{EShapeType::eEcc};                        
    EOrientationType orientationType_{EOrientationType::eRAAN};     
    EPositionType positionType_{EPositionType::eTrueAnomaly};       
};
 
AST_NAMESPACE_END