Exemple #1
0
  def test_smap(self):

    target = 'SMAP'

    et0 = spice.utc2et( '2016-06-01T12:00:00' )

    dpr = spice.dpr()

    a,b,c = [spice.gdpool('BODY399_RADII',i,1)[1] for i in range(3)]

    ods = []

    for deltatime in [0.1 * i for i in range(1080)]:
      et = et0 + deltatime
      stSmap,lsSmap = spice.spkezr( target, et, 'IAU_EARTH', 'NONE', 'EARTH' )
      posn, veloc = stSmap[:3], stSmap[3:]
      stSun,lsSun = spice.spkezr( 'SUN', et0, 'IAU_EARTH', 'LT', 'EARTH' )
      mtx = spice.pxform( 'SMAP_REFLECTOR', 'IAU_EARTH', et)
      boreEbf = spice.mxv( mtx, [1.0,0,0] )
      point = spice.surfpt( posn, boreEbf, a, b, c)
      rsurfpt,lon,lat = spice.reclat( point )
      utc = spice.et2utc( et, 'ISOC', 3 )

      ods += [ OD(deltatime=deltatime,posn=posn,veloc=veloc,boreEbf=boreEbf
                 ,utc=utc,point=point,rsurfpt=rsurfpt
                 ,rsmap=spice.vnorm(posn),lat=lat,lon=lon 
                 ,raynge=spice.vnorm(spice.vsub(point,posn))
                 ,sunsep=spice.vsep( spice.ucrss(posn,veloc), stSun[:3] )
                 )
             ]

    try:
      ### Moved matplotlib import to here so test runs to here at least
      from matplotlib import pyplot as plt
      plt.figure(1)
      keys = 'lat lon raynge'.split()
      secs = [od['deltatime'] for od in ods]
      for idx in range(len(keys)):
        scal = 1.0 if keys[idx] in 'rsurfpt rsmap raynge sunsep rp ecc t0 mu a P eccmean amean Pmean'.split() else dpr
        ordinate = [od[keys[idx]]*scal for od in ods]
        plt.subplot( 221+idx )
        plt.plot( secs, ordinate )
        plt.plot( secs, ordinate, '.')
        plt.title( keys[idx] )
        plt.ylabel( '%s%s' % (keys[idx],'' if scal==1.0 else ', deg') )
        if idx>1: plt.xlabel( 'T-T0, s' )

      abscissa = [od['lon']*dpr for od in ods]
      ordinate = [od['lat']*dpr for od in ods]
      plt.subplot( 221+idx+1 )
      plt.title( 'lon vs. lat' )
      plt.plot( abscissa, ordinate )
      plt.xlabel( 'lon, deg' )
      plt.ylabel( 'lat, deg' )
      plt.show()

    except:
      print( "Bypassed, or failed, matplotlib tests" )
Exemple #2
0
def transform(fname, metadata=False):
    """
    This function reads a Mission Analysis Orbit file and performs a matrix
    transformation on it. Currently only from the Mercury Equatorial frame to
    the Earth Equatorial frame.

    :param fname: The path to the orbit file.
    :type fname: str.
    :param metadata: Flag to return the metadata dictionary
    :type state: bool.
    :returns:  numpy.array -- the return code.
    """

    furnsh("/Users/jmcaulif/Code/naif/generic/lsk/naif0010.tls")

    logging.basicConfig(level=logging.INFO)

    mdata = {}
    data = {}

    with open(fname, "r") as fh:
        for line in fh:
            t, x, y, z, vx, vy, vz = [float(x) for x in line.split()]

            T = np.array(
                [
                    [0.98159386604468, 0.19098031873327, 0.0],
                    [-0.16775718426422, 0.86223242348167, 0.47792549108063],
                    [0.09127436261733, -0.46912873047114, 0.87840037851502],
                ]
            )

            Tinv = linalg.inv(T)

            r = np.array([[x, y, z]])
            v = np.array([[vx, vy, vz]])

            r_new = Tinv.dot(r.T).T
            v_new = Tinv.dot(v.T).T

            x, y, z = r_new[0]
            vx, vy, vz = v_new[0]

            t = et2utc(t * 86400, "isoc", 2)

            print("{} {:9.2f} {:9.2f} {:9.2f} {:9.6f} {:9.6f} {:9.6f}".format(t, x, y, z, vx, vy, vz))

    fh.close()

    if metadata:
        return data, mdata
    else:
        return data
