Beispiel #1
0
def spice_Intplt(et,stepBitNum):
	"""
	Testing interpolating spice results with two exact numbers 
	"""
	step = 1.0/2.0**stepBitNum
	numStep = 2.0**stepBitNum
	et0 = np.floor(et) # The first integer before targeting time et
	et1 = np.ceil(et)  # The first integer after targeting time et
	exctNumArray = np.linspace(et0,et1,numStep) 
	exctNumNear = min(exctNumArray, key=lambda x:abs(x-et)) # find the closest exact number
	# Find two exact number around input time et
	if(exctNumNear>et):
		exctNum0 = exctNumNear - step
		exctNum1 = exctNumNear
	elif(exctNumNear == et):
		exctNum0 = et
		exctNum1 = et
	else:	
		exctNum0 = exctNumNear 
                exctNum1 = exctNumNear - step
	print exctNum0,exctNum1
	state0,lt0 = spice.spkezr("EARTH",exctNum0,"J2000","NONE","SSB")
	state1,lt1 = spice.spkezr("EARTH",exctNum1,"J2000","NONE","SSB")
	state = []
	lt = []
	for i in range(6):
		state.append(np.interp(et,[exctNum0,exctNum1],[state0[i],state1[i]]))
	lt.append(np.interp(et,[exctNum0,exctNum1],[lt0,lt1]))
	
	stateOr,ltOr = spice.spkezr("EARTH",et,"J2000","NONE","SSB")


	return state,stateOr,np.array(state)-np.array(stateOr)
Beispiel #2
0
def spice_Intplt(et, stepBitNum):
    """
    Testing interpolating spice results with two exact numbers 
    """
    step = 1.0 / 2.0**stepBitNum
    numStep = 2.0**stepBitNum
    et0 = np.floor(et)  # The first integer before targeting time et
    et1 = np.ceil(et)  # The first integer after targeting time et
    exctNumArray = np.linspace(et0, et1, numStep)
    exctNumNear = min(
        exctNumArray,
        key=lambda x: abs(x - et))  # find the closest exact number
    # Find two exact number around input time et
    if (exctNumNear > et):
        exctNum0 = exctNumNear - step
        exctNum1 = exctNumNear
    elif (exctNumNear == et):
        exctNum0 = et
        exctNum1 = et
    else:
        exctNum0 = exctNumNear
        exctNum1 = exctNumNear - step
    print exctNum0, exctNum1
    state0, lt0 = spice.spkezr("EARTH", exctNum0, "J2000", "NONE", "SSB")
    state1, lt1 = spice.spkezr("EARTH", exctNum1, "J2000", "NONE", "SSB")
    state = []
    lt = []
    for i in range(6):
        state.append(
            np.interp(et, [exctNum0, exctNum1], [state0[i], state1[i]]))
    lt.append(np.interp(et, [exctNum0, exctNum1], [lt0, lt1]))

    stateOr, ltOr = spice.spkezr("EARTH", et, "J2000", "NONE", "SSB")

    return state, stateOr, np.array(state) - np.array(stateOr)
Beispiel #3
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" )
Beispiel #4
0
def test_lmt(et, step):
    """
    Testing how accurate that spice can distinguish two near by times(et) with littl time step
    et is the initial time
    step is the small time step  
    """
    et0 = et
    et1 = et + step
    print et0, et1, et1 - et0
    state0, lt0 = spice.spkezr("EARTH", et0, "J2000", "NONE", "SSB")
    state1, lt1 = spice.spkezr("EARTH", et1, "J2000", "NONE", "SSB")
    diff = np.array(state0) - np.array(state1)
    print state0, state1
    return diff
Beispiel #5
0
def test_lmt(et,step):
	"""
	Testing how accurate that spice can distinguish two near by times(et) with littl time step
	et is the initial time
	step is the small time step  
	"""
	et0 = et
	et1 = et+step
	print et0,et1,et1-et0
	state0,lt0 = spice.spkezr("EARTH",et0,"J2000","NONE","SSB")
	state1,lt1 = spice.spkezr("EARTH",et1,"J2000","NONE","SSB")
	diff = np.array(state0)-np.array(state1)
	print state0,state1
	return diff
