GravityField.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstMath/LowerMatrix.hpp"
#include "AstUtil/StringView.hpp"
#include <string>
 
AST_NAMESPACE_BEGIN
 
class GravityField;
class BKVParser;
 
void aGravityFieldNormalize(GravityField& gf);
 
void aGravityFieldUnnormalize(GravityField& gf);
 
class AST_CORE_API GravityFieldHead
{
public:
    errc_t load(StringView filepath, StringView dirpath=StringView());
    double getGM() const { return gm_; }
protected:
    int maxDegree_{0};                      
    int maxOrder_{0};                       
    std::string centralBody_;               
    std::string model_;                     
    double gm_{0};                          
    double refDistance_{0};                 
    bool normalized_{false};                
    bool includesPermTide_{false};          
};
 
 
class AST_CORE_API GravityField: protected GravityFieldHead
{
public:
    GravityField();
    ~GravityField() = default;
 
    using GravityFieldHead::maxDegree_;
    using GravityFieldHead::maxOrder_;
    using GravityFieldHead::centralBody_;
    using GravityFieldHead::model_;
    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_; }
    
    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;
 
    errc_t load(StringView model, StringView dirpath=StringView{});
 
    errc_t load(StringView model, int maxLoadDegree, int maxLoadOrder, StringView dirpath=StringView{});
    
    void normalize();
 
    void unnormalize() ;
 
    GravityField normalized() const;
 
    GravityField unnormalized() const;
    
public:
    double& snm(int n, int m);
    double& cnm(int n, int m);
    void initCoeffMatrices();
protected:
    
    LowerMatrixd sinCoeff_;         
    LowerMatrixd cosCoeff_;         
};
 
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