Exemple #3
0
def mpoplot(userdates, master_scale=15, demo=False):
    """
    ... explain what this does...
    """

    outdir = '../sample_data/output'
    # if demo:
    #     shutil.rmtree(outdir)
    #     os.makedirs(outdir)
    # else:
    #     if not os.path.exists(outdir):
    #         os.makedirs(outdir)
    #     else:
    #         print('\n   Uh-oh! The directory {} already exists.'.format(
    #             outdir))
    #         if yesno('   Do you want to replace it?'):
    #             shutil.rmtree(outdir)
    #             os.makedirs(outdir)
    #         else:
    #             return

    # Clear and load the kernels that this program requires.
    spice.kclear()
    spice.furnsh('epys.mk')

    # A graphic will be created for each 'date' in 'dates':
    for date in userdates:

        et = spice.str2et(date)
        datestr = (spice.et2utc(et, 'ISOC', 0))

        # -- Outer frame -------------------------------------------------

        dist_scl = 250.0

        elts = getorbelts(date)
        arg_peri = elts[4]

        # Opacity of degree frame and Venus graphic
        frame_op = 0.5

        # # Process JD time into calendar time strings
        # datestr = spice.et2utc(et, 'ISOC', 0)
        date = '{} {}'.format(datestr.split('T')[0],
                              datestr.split('T')[1])
        edate, etime = date.split()
        eyear = "{}".format(edate.split('-')[0])
        emonth = "{0:02d}".format(int(edate.split('-')[1]))
        eday = "{0:02d}".format(int(edate.split('-')[2]))
        epoch = "{}/{}/{}".format(eday, emonth, eyear)
        ep_name = "{}{}{}".format(eyear, emonth, eday)

        frame = _outerframe(epoch, frmSize=master_scale, frm_op=frame_op,
                            mpoargp=arg_peri)

        # -- Mercury Planet --------------------------------------------------

        # tru_ano = 90
        # look_from = 270

        # x1 = "{}%".format((100*math.sin(math.radians((tru_ano+90)/2.))))
        # x2 = "{}%".format(100-(100*sin(radians((tru_ano+90)/2.))))

        angs = range(0, 360, 1)

        plt.plot(angs, ["{}".format((100 * math.sin(math.radians(x / 2))))
                        for x in angs], 'yo-')
        plt.plot(angs, ["{}".format(100 - (100 *
                        math.sin(math.radians(x / 2)))) for x in angs], 'ro-')
        # plt.show()

        stop1 = "#C8C5E2"
        # stop2 = "#373163"

        defs = svg.SVG("defs",
                       svg.SVG("linearGradient",
                               svg.SVG("stop", stop_color=stop1,
                                       stop_opacity=1, offset="45%"),
                               svg.SVG("stop", stop_color=stop1,
                                       stop_opacity=1, offset="55%"),
                               x1="0%", y1="0%", x2="100%", y2="0%",
                               spreadMethod="pad",
                               id="mercGrad")
                       )

        # defs = svg.SVG('defs',
        #                svg.SVG('radialGradient',
        #                        svg.SVG('stop',
        #                                stop_color=stop1,
        #                                stop_opacity=1,
        #                                offset='38%'),
        #                        svg.SVG('stop',
        #                                stop_color=stop2,
        #                                stop_opacity=1,
        #                                offset='40%'),
        #                        cx='50%', cy='50%',
        #                        fx='230%', fy='50%',
        #                        r='300%',
        #                        spreadMethod='pad',
        #                        id='mercGrad')
        #                )

        merc_rad = 2439.99  # km
        merc_rad_scl = merc_rad / dist_scl
        merc_ball = svg.Ellipse(0, 0, 0, merc_rad_scl, merc_rad_scl,
                                fill="url(#mercGrad)", stroke_width="0.15pt")

        # -- MPO Orbit --

        mpo_orb_ecc = 0.163229
        mpo_orb_sma = 3394.0  # km
        mpo_orb_sma_scl = mpo_orb_sma / dist_scl
        mpo_orb_smi_scl = mpo_orb_sma_scl * math.sqrt(1 - mpo_orb_ecc ** 2)

        # Make things cleaner
        a = mpo_orb_sma_scl
        b = mpo_orb_smi_scl

        mpo_orb = svg.Ellipse(-math.sqrt(a ** 2 - b ** 2), 0, 0, a, b,
                              fill="none", stroke_width="0.25pt")
        # apof = 8
        mpo_orb_apses = svg.Line(-_rellipse(a, b, 180) - 5, 0,
                                 _rellipse(a, b, 0) + 10, 0,
                                 stroke_width="0.15pt",
                                 stroke_dasharray="2, 2")

        dot_angs = range(0, 360, 20)
        dots = [_orbitdot(a, b, x, color="black") for x in dot_angs]
        mpo_orb_dots = svg.Fig()
        for dot in dots:
            mpo_orb_dots.d.append(dot)

        mpo_orb_trans = svg.rotate(arg_peri, 0, 0)
        mpo_orb_plot = svg.Fig(mpo_orb, mpo_orb_apses, mpo_orb_dots,
                               trans=mpo_orb_trans)

        # -- Direction arrow -------------------------------------------------

        dirarend = svg.make_marker("dirarrowend", "arrow_end",
                                   fill_opacity=0.2)
        dirarend.attr["markerWidth"] = 7.5

        x1, y1 = master_scale + 1, 0.4,
        x2, y2 = master_scale + 1, 1

        dirarwstrt = svg.Line(x1, y1, x2, y2, stroke_width=".4pt",
                              stroke_opacity=0.2, arrow_end=dirarend)

        dirarw = svg.Fig(dirarwstrt, trans="x*cos(y), x*sin(y)")

        # -- Apsis view ------------------------------------------------------

        apvx, apvy = master_scale + 3, -master_scale - 3
        apsisviewball = svg.Ellipse(apvx, apvy,
                                    0, merc_rad_scl * 0.25,
                                    merc_rad_scl * 0.25,
                                    fill="url(#mercGrad)",
                                    stroke_width="0.15pt")

        apsisviewlats = svg.Fig()

        for x in range(-9, 10, 3):

            hscl = math.sin(math.radians(x * 10))
            wscl = math.cos(math.radians(x * 10))

            x1 = apvx - (merc_rad_scl * 0.25 * wscl)
            y1 = apvy + (merc_rad_scl * 0.25 * hscl)
            x2 = apvx + (merc_rad_scl * 0.25 * wscl)
            y2 = apvy + (merc_rad_scl * 0.25 * hscl)

            apsisviewlats.d.append(svg.Line(x1, y1, x2, y2,
                                   stroke_width=".2pt",
                                   stroke_opacity=0.4))

        apvarend = svg.make_marker("apvarrowend",
                                   "arrow_end",
                                   fill_opacity=0.6)
        apvarend.attr["markerWidth"] = 3.0
        apvarend.attr["markerHeight"] = 3.0

        x1, y1 = apvx, apvy - 3
        x2, y2 = apvx, apvy + 3
        apsisvieworbit = svg.Line(x1, y1, x2, y2,
                                  stroke_width=".4pt",
                                  stroke_opacity=0.6,
                                  arrow_end=apvarend)

        xd = apvx
        yd = apvy + (merc_rad_scl * 0.25 * math.sin(math.radians(arg_peri)))
        apsisviewdot = svg.Fig(svg.Dots([(xd, yd)],
                                        svg.make_symbol("apsisdot",
                                                        fill="black",
                                                        fill_opacity=0.6
                                                        ),
                                        0.6, 0.6
                                        )
                               )

        apsisview = svg.Fig(apsisviewball,
                            apsisviewlats,
                            apsisvieworbit,
                            apsisviewdot)

        # -- Build final figure ----------------------------------------------

        wa = master_scale * 1.5
        svgout = svg.Fig(frame,
                         merc_ball,
                         mpo_orb_plot,
                         dirarw,
                         apsisview
                         ).SVG(svg.window(-wa, wa, -wa, wa))

        svgout.prepend(defs)

        argp = int(arg_peri)
        svgout.save(os.path.join(outdir,
                                 "mpo_orbit_plot_{}_{}.svg".format(ep_name,
                                                                   argp)
                                 )
                    )
