コード例 #1
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)
コード例 #2
0
def approximateOrbit(object1, object2, epoch):
    if object2.epoch == object1.epoch:
        proportion = 0
    else:
        proportion = (epoch - object1.epoch) / (object2.epoch - object1.epoch)

    if (0.95 < object1.ecc and object1.ecc < 1.05) or (
            0.95 < object2.ecc and
            object2.ecc < 1.05) or (object1.isElliptic != object2.isElliptic):
        state1 = object1.getStateByEpoch(epoch)
        state2 = object2.getStateByEpoch(epoch)
        return kepler.createOrbitByState(
            kepler.StateVector(
                kepler.Vector3(
                    approximateNumber(state1.position.x, state2.position.x,
                                      proportion),
                    approximateNumber(state1.position.y, state2.position.y,
                                      proportion),
                    approximateNumber(state1.position.z, state2.position.z,
                                      proportion)),
                kepler.Vector3(
                    approximateNumber(state1.velocity.x, state2.velocity.x,
                                      proportion),
                    approximateNumber(state1.velocity.y, state2.velocity.y,
                                      proportion),
                    approximateNumber(state1.velocity.z, state2.velocity.z,
                                      proportion))), object2.mu, epoch)

    if object1.isElliptic:
        ma = approximateAngle(object1.getMeanAnomalyByEpoch(epoch),
                              object2.getMeanAnomalyByEpoch(epoch), proportion)
    else:
        ma = approximateNumber(object1.getMeanAnomalyByEpoch(epoch),
                               object2.getMeanAnomalyByEpoch(epoch),
                               proportion)

    if approximateNumber(object1.ecc, object2.ecc, proportion) < 0:
        print(object1.epoch, object2.epoch, epoch, proportion)
        print(approximateNumber(object1.ecc, object2.ecc, proportion))
        print(object1)
        print(object2)

    return kepler.Orbit(
        approximateNumber(object1.ecc, object2.ecc, proportion),
        approximateNumber(object1.sma, object2.sma, proportion),
        approximateAngle(object1.aop, object2.aop, proportion),
        approximateAngle(object1.inc, object2.inc, proportion),
        approximateAngle(
            object1.loan +
            object1.getNodalPrecessionByEpoch(EARTH_R, EARTH_J2, epoch),
            object2.loan +
            object2.getNodalPrecessionByEpoch(EARTH_R, EARTH_J2, epoch),
            proportion), ma, epoch,
        approximateNumber(object1.mu, object2.mu, proportion), False)