GravityField.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstMath/LowerMatrix.hpp"
#include "AstUtil/StringView.hpp"
#include "AstCore/TimePoint.hpp"
#include <string>
#include <vector>
 
AST_NAMESPACE_BEGIN
 
class GravityField;
class BKVParser;
 
AST_CORE_CAPI void aGravityFieldNormalize(GravityField& gf);
 
AST_CORE_CAPI void aGravityFieldUnnormalize(GravityField& gf);
 
class AST_CORE_API GravityFieldHead
{
public:
    errc_t load(StringView filepath, StringView dirpath=StringView());
    
    double getGM() const { return gm_; }
 
    const std::string& referenceFrame() const { return referenceFrame_; }
protected:
    int maxDegree_{0};                      
    int maxOrder_{0};                       
    std::string centralBody_{};              
    std::string model_{};                    
    std::string referenceFrame_{};           
    double gm_{0};                          
    double refDistance_{0};                 
    bool normalized_{false};                
    bool includesPermTide_{false};          
};
 
class GravityFieldSecularVariations
{
public:
    struct Variation
    {
        bool isSin_{false};                
        int degree_{0};                    
        int order_{0};                     
        double linearRate_{0};             
        double originalCoefficient_{0};    
    };
public:
    bool normalized_{false};                 
    TimePoint referenceEpoch_{};             
    std::vector<Variation> variations_{};     
};
 
class AST_CORE_API GravityField: protected GravityFieldHead
{
public:
    using SecularVariations = GravityFieldSecularVariations;
    GravityField();
    ~GravityField() = default;
 
    using GravityFieldHead::referenceFrame;
    
    using GravityFieldHead::maxDegree_;
    using GravityFieldHead::maxOrder_;
    using GravityFieldHead::centralBody_;
    using GravityFieldHead::model_;
    using GravityFieldHead::referenceFrame_;
    using GravityFieldHead::gm_;
    using GravityFieldHead::refDistance_;
    using GravityFieldHead::normalized_;
    using GravityFieldHead::includesPermTide_;
 
 
    const GravityFieldHead& getHead() const { return *this; }
 
    const std::string& getModelName() const { return model_; }
    void setModelName(StringView model) { model_ = std::string(model); }
    
    const std::string& getCentralBodyName() const { return centralBody_; }
 
    int getMaxDegree() const { return maxDegree_; }
    int getMaxOrder() const { return maxOrder_; }
 
    bool isValidDegreeOrder(int degree, int order) const;
    
    double getGM() const { return gm_; }
 
    double getRefDistance() const { return refDistance_; }
 
    bool isNormalized() const { return normalized_; }
    
    bool isIncludesPermTide() const { return includesPermTide_; }
 
    void applyPermanentTideC20Correction(double k20);
 
    double getSnm(int n, int m) const;
    
    double getCnm(int n, int m) const;
    
    double getSnmNormalized(int n, int m) const;
    double getCnmNormalized(int n, int m) const;
    double getSnmUnnormalized(int n, int m) const;
    double getCnmUnnormalized(int n, int m) const;
 
    double getJn(int n) const;
 
#ifndef SWIG // 还没解决好swig封装StringView的问题，暂时屏蔽
 
    errc_t load(StringView model, StringView dirpath=StringView{});
 
    errc_t load(StringView model, int maxLoadDegree, int maxLoadOrder, StringView dirpath=StringView{});
    
#endif
 
    void normalize();
 
    void unnormalize() ;
 
    GravityField normalized() const;
 
    GravityField unnormalized() const;
 
    void updateVariations(const TimePoint& epoch);
    
    SecularVariations& secularVariations() { return secularVariations_; }
public:
    double& snm(int n, int m);
    double& cnm(int n, int m);
    void initCoeffMatrices();
protected:
    LowerMatrixd sinCoeff_{};                
    LowerMatrixd cosCoeff_{};                
    SecularVariations secularVariations_{};  
};
 
inline double &GravityField::snm(int n, int m)
{
    return sinCoeff_(n, m);
}
 
inline double &GravityField::cnm(int n, int m)
{
    return cosCoeff_(n, m);
}
 
inline bool GravityField::isValidDegreeOrder(int degree, int order) const
{
    return degree <= this->getMaxDegree() && order <= this->getMaxOrder() 
            && degree >= order && order >= 0 && degree >= 0;
}
 
inline double GravityField::getSnm(int n, int m) const
{
    if(A_LIKELY(isValidDegreeOrder(n, m)))
        return sinCoeff_(n, m);
    return 0;
}
 
inline double GravityField::getCnm(int n, int m) const
{
    if(A_LIKELY(isValidDegreeOrder(n, m)))
        return cosCoeff_(n, m);
    return 0;
}
 
 
AST_NAMESPACE_END