6. Data structures and algorithms

6.1 Observation data and points

The Gama observation data structures are designed to enable adjustment of any combination of possibly correlated observations. At its very early stage Gama was limited to adjustment of uncorrelated observations. Only directions and distances were available and observable’s weight was stored together with the observed value in a single object. A single array of pointers to observation objects was sufficient for handling all observations. So called orientation shifts corresponding to directions measured form a point were stored together with coordinations in point objects.

To enable adjustment of possibly correlated observations (like angles derived from observed directions or already adjusted coordinates from a previous adjustment) Gama has come with the concept of clusters. Cluster is an object with a common variance-covariance matrix and a list of pointers to observation objects (distances, directions, angles, etc.). Weights were removed from observation objects and replaced with a pointer to the cluster to which the observation belong. All clusters are joined in a common object ObservationData; similarly to observations, each cluster contains a pointer to its parent Observation Data object. Orientation shifts were separated from coordinates and are stored in the cluster containing the bunch of directions and thus number of orientations is not limited to one for a point.

This organisation of observational information has proved to be effective. Template classes ObservationData and Cluster are used as base classes both in gama-local and gama-g3

template <typename Observation>
  class ObservationData
  {
  public:    
    ClusterList<Observation>  CL;
    
    ObservationData();
    ObservationData(const ObservationData& cod);
    ~ObservationData();
    
    ObservationData& operator=(const ObservationData& cod);   
    template <typename P> void for_each(const P& p) const;
  };

template <typename Observation>  
  class Cluster 
  {
  public:
    const ObservationData<Observation>*     observation_data;
    ObservationList<Observation>            observation_list;
    typename Observation::CovarianceMatrix  covariance_matrix;  
    
    Cluster(const ObservationData<Observation>* od);
    virtual ~Cluster();
    
    virtual Cluster* clone(const ObservationData<Observation>*) const = 0;
    double stdDev(int i) const;
    int size() const;
    void update();
    int  activeCount() const;
    typename Observation::CovarianceMatrix activeCov() const; 
  };

The following template class PointBase for handling point information is used in gama-g3. The template class PointBase relies internally on std::map container but comes with its own interface (in gama-local std::map was used directly for storing points).

template <typename Point>
  class PointBase
  {
    typedef std::map<typename Point::Name, Point*>  Points;

  public:    
    PointBase();
    PointBase(const PointBase& cod);
    ~PointBase();
    
    PointBase& operator=(const PointBase& cod);
    void put(const Point&);
    void put(Point*);
    Point*       find(const typename Point::Name&);
    const Point* find(const typename Point::Name&) const;
    void erase(const typename Point::Name&);
    void erase();
    
    class const_iterator;
    const_iterator  begin();
    const_iterator  end  ();

    class iterator;
    iterator  begin();
    iterator  end  ();
  };

Template classes ObservationData and PointBase are defined in namespace GNU_gama and are located in the source directory gnu_gama.

6.2 Supported ellipsoids

6.3 Transformation from spatial to geographical coordinates

Spatial coordinates (X, Y, Z) can be easily computed from geographical ellipsoidal coordinates (B, L, H), where B is geographical latitude, L geographical longitude and H is elliposidal height, as

X = (N + H) cos B cos L
Y = (N + H) cos B sin L
Z = (N(1-e^2) + H)sin B

where N = a/sqrt(1 - e^2 sin^2 B) is the radius of curvature in the prime vertical, e^2 = (a^2 - b^2)/a^2 is the first eccentricity for the given rotational ellipsoid (spheroid) with semi-major axis a and semi-minor axis b.

In the case of coordiante transformation from (X, Y, Z) to (B, L, H), the longitude is given by the formula

tan L = Y / X.

Now we can introduce

D = sqrt(X^2 + Y^2),

so that the cartesian system become (D, Z). Coordinates B and H are then usually computed by iteration with some starting value of B_0, for example

tan B_0 = Z/D/(1 - e^2),

tan B = Z/D + N/(N+H) e^2 tan B,   H  = D / cos B = Z / sin B - N(1-e^2)

B. R. Bowring described a closed formula(3) that is more effective and sufficiantly accurate and that is used in GNU Gama.

The centre of curvature C of the spheroid corresponding to P’ is the point

(e^2 a cos^3 u, -e’^2 b sin^3 u)),

where e’^2 = (a^2 - b^2)/b^2 is second eccentricity and u is the parametric latitude of the point P’, (1-e^2)N sin B = b sin u. Therefore

tan B = (Z + e’^2 b sin^3 u) / (D - e^2 a cos^3 u).

This is clearly an iterative solution; but it has been found that this formula is extremely accurate using the single first approximation for u for the tan u = (Z/D)(a/b). Maximum error in earth bound region is 3e-8 of sexagesimal arc seconds (5e-7 millimetres); maximum is 0.0018” (0.1 millimetres) at height H = 2a.

6.4 Class g3::Model

g3::model documentation shall come here ...

namespace GNU_gama {  namespace g3 {

  
  class Model {
  public:
    
    typedef GNU_gama::PointBase<g3::Point>              PointBase;
    typedef GNU_gama::ObservationData<g3::Observation>  ObservationData;
    
    PointBase           *points;
    ObservationData     *obs;
    
    GNU_gama::Ellipsoid  ellipsoid;


    Model();
    ~Model();

    Point* get_point(const Point::Name&);
    void   write_xml(std::ostream& out) const;
    void   pre_linearization();
}}

This document was generated on February 17, 2024 using texi2html 1.82.