Exemple #4
0
def planetsplot(userdates=None, delta="1d", master_scale=15, demo=False,
                showplots=False):
    """
    ... explain what this does...
    """

    outdir = './sample_data/output'
    # if demo:
    #     shutil.rmtree(outdir)
    #     os.makedirs(outdir)
    # else:
    #     if not os.path.exists(outdir):
    #         os.makedirs(outdir)
    #     else:
    #         print('\n   Uh-oh! The directory {} already exists.'.format(
    #             outdir))
    #         if yesno('   Do you want to replace it?'):
    #             shutil.rmtree(outdir)
    #             os.makedirs(outdir)
    #         else:
    #             return

    orbitdata = _gatherorbitdata(delta=delta, scale=master_scale)
    ets, dates, orbits, argps, argpxys, nus = orbitdata

    if userdates is None:
        userdates = dates

    if showplots:
        plt.subplot(1, 1, 1)
        for xy in orbits:
            plt.plot([x[0] for x in xy], [y[1] for y in xy],
                     'rx', label='SPICE')
        for xy in argpxys:
            plt.plot(xy[0], xy[1], 'go')
        plt.show()

    if len(orbits[0]) == len(dates) == len(ets):

        # This rotation will put the Hermean perihelion on the X-axis.
        rotang = -argps[0]

        # Load the kernels that this program requires.
        spice.kclear()
        this_dir = os.path.dirname(os.path.realpath(__file__))
        spice.furnsh(os.path.join(this_dir, 'epys.mk'))

        output_files = []

        # A graphic will be created for each 'date' in 'userdates':
        for date in userdates:

            # get the position-index of the 'et' in the 'orbitdata' list
            # of 'ets' that is closest to the 'date' in the 'userdates'
            et = spice.str2et(date)
            dx = ets.index(getclosest(ets, et))

            # -- Outer frame -------------------------------------------------

            # Opacity of degree frame and Venus graphic
            frame_op = 0.8

            # Process calendar time strings
            date = '{} {}'.format(spice.et2utc(et, 'ISOC', 0).split('T')[0],
                                  spice.et2utc(et, 'ISOC', 0).split('T')[1])
            edate, etime = date.split()
            eyear = "{}".format(edate.split('-')[0])
            emonth = "{0:02d}".format(int(edate.split('-')[1]))
            eday = "{0:02d}".format(int(edate.split('-')[2]))
            epoch = "{}/{}/{}".format(eday, emonth, eyear)
            ep_name = "{}{}{}_{}".format(eyear, emonth, eday,
                                         etime.replace(':', ''))

            frame = _outerframe(epoch, frmSize=master_scale, frm_op=frame_op)

            # -- First Point of Aires ----------------------------------------

            # merc_loan = 48.331
            # merc_argp = 29.124
            arend = svg.make_marker("fopa_arrowend", "arrow_end",
                                    fill_opacity=0.4)

            x1, y1 = 10, 0
            x2, y2 = master_scale * 1.3, 0

            fpoa = svg.Line(x1, y1, x2, y2, stroke_width=".4pt",
                            stroke_opacity=0.4, arrow_end=arend)

            xp = (x2 * math.cos(math.radians(rotang)) -
                  y2 * math.sin(math.radians(rotang)))
            yp = (x2 * math.sin(math.radians(rotang)) +
                  y2 * math.cos(math.radians(rotang)))

            fpoa_text = svg.Text(xp + 6.5, yp - 1.0, "First Point of Aries",
                                 font_size=3, opacity=0.75)
            fpoa = svg.Fig(svg.Fig(fpoa, trans=svg.rotate(rotang, 0, 0)),
                           fpoa_text)

            # -- Some containers ---------------------------------------------

            orbs = []
            circles = []
            defs = svg.SVG("defs")

            # -- Orbit circles -----------------------------------------------

            # Build the SVG for each orbit.
            for orbit in orbits:

                if orbits.index(orbit) == 1:
                    orbit_op = 0.4
                else:
                    orbit_op = 1.0

                # Mercury's orbit will have perihelion on the X-axis
                circles.append(svg.Fig(svg.Poly(orbit, stroke_width=".25pt",
                                                stroke_opacity=orbit_op),
                                       trans=svg.rotate(rotang, 0, 0)))

            # -- Planet orbs -------------------------------------------------

            points = [orbits[0][dx], orbits[1][dx], orbits[2][dx]]

            # Build the planet orb for each planet for this chart.
            for point in points:

                # Planetary inputs ...
                if points.index(point) == 0:
                    name = "MERCURY"
                    nu = math.degrees(math.atan2(point[1], point[0])) + rotang
                    if nu < 0:
                        nu = nu + 360
                    # print(nu, nu-rotang, rotang)
                    nu = "{0:03d}".format(int(nu))
                if points.index(point) == 1:
                    name = "VENUS"
                if points.index(point) == 2:
                    name = "EARTH"

                # point_r  = [x/AU for x in point]

                orb, grad = _planetdiag(name, point, rotang)

                orbs.append(orb)
                defs.append(grad)

            # -- Build final figure ------------------------------------------

            wa = master_scale * 1.5
            svgout = svg.Fig(fpoa, frame,
                             circles[0], circles[1], circles[2],
                             orbs[0], orbs[1], orbs[2]
                             ).SVG(svg.window(-wa, wa, -wa, wa))

            svgout.prepend(defs)
            out_path = os.path.join(outdir,
                                    "merc_orbit_plot_{}_{}.svg".format(
                                        ep_name, nu))
            svgout.save(out_path)
            output_files.append(out_path)

        spice.kclear()

        return output_files

    else:
        # You'll jump to hear if the epochs for all 3 planets are not equal.
        print("There is an epoch error between the planet time values...")