Beispiel #6
0
def get_v_sun(kernelMetaFile, utcStartTime):
    '''
    compute radial component of CG towards/away from sun for given utcTime.
    v_sun: velocity component on the comet-sun-line.
    '''

    spice.furnsh(kernelMetaFile)
    et = spice.str2et(utcStartTime)
    state, lightTime = spice.spkezr("CHURYUMOV-GERASIMENKO",
                                    et, "J2000", "NONE", "SUN")

    x = state[0]
    y = state[1]
    z = state[2]
    vx = state[3]
    vy = state[4]
    vz = state[5]

    r_length = np.sqrt(x**2 + y**2 + z**2)

    r_hat = np.zeros(3)
    v = np.zeros(3)

    r_hat[0] = x / r_length
    r_hat[1] = y / r_length
    r_hat[2] = z / r_length

    v[0] = r_hat[0] * vx
    v[1] = r_hat[1] * vy
    v[2] = r_hat[2] * vz

    v_sun = v[0] + v[1] + v[2]

    return v_sun
Beispiel #7
0
def getStateFromSpice(parent, body, epoch, referenceFrame='ECLIPJ2000'):
    global linearPoints
    state = list(spice.spkezr(body, epoch, referenceFrame, 'NONE', parent)[0])
    velocity = kepler.Vector3(state[3], state[4], state[5])

    for record in linearPoints:
        if epoch > record[0][0] and epoch < record[0][1]:
            i = 1
            while i < len(record[1][0]):
                if epoch < record[1][0][i]:
                    break
                i += 1
            state1 = record[1][1][i - 1]
            state2 = record[1][1][i]
            ratio = (epoch - record[1][0][i - 1]) / (record[1][0][i] -
                                                     record[1][0][i - 1])

            velocity = state1.velocity.mul(1 - ratio).add(
                state2.velocity.mul(ratio))
            break

    if epoch == 299024951.06256104:
        print(
            kepler.StateVector(kepler.Vector3(state[0], state[1], state[2]),
                               velocity))

    return kepler.StateVector(kepler.Vector3(state[0], state[1], state[2]),
                              velocity)
Beispiel #8
0
def objPosVel2SSB(objname, et):
    """Convert a PosVel object to solar system barycenter coordinates.

    Returns a solar system object position and velocity in J2000 SSB
    coordinates.  Requires SPK and LPSK kernels in J2000 SSB coordinates.
    """
    load_kernels()
    return spice.spkezr(objname.upper(), et, "J2000", "NONE", "SSB")
Beispiel #9
0
def objPosVel2SSB(objname, et):
    """Convert a PosVel object to solar system barycenter coordinates.

    Returns a solar system object position and velocity in J2000 SSB
    coordinates.  Requires SPK and LPSK kernels in J2000 SSB coordinates.
    """
    load_kernels()
    return spice.spkezr(objname.upper(), et, "J2000", "NONE", "SSB")
Beispiel #10
0
def objPosVel2SSB(objname, et):
    """
    objPosVel2SSB(objname, et)
    
    Returns a solar system object position and velocity in J2000 SSB
    coordinates.  Requires SPK and LPSK kernels in J2000 SSB coordinates.
    """
    return spice.spkezr(objname.upper(), et, "J2000", "NONE", "SSB")
Beispiel #11
0
def objPosVel(obj1, obj2, et):
    """Compute the difference of PosVel objects.

    Returns position/velocity vectors between obj1 and obj2 as a
    PosVel object at the given time.

    et is in spice format (TDB seconds past J2000 epoch)
    """
    # TODO:
    #  - maybe this should be a PosVel __init__ method instead?
    #  - accept an astropy time rather than et as input?
    pv, _ = spice.spkezr(obj1, float(et), "J2000", "NONE", obj2)
    return PosVel(pv[:3]*u.km, pv[3:]*u.km/u.s, obj=obj1, origin=obj2)
