Beispiel #1
0
        /// <summary>
        /// Returns the topo-centric (azimuth, elevation, etc.) coordinates for
        /// a target object described by the given ECI coordinates.
        /// </summary>
        /// <param name="eci">The ECI coordinates of the target object.</param>
        /// <returns>The look angle to the target object.</returns>
        public TopoTime GetLookAngle(EciTime eci)
        {
            // Calculate the ECI coordinates for this Site object at the time
             // of interest.
             Julian  date     = eci.Date;
             EciTime eciSite  = GetPosition(date);
             Vector vecRgRate = new Vector(eci.Velocity.X - eciSite.Velocity.X,
                                       eci.Velocity.Y - eciSite.Velocity.Y,
                                       eci.Velocity.Z - eciSite.Velocity.Z);

             double x = eci.Position.X - eciSite.Position.X;
             double y = eci.Position.Y - eciSite.Position.Y;
             double z = eci.Position.Z - eciSite.Position.Z;
             double w = Math.Sqrt(Globals.Sqr(x) + Globals.Sqr(y) + Globals.Sqr(z));

             Vector vecRange = new Vector(x, y, z, w);

             // The site's Local Mean Sidereal Time at the time of interest.
             double theta = date.ToLmst(LongitudeRad);

             double sin_lat   = Math.Sin(LatitudeRad);
             double cos_lat   = Math.Cos(LatitudeRad);
             double sin_theta = Math.Sin(theta);
             double cos_theta = Math.Cos(theta);

             double top_s = sin_lat * cos_theta * vecRange.X +
                        sin_lat * sin_theta * vecRange.Y -
                        cos_lat * vecRange.Z;
             double top_e = -sin_theta * vecRange.X +
                         cos_theta * vecRange.Y;
             double top_z = cos_lat * cos_theta * vecRange.X +
                        cos_lat * sin_theta * vecRange.Y +
                        sin_lat * vecRange.Z;
             double az    = Math.Atan(-top_e / top_s);

             if (top_s > 0.0)
             {
            az += Globals.Pi;
             }

             if (az < 0.0)
             {
            az += 2.0 * Globals.Pi;
             }

             double el   = Math.Asin(top_z / vecRange.W);
             double rate = (vecRange.X * vecRgRate.X +
                        vecRange.Y * vecRgRate.Y +
                        vecRange.Z * vecRgRate.Z) / vecRange.W;

             TopoTime topo = new TopoTime(az,         // azimuth, radians
                                      el,         // elevation, radians
                                      vecRange.W, // range, km
                                      rate,       // rate, km / sec
                                      eci.Date);

            #if WANT_ATMOSPHERIC_CORRECTION
              // Elevation correction for atmospheric refraction.
              // Reference:  Astronomical Algorithms by Jean Meeus, pp. 101-104
              // Note:  Correction is meaningless when apparent elevation is below horizon
              topo.m_El += Globals.ToRadians((1.02 /
                                    Math.Tan(Globals.ToRadians(Globals.ToDegrees(el) + 10.3 /
                                    (Globals.ToDegrees(el) + 5.11)))) / 60.0);
              if (topo.m_El < 0.0)
              {
             topo.m_El = el;    // Reset to true elevation
              }

              if (topo.m_El > (Globals.PI / 2))
              {
             topo.m_El = (Globals.PI / 2);
              }
            #endif
             return topo;
        }
Beispiel #2
0
 /// <summary>
 /// Creates a new instance of the class from ECI-time information.
 /// </summary>
 /// <param name="eci">The ECI-time coordinate pair.</param>
 /// <param name="ellipsoid">The earth ellipsoid model.</param>
 public GeoTime(EciTime eci)
     : base(eci, eci.Date)
 {
     Date = eci.Date;
 }