Exemple #5
0
def _gatherorbitdata(delta="1d", scale=15, verbose=False):

    # print("Building orbit for planets with SPICE...")

    spice.kclear()

    # Load the kernels that this program requires.
    this_dir = os.path.dirname(os.path.realpath(__file__))
    spice.furnsh(os.path.join(this_dir, 'epys.mk'))

    # convert starting epoch to ET
    et0 = spice.str2et('2024/05/07 00:00')
    rate = 24 * 2  # Every 30 mins
    days = [(et0 + (day * (86400 / rate))) for day in range(366 * rate)]

    # internal variables and constants
    planets = ("MERCURY", "VENUS", "EARTH")
    AU = consts.AU / 1000.  # AU [km]
    argps = []
    argpxys = []
    xyvecs = []
    nuvecs = []

    for planet in planets:

        # print("     > {}".format(planet))

        dates = []
        rvec = []   # vector of centric radii
        xyvec = []  # vector of (x,y) coordinates
        nuvec = []  # vector of nu (True Anomaly) values
        incvec = []  # vector of inclination values

        for et in days:

            if verbose:
                print('ET Seconds Past J2000: {}'.format(et))

            # Compute the apparent state of MERCURY as seen from
            # the SUN in ECLIPJ2000
            starg, ltime = spice.spkezr(planet, et, 'ECLIPJ2000',
                                        'NONE', 'SUN')

            x, y, z, vx, vy, vz = [el / AU * scale for el in starg]
            r = math.sqrt(x ** 2 + y ** 2 + z ** 2)

            if verbose:
                print('\nApparent state of MERCURY as seen from',
                      ' Sun in the J2000:')
                print(' X = {:10.4f} km (LT+S)'.format(x))
                print(' Y = {:10.4f} km (LT+S)'.format(y))
                print(' Z = {:10.4f} km (LT+S)'.format(z))
                print('VX = {:10.4f} km/s (LT+S)'.format(vx))
                print('VY = {:10.4f} km/s (LT+S)'.format(vy))
                print('VZ = {:10.4f} km/s (LT+S)'.format(vz))

            # calculate orbital elements from the starg state vector
            elts = spice.oscelt(starg, et, planetmu('Sun'))

            # define a solver for Kepler's equation
            ks = pyasl.MarkleyKESolver()

            # solve for the Eccentric Anomaly (E) with the
            # Mean Anomaly (M = elts[5]) and the
            # Eccentricity (ecc = elts[1])
            E = ks.getE(elts[5], elts[1])

            # calculate the True Anomaly (nu) from E and ecc (elts[1])
            nuarg1 = math.sqrt(1 - elts[1]) * math.cos(E / 2)
            nuarg2 = math.sqrt(1 + elts[1]) * math.sin(E / 2)

            # atan2 in python needs the arguments as (y,x)
            # rather than (x,y) ...?
            nu = 2 * math.atan2(nuarg2, nuarg1)

            rvec.append(r)  # append r for each day
            xyvec.append((x, y))  # append (x,y) coords for each day
            nuvec.append(nu)  # append True anomaly for each day

            # build date in ISO format
            date = '{} {}'.format(spice.et2utc(et, 'ISOC', 0).split('T')[0],
                                  spice.et2utc(et, 'ISOC', 0).split('T')[1])
            dates.append(date)  # append date for each day
            incvec.append(elts[2])  # append inc. for each day (rads)

            # print(date, nu * spice.dpr(), x, y, z, r, elts[0])

        # for this planet find the argument of pericenter (argp):
        # find the index of the min. r value for calculated range.
        argpi = rvec.index(min(rvec))

        # calculate argp x and y values and argp using atan2
        argpxy = (xyvec[argpi][0], xyvec[argpi][1] * math.cos(incvec[argpi]))
        argp = math.degrees(math.atan2(argpxy[1], argpxy[0]))

        argpxys.append(argpxy)  # append argp (x,y) coords.
        argps.append(argp)  # append argp
        xyvecs.append(xyvec)  # append (x,y) coords. vector
        nuvecs.append(nuvec)  # append true anomaly vector

    spice.kclear()

    return days, dates, xyvecs, argps, argpxys, nuvecs