Beispiel #12
0
def spkInterp(et, stepBitNum):
    """
    This function interpolates earth state in one second with seveal exact points. 
    To increase accuracy, each know point will be the exact number that can be represented 
    by double precision. 
    et is the target time
    stepBitNum determines that how small the step for exact points will be. And it is 
    calculated by bits 
    step  = 1.0/2.0**stepBitNum   
    """
    step = 1.0 / 2.0**stepBitNum  # Step from exact point
    numStep = 2.0**stepBitNum  # Number of exact point
    et0 = np.floor(et)  # Start point of interval
    etExctArray = np.linspace(et0, et0 + 1,
                              numStep + 1)  # Exact time point array
    stateArray = []  # Earth state array for each exact point
    ltArray = []  # light time state array for each exact point
    """
	Calculate the earth state and lt for each exact point
	"""
    for data in etExctArray:
        stateExct, ltExct = spice.spkezr("EARTH", data, "J2000", "NONE", "SSB")
        stateArray.append(stateExct)
        ltArray.append(ltExct)

    stateArray = np.array(stateArray)  # Transfer to numpy array
    ltArray = np.array(ltArray)  # Transfer to numpy array
    state = []  # Earth state for target time
    lt = []  # lt for target time
    """
	Interpolate for target time
	"""
    for i in range(6):
        state.append(np.interp(et, etExctArray, stateArray[:, i]))
        lt.append(np.interp(et, etExctArray, ltArray))
    """
	Return earth state and light time as list
	"""
    return state, lt
Beispiel #13
0
def spkInterp(et,stepBitNum):
	"""
	This function interpolates earth state in one second with seveal exact points. 
	To increase accuracy, each know point will be the exact number that can be represented 
	by double precision. 
	et is the target time
	stepBitNum determines that how small the step for exact points will be. And it is 
	calculated by bits 
	step  = 1.0/2.0**stepBitNum   
	"""
	step = 1.0/2.0**stepBitNum   # Step from exact point
	numStep = 2.0**stepBitNum    # Number of exact point
	et0 = np.floor(et)           # Start point of interval
	etExctArray = np.linspace(et0,et0+1,numStep+1) # Exact time point array
	stateArray = [] # Earth state array for each exact point
	ltArray = []  # light time state array for each exact point
	"""
	Calculate the earth state and lt for each exact point
	"""
	for data in etExctArray:
		stateExct,ltExct = spice.spkezr("EARTH",data,"J2000","NONE","SSB")
		stateArray.append(stateExct)
		ltArray.append(ltExct)

	stateArray = np.array(stateArray) # Transfer to numpy array
	ltArray = np.array(ltArray)	  # Transfer to numpy array	
	state = []    # Earth state for target time
	lt = []       # lt for target time
	"""
	Interpolate for target time
	"""
	for i in range(6):  
		state.append(np.interp(et,etExctArray,stateArray[:,i]))	
		lt.append(np.interp(et,etExctArray,ltArray))	
	"""
	Return earth state and light time as list
	"""
	return state,lt
Beispiel #14
0
def objPosVel(obj1, obj2, et):
    """Returns PosVel instance from obj1 to obj2 at et (TDB sec past J2000)"""
    pv, _ = spice.spkezr(obj2, float(et), "J2000", "NONE", obj1)
    return PosVel(pv[:3] * u.km, pv[3:] * u.km / u.s, origin=obj1, obj=obj2)
Beispiel #15
0
def objPosVel(obj1, obj2, et):
    """Returns PosVel instance from obj1 to obj2 at et (TDB sec past J2000)"""
    pv, _ = spice.spkezr(obj2, float(et), "J2000", "NONE", obj1)
    return PosVel(pv[:3]*u.km, pv[3:]*u.km/u.s, origin=obj1, obj=obj2)
Beispiel #16
0
            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],
                                     'IAU_EARTH', 'LT+S', 'EARTH')[0][:3]
            uvEarth2Sun = spice.vhat(earth2Sun)

            scAltKm = scAltKms[row]
            scLonDeg = scLonDegs[row]
            scLatDeg = scLatDegs[row]

            for pixel in pixelIter:
                glintAngles[row,
                            pixel] = glintangle(scAltKm, scLonDeg, scLatDeg,
                                                surfLonDegs[row, pixel],
                                                surfLatDegs[row, pixel],
                                                uvEarth2Sun)

        ### Get top level groups for copying
Beispiel #17
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")
Beispiel #18
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
Beispiel #19
0
Datei: vj.py Projekt: drbitboy/vj
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] ,) )