Exemple #6
0
### ET of TOI-15d
found, et = spice.gdpool('ETSTART', 0, 1)

### S/C IDs
scids = [-70, -140]
n = len(scids)
rn = range(len(scids))

### for 15 days leading up to TOI
for i in range(16):
    ### Convert
    ### - ET to ISO Calendar and DOY UTCs
    ### - ET to DII and DIF SCLKs
    ### - SCLKs to encoded SCLK, scale by 1/256 to get s past J2k epoch
    utcs = [spice.et2utc(et, 'isoc', 3), spice.et2utc(et, 'isod', 3)]
    sclks = [spice.sce2s(scids[i], et) for i in rn]
    encds = [spice.scencd(scids[i], sclks[i]) / 256e0 for i in rn]
    ### Build and print output
    f3 = ' %.3f'
    sencds = (f3 * n).strip() % tuple(
        [spice.scencd(scids[i], sclks[i]) / 256e0 for i in rn])
    diff3 = (f3 * (n + 1)).strip() % tuple([encds[0] - encds[1]] +
                                           [et - encds[i] for i in rn])
    print((
        utcs,
        sclks,
        sencds,
        diff3,
    ))
    ### Increment ET by 1d (spice.spd() = seconds/day)
  def test_horizons(self):
    import horizons

    target = 'C/2013 S1'
    target = 'C/2011 L4'

    spkFilename,spiceId,status = horizons.gomain(target)

    spice.furnsh( spkFilename )
    self.kernels += [spkFilename]

    target_ = '_'.join( target.split() )

    et0 = spice.utc2et( '2013-01-10T12:00:00' )

    ls2au = spice.convrt( spice.clight(), 'KM', 'AU' )
    dpr = spice.dpr()
    spd = spice.spd()

    deltatime = None

    while deltatime is None or abs(deltatime) > 5e-7:
      stS2I,lsS2I = spice.spkgeo( spiceId, et0, 'J2000', 10 )
      posn, veloc = stS2I[:3], stS2I[3:]
      deltatime = - spice.vdot( posn, veloc ) / spice.vdot( veloc, veloc )
      et0 += deltatime


    valarrs = [ ]
    print( (deltatime,spice.et2utc(et0,'ISOC',3),) )

    deltatime = 1.0
    sixmonths = spice.pi() * 1e7

    while deltatime < sixmonths:
      for pmdet in (-deltatime,deltatime):
        et = et0 + pmdet
        utc = spice.et2utc(et,'ISOC',1)

        stD2I,lsD2I = spice.spkgeo( spiceId, et, 'J2000', -140)
        stI2S,lsI2S = spice.spkgeo( 10, et, 'J2000', spiceId )
        stD2S,lsD2S = spice.spkgeo( 10, et, 'J2000', -140 )

        rD2I, rI2S = [ ls * ls2au for ls in [lsD2I,lsI2S] ]
        aDIS, aSDI = [ ang * dpr for ang in 
                       [ spice.vsep( spice.vminus(stD2I[:3]), stI2S[:-3] )
                       , spice.vsep( stD2S[:3], stD2I[:-3] )
                       ]
                     ]
        valarrs += [ (et,pmdet,rD2I,rI2S,aDIS,aSDI,utc,) ]

      deltatime *= 1.2

    valarrs.sort()
    for valarr in valarrs:
      print( '%12.1f %9.3f %9.3f %7.2f %7.2f %s' % valarr[1:] )

    days = [i[1]/spd for i in valarrs]

    titles = [ i % (target_,) for i in """
    Range, %s-DI, AU
    Range, %s-Sun, AU
    Phase, DI-%s-Sun, deg
    Elongation, Sun-DI-%s, deg
    """.strip().split('\n')]

    try:
      ### Moved matplotlib import to here so test runs to here at least
      from matplotlib import pyplot as plt
      plt.figure(1)
      for idx in range(len(titles)):
        ordinate = [i[idx+2] for i in valarrs]
        plt.subplot( 221+idx )
        plt.plot( days, ordinate )
        plt.plot( days, ordinate, '.')
        plt.title( titles[idx] )
        plt.ylabel( titles[idx] )
        if idx>1: plt.xlabel( 'T-Tperi, d' )

      plt.show()

    except:
      print( "Bypassed, or failed, matplotlib tests" )
Exemple #8
0
    def test_horizons(self):
        import horizons

        target = 'C/2013 S1'
        target = 'C/2011 L4'

        spkFilename, spiceId, status = horizons.gomain(target)

        spice.furnsh(spkFilename)
        self.kernels += [spkFilename]

        target_ = '_'.join(target.split())

        et0 = spice.utc2et('2013-01-10T12:00:00')

        ls2au = spice.convrt(spice.clight(), 'KM', 'AU')
        dpr = spice.dpr()
        spd = spice.spd()

        deltatime = None

        while deltatime is None or abs(deltatime) > 5e-7:
            stS2I, lsS2I = spice.spkgeo(spiceId, et0, 'J2000', 10)
            posn, veloc = stS2I[:3], stS2I[3:]
            deltatime = -spice.vdot(posn, veloc) / spice.vdot(veloc, veloc)
            et0 += deltatime

        valarrs = []
        print((
            deltatime,
            spice.et2utc(et0, 'ISOC', 3),
        ))

        deltatime = 1.0
        sixmonths = spice.pi() * 1e7

        while deltatime < sixmonths:
            for pmdet in (-deltatime, deltatime):
                et = et0 + pmdet
                utc = spice.et2utc(et, 'ISOC', 1)

                stD2I, lsD2I = spice.spkgeo(spiceId, et, 'J2000', -140)
                stI2S, lsI2S = spice.spkgeo(10, et, 'J2000', spiceId)
                stD2S, lsD2S = spice.spkgeo(10, et, 'J2000', -140)

                rD2I, rI2S = [ls * ls2au for ls in [lsD2I, lsI2S]]
                aDIS, aSDI = [
                    ang * dpr for ang in [
                        spice.vsep(spice.vminus(stD2I[:3]), stI2S[:-3]),
                        spice.vsep(stD2S[:3], stD2I[:-3])
                    ]
                ]
                valarrs += [(
                    et,
                    pmdet,
                    rD2I,
                    rI2S,
                    aDIS,
                    aSDI,
                    utc,
                )]

            deltatime *= 1.2

        valarrs.sort()
        for valarr in valarrs:
            print('%12.1f %9.3f %9.3f %7.2f %7.2f %s' % valarr[1:])

        days = [i[1] / spd for i in valarrs]

        titles = [
            i % (target_, ) for i in """
    Range, %s-DI, AU
    Range, %s-Sun, AU
    Phase, DI-%s-Sun, deg
    Elongation, Sun-DI-%s, deg
    """.strip().split('\n')
        ]

        try:
            ### Moved matplotlib import to here so test runs to here at least
            from matplotlib import pyplot as plt
            plt.figure(1)
            for idx in range(len(titles)):
                ordinate = [i[idx + 2] for i in valarrs]
                plt.subplot(221 + idx)
                plt.plot(days, ordinate)
                plt.plot(days, ordinate, '.')
                plt.title(titles[idx])
                plt.ylabel(titles[idx])
                if idx > 1: plt.xlabel('T-Tperi, d')

            plt.show()

        except:
            print("Bypassed, or failed, matplotlib tests")
Exemple #9
0
import pprint


print(__doc__.replace('\b','\\b'))
spice.furnsh(__file__)

### ET of TOI-15d
found,et = spice.gdpool( 'ETSTART', 0, 1 )

### S/C IDs
scids = [-70,-140]
n = len(scids)
rn = range(len(scids))

### for 15 days leading up to TOI
for i in range(16):
  ### Convert
  ### - ET to ISO Calendar and DOY UTCs
  ### - ET to DII and DIF SCLKs
  ### - SCLKs to encoded SCLK, scale by 1/256 to get s past J2k epoch
  utcs = [ spice.et2utc( et, 'isoc', 3), spice.et2utc( et, 'isod', 3) ]
  sclks = [ spice.sce2s(scids[i],et) for i in rn ]
  encds = [ spice.scencd(scids[i],sclks[i])/256e0 for i in rn ]
  ### Build and print output
  f3 = ' %.3f'
  sencds = (f3*n).strip() % tuple([ spice.scencd(scids[i],sclks[i])/256e0 for i in rn ])
  diff3 = (f3*(n+1)).strip() % tuple( [encds[0] - encds[1]] + [ et-encds[i] for i in rn ])
  print( (utcs,sclks,sencds,diff3,) )
  ### Increment ET by 1d (spice.spd() = seconds/day)
  et += spice.spd()
Exemple #10
0
        dcmd = pdsi._downone(faux)

        ### Extract start time from dcmd (CoreMetadata) as ISO UTC string
        firstTomsUTC = '%sT%s' % (
            dcmd['INVENTORYMETADATA']['RANGEDATETIME']['RANGEBEGINNINGDATE']
            ['VALUE'],
            dcmd['INVENTORYMETADATA']['RANGEDATETIME']['RANGEBEGINNINGTIME']
            ['VALUE'],
        )

        ### Combine start time and /Time offset to get the TOMS data zero epoch as seconds past J2000 epoch
        ### N.B. is typically (always?) equivalent to 1993-01-01T00:00:00 UTC
        tomsZeroEpoch = spice.utc2et(firstTomsUTC) - tomsOffsetTimes[0]

        print('%s(Epoch)  %s(Start)  %s' % (
            spice.et2utc(tomsZeroEpoch, 'ISOC', 1),
            firstTomsUTC,
            fnInput,
        ))

        ### Iterators
        twoDshape = surfLonDegs.shape
        rowIter, pixelIter = map(xrange, twoDshape)

        glintAngles = numpy.zeros(twoDshape, dtype=numpy.float32)

        for row in rowIter:

            ### Earth-Sun vector, convert to unit vector
            earth2Sun = spice.spkezr('SUN',
                                     tomsZeroEpoch + tomsOffsetTimes[row],
Exemple #11
0
    def test_smap(self):

        target = 'SMAP'

        et0 = spice.utc2et('2016-06-01T12:00:00')

        dpr = spice.dpr()

        a, b, c = [spice.gdpool('BODY399_RADII', i, 1)[1] for i in range(3)]

        ods = []

        for deltatime in [0.1 * i for i in range(1080)]:
            et = et0 + deltatime
            stSmap, lsSmap = spice.spkezr(target, et, 'IAU_EARTH', 'NONE',
                                          'EARTH')
            posn, veloc = stSmap[:3], stSmap[3:]
            stSun, lsSun = spice.spkezr('SUN', et0, 'IAU_EARTH', 'LT', 'EARTH')
            mtx = spice.pxform('SMAP_REFLECTOR', 'IAU_EARTH', et)
            boreEbf = spice.mxv(mtx, [1.0, 0, 0])
            point = spice.surfpt(posn, boreEbf, a, b, c)
            rsurfpt, lon, lat = spice.reclat(point)
            utc = spice.et2utc(et, 'ISOC', 3)

            ods += [
                OD(deltatime=deltatime,
                   posn=posn,
                   veloc=veloc,
                   boreEbf=boreEbf,
                   utc=utc,
                   point=point,
                   rsurfpt=rsurfpt,
                   rsmap=spice.vnorm(posn),
                   lat=lat,
                   lon=lon,
                   raynge=spice.vnorm(spice.vsub(point, posn)),
                   sunsep=spice.vsep(spice.ucrss(posn, veloc), stSun[:3]))
            ]

        try:
            ### Moved matplotlib import to here so test runs to here at least
            from matplotlib import pyplot as plt
            plt.figure(1)
            keys = 'lat lon raynge'.split()
            secs = [od['deltatime'] for od in ods]
            for idx in range(len(keys)):
                scal = 1.0 if keys[
                    idx] in 'rsurfpt rsmap raynge sunsep rp ecc t0 mu a P eccmean amean Pmean'.split(
                    ) else dpr
                ordinate = [od[keys[idx]] * scal for od in ods]
                plt.subplot(221 + idx)
                plt.plot(secs, ordinate)
                plt.plot(secs, ordinate, '.')
                plt.title(keys[idx])
                plt.ylabel('%s%s' %
                           (keys[idx], '' if scal == 1.0 else ', deg'))
                if idx > 1: plt.xlabel('T-T0, s')

            abscissa = [od['lon'] * dpr for od in ods]
            ordinate = [od['lat'] * dpr for od in ods]
            plt.subplot(221 + idx + 1)
            plt.title('lon vs. lat')
            plt.plot(abscissa, ordinate)
            plt.xlabel('lon, deg')
            plt.ylabel('lat, deg')
            plt.show()

        except:
            print("Bypassed, or failed, matplotlib tests")
Exemple #12
0
spice.furnsh(dot.join(__file__.split(dot)[:-1] + ['py']))

### Set arguments for Geometry Finder call
### - Times when VENUS crosses equator of Jupiter (Zjup = 0)
### - abcorr='LT+S' - correct for light time and stellar aberration
### - Timestep of 10 days (spice.spd() = seconds per day)
### - nintvls - 450 seems to work here
target, frame, abcorr, obsrvr = 'VENUS', 'IAU_JUPITER', 'LT+S', 'JUPITER'
relate, crdsys, coord = '=', 'RECTANGULAR', 'Z'
refval, adjust, step, nintvls = 0.0, 0.0, spice.spd()*10, 450

### Range of ETs to test
etlo,ethi = [spice.gdpool(s,0,1)[1] for s in 'ETLO ETHI'.split()]
cnfine = spice.wninsd( etlo, ethi, spice.objects.Cell(spice.DataType.SPICE_DP,2))

### Create DP window to receive results
result = spice.objects.Cell(spice.DataType.SPICE_DP,500)

### Make the call to the generic Geometry Finder call
cnfine, result = spice.gfposc( target, frame, abcorr, obsrvr, crdsys, coord, relate, refval, adjust, step, nintvls, cnfine, result )

### Output results as four columns
### - Crossing ordinal
### - UTC of crossing as ISO calendar time
### - TDB of crossing as calendar time (no leapseconds)
### - The Z value of Venus in the Jupiter-centered IAU_JUPITER frame
for i in xrange(spice.wncard(result)):
  et0,et1 = spice.wnfetd(result,i)
  assert et0 == et1
  print( ( i+1, spice.et2utc(et0,'ISOC',3), spice.etcal(et0), spice.spkezr(target,et0,frame,abcorr,obsrvr)[0][2] ,) )