Example #1
0
	def setUp(self):
		self._solarsystem = Solar_system()
		#self._planet_1 = None
		
		route_1_x = [1000, 0, 0]
		route_1_v = [0, -1000, 0]
		route_1 = Route(route_1_x, route_1_v)
		name_1 = "Aalto-3"
		mass_1 = 10
		state_1 = State.ALIVE
		self._satellite_1 = Satellite(name_1, route_1, mass_1, state_1)
		
		route_1_x = [152100000000, 0, 0]
		route_1_v = [0, 29780, 0]
		route_1 = Route(route_1_x, route_1_v)
		name_1 = "Earth"
		mass_1 = 5.97237*10**24
		diameter = 2*6371000
		self._planet_1 = Planet(name_1, route_1, mass_1, diameter)
		
		self.pos_test_string = "x:220my:100kmz:20m"
		self.test_read = Read_planets()
		test_file = open("test_read.txt")
		self._solarsystem.read_planets(test_file)		
		test_file.close()
Example #2
0
    def add_satellite(self, body_name, vi, s_name, r, m, target, d=0):
        """
        Adds a satellite to the system a distance from the surface of a specific body

        body_name: name of body the satellite starts at
        vi: velocity of satellite
        s_name: name of satellite
        r: radius of satellite
        m: mass of satellite
        target: name of body satellite is aiming for
        d: extra added distance from body, use when adding more than one satellite to body
        """

        #Loops over bodies selecting the specified starting body
        for body in self.bodies:
            if body.name == body_name:
                #Creates a new satellite with the given parameters
                s = Satellite(s_name, 'green', m, r,
                              body.d - 2 * body.radius - d, vi, target)

                #Calculates initial acceleration of satellite
                s.get_init_accn(self.bodies)

                #Adds satellite to system bodies and a circle to the patches for animation
                self.bodies.append(s)
                self.patches.append(
                    plt.Circle(s.r / const.PixelToKM / const.DistScaleFactor,
                               radius=s.radius / const.PixelToKM *
                               const.SatelliteScaleFactor,
                               color=s.c,
                               animated=True))

                #Increment satellite couint and then break
                self.satellite_count += 1
                break
Example #3
0
 def setUp(self):
     t_init = 0  # 1/24/60
     t_end = t_init + 1 / 24 / 60  # 365*5
     my_dt = 1 / 24 / 60 / 10  # [days]
     spline_degree = 3
     gaia = Satellite(ti=t_init, tf=t_end, dt=my_dt, k=spline_degree)
     self.gaia = gaia
     my_times = np.linspace(t_init, t_end, num=100, endpoint=False)
     real_sources = []
     calc_sources = []
     for t in my_times:
         alpha, delta = af.generate_observation_wrt_attitude(
             gaia.func_attitude(t))
         real_src_tmp = Source(str(t), np.degrees(alpha), np.degrees(delta),
                               0, 0, 0, 0)
         calc_src_tmp = Calc_source('calc_' + str(t), [t],
                                    real_src_tmp.get_parameters()[0:5],
                                    real_src_tmp.get_parameters()[5])
         real_sources.append(real_src_tmp)
         calc_sources.append(calc_src_tmp)
     # test if source and calc source are equal (as they should be)
     np.testing.assert_array_almost_equal(
         np.array(real_sources[0].get_parameters()[0:5]),
         calc_sources[0].s_params)
     # create Solver
     self.Solver = Agis(
         gaia,
         calc_sources,
         real_sources,
         attitude_splines=[gaia.s_w, gaia.s_x, gaia.s_y, gaia.s_z],
         spline_degree=spline_degree,
         attitude_regularisation_factor=1e-3)
 def test_sees(self):
     sat1 = Satellite('SAT1', 0, 0, 1 + earth.radius * sqrt(2))
     sat2 = Satellite('SAT2', 0, pi, 1 + earth.radius * sqrt(2))
     sat3 = Satellite('SAT2', 0, pi/2, 1 + earth.radius * sqrt(2))
     self.assertFalse(sat1.sees(sat2))
     self.assertTrue(sat1.sees(sat3))
     self.assertTrue(sat2.sees(sat3))
Example #5
0
class VirtWho(object):
    def __init__(self, logger, options):
        """
        VirtWho class provides bridge between virtualization supervisor and
        Subscription Manager.

        logger - logger instance
        options - options for virt-who, parsed from command line arguments
        """
        self.logger = logger
        self.options = options

        self.virt = None
        self.subscriptionManager = None

        self.unableToRecoverStr = "Unable to recover"
        if not options.oneshot:
            self.unableToRecoverStr += ", retry in %d seconds." % RetryInterval

        # True if reload is queued
        self.doReload = False


    def initVirt(self):
        """
        Connect to the virtualization supervisor (libvirt or VDSM)
        """
        if self.options.virtType == "vdsm":
            self.virt = VDSM(self.logger)
        elif self.options.virtType == "libvirt":
            self.virt = Virt(self.logger, registerEvents=self.options.background)
            # We can listen for libvirt events
            self.tryRegisterEventCallback()
        elif self.options.virtType == "rhevm":
            self.virt = RHEVM(self.logger, self.options.server, self.options.username, self.options.password)
        elif self.options.virtType == "hyperv":
            self.virt = HyperV(self.logger, self.options.server, self.options.username, self.options.password)
        else:
            # ESX
            self.virt = VSphere(self.logger, self.options.server, self.options.username, self.options.password)

    def initSM(self):
        """
        Connect to the subscription manager (candlepin).
        """
        try:
            if self.options.smType == "sam":
                self.subscriptionManager = SubscriptionManager(self.logger)
                self.subscriptionManager.connect()
            elif self.options.smType == "satellite":
                self.subscriptionManager = Satellite(self.logger)
                self.subscriptionManager.connect(self.options.sat_server, self.options.sat_username, self.options.sat_password)
        except NoOptionError, e:
            self.logger.exception("Error in reading configuration file (/etc/rhsm/rhsm.conf):")
            raise
        except SubscriptionManagerError, e:
            self.logger.exception("Unable to obtain status from server, UEPConnection is likely not usable:")
            raise
 def test_solar_torque_value(self):
     state = np.array([1., 0., 0., 0., 0.1, -0.02, -0.2])
     mySat = Satellite(state, 128.05)
     v_sv_i = np.array([1.0, 0.0, 0.0])  #sun vector in eci frame
     mySat.setSun_i(v_sv_i)
     result = dist.solar_torque(mySat)
     print result
     self.assertTrue(
         np.allclose(result,
                     [0.00000000e+00, -3.66624000e-11, 3.17376000e-10]))
Example #7
0
    def apply(self, satellite: Satellite) -> ManeuverCost:
        orbit = satellite.orbit
        cur_theta = satellite.true_anomaly()
        new_theta = cur_theta + self.delta_theta

        # Find the difference in s and wait by that much
        cur_s = satellite.true_to_universal_anomaly(cur_theta)
        new_s = satellite.true_to_universal_anomaly(new_theta)

        delta_s = new_s - cur_s
        satellite.wait_s(delta_s)
        return ManeuverCost(delta_t=satellite.delta_s_to_t(delta_s))
Example #8
0
    def apply(self, satellite: Satellite) -> ManeuverCost:
        # We want to rotate around the radial vector. Use Rodrigues.
        axis = satellite.pos.norm()
        vel = satellite.vel
        cos = math.cos(self.angle)
        sin = math.sin(self.angle)

        new_vel = vel * cos + axis.cross(vel) * sin + axis * axis.dot(vel) * (
            1 - cos)

        delta_v = new_vel - vel
        satellite.boost(delta_v)
        return ManeuverCost(delta_v=delta_v.length())
Example #9
0
 def initSM(self):
     """
     Connect to the subscription manager (candlepin).
     """
     try:
         if self.options.smType == "sam":
             self.subscriptionManager = SubscriptionManager(self.logger)
             self.subscriptionManager.connect()
         elif self.options.smType == "satellite":
             self.subscriptionManager = Satellite(self.logger)
             self.subscriptionManager.connect(self.options.sat_server, self.options.sat_username, self.options.sat_password)
     except NoOptionError, e:
         self.logger.exception("Error in reading configuration file (/etc/rhsm/rhsm.conf):")
         raise
Example #10
0
def collectData():
    printDBG(1, "Collecting data from Satellite")
    s = Satellite(credentials['hostname'])
    s.setUsername(credentials['username'])
    s.setPassword(credentials['password'])
    h = s.listHosts()
    for host in h:
        printDBG(2, "Examining host " + host['name'])
        host['errata_reboot_suggested'] = False
        errata = s.getHostErrata(str(host['id']))
        if len(errata) == 0:
            pass
        else:
            printDBG(3, "Host has applicable errata.")
            listOfHosts[host['name']] = host
            listOfHosts[host['name']]['errata'] = {}
            for erratum in errata:
                if erratum['reboot_suggested']:
                    printDBG(
                        3, "Host will require reboot after errata application")
                host['errata_reboot_suggested'] = host[
                    'errata_reboot_suggested'] or erratum['reboot_suggested']
                erratumID = erratum['errata_id']
                if erratumID in listOfErrata:
                    pass
                else:
                    listOfErrata[erratumID] = erratum
                listOfHosts[host['name']]['errata'][erratumID] = erratum
Example #11
0
def collectData():
    printDBG(1, "Collecting data from Satellite")
    s = Satellite(credentials['hostname'])
    s.setUsername(credentials['username'])
    s.setPassword(credentials['password'])
    h = s.listHosts()
    for host in h:
        hostItem = {}
        hostItem['name'] = host['name']
        hostItem['subs'] = []
        subItems = s.getHostSubscriptions(str(host['id']))
        if (type(None) == type(subItems)):
            continue
        for item in subItems:
            si = {}
            if ('name' not in item):
                continue
            if (item['name'] in ['EPEL', 'FPLInternal']):
                continue
            si['accountNum'] = item['account_number']
            si['contractNum'] = item['contract_number']
            si['endDate'] = item['end_date']
            si['name'] = item['name']
            hostItem['subs'].append(si)
        listOfHosts.append(hostItem)
 def test_solar_torque_type(self):
     sat = Satellite(np.array([1., 0., 0., 0., 0., 0., 0.]), 13.)
     sat.setPos(np.array([7070e3, 0., 0.]))
     v_sv_i = np.array([1.0, 0.0, 0.0])
     sat.setSun_i(v_sv_i)
     sat.setLight(0)
     result = dist.vTSdB(sat)
     self.assertEqual(type(result), np.ndarray)
Example #13
0
def run():
    """
    Create the objects source for Sirio, Vega and Proxima as well
    as the corresponding scanners and the satellite object of Gaia.
    Then scan the sources from Gaia and print the time.
    :return: gaia, sirio, scanSirio, vega, scanVega, proxima, scanProxima
    """
    start_time = time.time()
    sirio = Source("sirio", 101.28, -16.7161, 379.21, -546.05, -1223.14, -7.6)
    vega = Source("vega", 279.2333, 38.78, 128.91, 201.03, 286.23, -13.9)
    proxima = Source("proxima", 217.42, -62, 768.7, 3775.40, 769.33, 21.7)

    scanSirio = Scanner(np.radians(20), np.radians(2))
    scanVega = Scanner(np.radians(20), np.radians(2))
    scanProxima = Scanner(np.radians(20), np.radians(2))
    gaia = Satellite()
    print(time.time() - start_time)

    scanSirio.start(gaia, sirio)
    scanVega.start(gaia, vega)
    scanProxima.start(gaia, proxima)
    print(time.time() - start_time)

    seconds = time.time() - start_time
    print('Total seconds:', seconds)
    return gaia, sirio, scanSirio, vega, scanVega, proxima, scanProxima
Example #14
0
    def apply(self, satellite: Satellite) -> ManeuverCost:
        cur_theta = satellite.true_anomaly()

        if satellite.orbit.is_open and cur_theta >= 0:
            raise ValueError("Periapsis is in the past on an open orbit")

        delta_theta = 2 * math.pi - cur_theta
        return WaitAngle(delta_theta).apply(satellite)
Example #15
0
	def test_aero_value(self):
		qBI = np.array([-np.sqrt(0.5),0.,0.,np.sqrt(0.5)])
		wBIb = np.array([0.1,0.23,0.])
		v_pos_i = np.array([0.,0.,7e6])
		v_vel_i = np.array([0,2e3,6e3])
		qBO = fs.qBI2qBO(qBI,v_pos_i,v_vel_i)
		wBOB = fs.wBIb2wBOb(wBIb,qBO,v_w_IO_o)
		sat = Satellite(np.hstack((qBO,wBOB)),13.)
		sat.setQ_BI(qBI)
		sat.setPos(np.array([0.,0.,7e6]))
		sat.setVel(np.array([0,2e3,6e3]))
		dist.aeroTorqueb(sat)
		result = sat.getaeroDisturbance_b()
		self.assertTrue(np.allclose(result, [2.99654080e-10,-2.57065600e-11,-7.71196800e-11]))
def populate_satellites_array():
    """Populates the satellites array from TLEs"""
    total_tles = 0
    tles = storage.get_tles_from_cache()
    metadata = storage.get_metadata()
    last_updated.append(metadata.get('last_updated'))
    if len(last_updated) > 1:
        del last_updated[0]
    if not tles:
        print('Fetching from spacetrack')
        cron_refresh_spacetrack_cache()
        tles = storage.get_tles_from_cache()
    for tle in tles:
        total_tles += 1
        s = Satellite(tle)
        if s.is_valid():
            satellites.append(s)
    print('Loaded {} of {} satellites'.format(len(satellites), total_tles))
Example #17
0
	def test_aero_type(self):
		qBI = np.array([-np.sqrt(0.5),0.,0.,np.sqrt(0.5)])
		wBIb = np.array([0.1,0.23,0.])
		v_pos_i = np.array([0.,0.,7e6])
		v_vel_i = np.array([0,2e3,6e3])
		qBO = fs.qBI2qBO(qBI,v_pos_i,v_vel_i)
		wBOB = fs.wBIb2wBOb(wBIb,qBO,v_w_IO_o)
		sat = Satellite(np.hstack((qBO,wBOB)),13.)
		sat.setQ_BI(qBI)
		sat.setPos(np.array([0.,0.,7e6]))		
		sat.setVel(np.array([0,2e3,6e3]))
		dist.aeroTorqueb(sat)
		result = sat.getaeroDisturbance_b()
			   
		self.assertEqual(type(result),np.ndarray)
Example #18
0
	def test_inertia_eigenvec(self,value):
		
		qBI = np.array([0.,0.,0.,1.])
		wBIb = np.array([0.1,-0.02,-0.2])
		v_pos_i = value
		v_vel_i = np.array([5.60,-5.0,0.0])
		qBO = fs.qBI2qBO(qBI,v_pos_i,v_vel_i)
		wBOB = fs.wBIb2wBOb(wBIb,qBO,v_w_IO_o)
		sat = Satellite(np.hstack((qBO,wBOB)),13.)
		sat.setQ_BI(qBI)
		sat.setPos(value)
		sat.setVel(v_vel_i)
		dist.ggTorqueb(sat)
		result = sat.getggDisturbance_b()
		self.assertTrue(np.allclose(result,[0.,0.,0.]))      
Example #19
0
	def test_solar_torque_value(self):
		qBI = np.array([0.,0.,0.,1.])
		wBIb = np.array([0.1,-0.02,-0.2])
		v_pos_i = np.array([7070e3,0.,0.])
		v_vel_i = np.array([0,2e3,6e3])
		qBO = fs.qBI2qBO(qBI,v_pos_i,v_vel_i)
		wBOB = fs.wBIb2wBOb(wBIb,qBO,v_w_IO_o)
		sat = Satellite(np.hstack((qBO,wBOB)),13.)
		sat.setQ_BI(qBI)			   		
		v_sv_i=np.array([1.0,0.0,0.0])            #sun vector in eci frame
		sat.setSun_i(v_sv_i)
		sat.setLight(1)
		dist.solarTorqueb(sat)
		result = sat.getsolarDisturbance_b()        
		self.assertTrue(np.allclose(result,[  0.00000000e+00,-3.66624000e-11,3.17376000e-10]))
Example #20
0
    def predict(self):
        sat = str(self.tbChooseSatellite.currentText())
        tle = self.tles[sat]
        with open("temp_tle.txt", "w") as f:
            f.write(tle + "\n")

        location = str(self.tbLocation.itemData(
            self.tbLocation.currentIndex()))
        satellite = Satellite(sat, tle, location)
        self.prediction = Prediction(satellite)
        self.prediction.show()
    def test_inertia_eigenvec(self, value):
        state = np.array([1., 0., 0., 0., 0.1, -0.02, -0.2])
        mySat = Satellite(state, 128.05)
        mySat.setPos(value)
        mySat.setVel(np.array([5.60, -5.0, 0.0]))
        result = dist.gg_torque(mySat)

        self.assertTrue(np.allclose(result, [0., 0., 0.]))
 def test_aero(self):
     sat = Satellite(
         np.array([np.sqrt(0.5), -np.sqrt(0.5), 0., 0., 0.1, 0.23, 0.]),
         13.)
     sat.setPos(np.array([0., 0., 7e6]))
     sat.setVel(np.array([0, 2e3, 6e3]))
     result = dist.aero_torque(sat)
     print result
Example #23
0
	def test_gg_data_type(self):
		qBI = np.array([0.,0.,0.,1.])
		wBIb = np.array([0.,0.,0.])
		v_pos_i = np.array([7070e3,0.,0.])
		v_vel_i = np.array([2.0e3,2.8,-73.2])
		qBO = fs.qBI2qBO(qBI,v_pos_i,v_vel_i)
		wBOB = fs.wBIb2wBOb(wBIb,qBO,v_w_IO_o)
		sat = Satellite(np.hstack((qBO,wBOB)),13.)
		sat.setPos(np.array([7070e3,0.,0.]))  
		sat.setQ_BI(qBI)
		dist.ggTorqueb(sat)
		result = sat.getggDisturbance_b()        
		self.assertEqual(type(result),np.ndarray)
Example #24
0
    def apply(self, satellite: Satellite) -> ManeuverCost:
        cur_theta = satellite.true_anomaly()

        # TODO: should i also block nearly-parabolic?
        if satellite.orbit.is_open:
            raise ValueError("No apoapsis on an open orbit")

        if cur_theta <= math.pi:
            # next apoapsis is coming up soon
            delta_theta = math.pi - cur_theta
        else:
            # we just passed it, pass through the periapsis first
            delta_theta = 3 * math.pi - cur_theta

        return WaitAngle(delta_theta).apply(satellite)
Example #25
0
 def get_more_satellite_data():
     response = open('TLE.txt', 'r').readlines()
     splits = response
     satellites = []
     size = 5
     for i in range(0, 6000, 2):
         print(i)
         satellite = Satellite(id=splits[i].replace('  ', '').split(' ')[2],
                               line1=splits[i].replace('\n', ''),
                               line2=splits[i + 1].replace('\n', ''),
                               size=size)
         satellites.append(satellite)
     print('Retrieved [{}] satellites from Celestrak'.format(
         len(satellites)))
     return satellites
    def test_aero_type(self):
        sat = Satellite(
            np.array([np.sqrt(0.5), -np.sqrt(0.5), 0., 0., 0.1, 0.23, 0.]),
            13.)
        sat.setPos(np.array([0., 0., 7e6]))

        sat.setVel(np.array([0, 2e3, 6e3]))
        result = dist.aero_torque(sat)

        self.assertEqual(type(result), np.ndarray)
Example #27
0
    def _setBlockSize(self, block_size):
        self.block_size = block_size
        doppler = int(np.ceil(self.doppler * float(self.block_size) / self.fs))
        self.dopplers = range(-doppler, doppler + 1)
        self.peak_matrix = np.zeros([33, doppler * 2 + 1])
        self.phase_matrix = np.zeros([33, doppler * 2 + 1])

        # Instantiate satellites if not already instantiated.
        if len(self.satellites) == 0:
            for i in range(1, 33):
                sat = Satellite(i, self.fs, self.block_size)
                self.satellites.append(sat)

        # Set the block size for satellites
        for s in self.satellites:
            s.setBlockSize(self.block_size)
 def test_aero_value(self):
     sat = Satellite(
         np.array([np.sqrt(0.5), -np.sqrt(0.5), 0., 0., 0.1, 0.23, 0.]),
         13.)
     sat.setPos(np.array([0., 0., 7e6]))
     sat.setVel(np.array([0, 2e3, 6e3]))
     result = dist.aero_torque(sat)
     print result
     self.assertTrue(
         np.allclose(result,
                     [2.99654080e-10, -2.57065600e-11, -7.71196800e-11]))
Example #29
0
def test():
    MHz = 1e6
    fs = 4 * MHz
    block_size = 1 * int(fs / 1000)  # 1 millisecond blocks
    sat7 = Satellite(7, fs, block_size)

    # Create a shifted transmit test signal
    tx_sig = np.roll(sat7.code_sig, 962)

    # Add noise to give -15dB SNR
    snr_db = -15
    w = 2 * np.pi * 3500 / fs  # 3.5kHz doppler shift
    theta = w * np.arange(len(tx_sig))
    rx_sig = tx_sig * np.exp(-1j * theta) + np.random.randn(
        len(tx_sig)) * 10**(-snr_db / 20)

    ca = CASearch(fs)
    ca.processBlock(rx_sig)
Example #30
0
 def get_satellite_data():
     response = open('active.txt', 'r').readlines()
     splits = response
     satellites = []
     size = 5
     for i in range(0, len(splits) - 1, 3):
         satellite = Satellite(id=splits[i].replace(' ',
                                                    '').replace('\n', ''),
                               line1=splits[i + 1].replace('\n', ''),
                               line2=splits[i + 2].replace('\n', ''),
                               size=size)
         satellites.append(satellite)
     satellites.sort(key=lambda x: x.get_semi_major_axis())
     satellites = satellites[:1250 if len(satellites
                                          ) >= 1250 else len(satellites)]
     print('Retrieved [{}] satellites from Celestrak'.format(
         len(satellites)))
     return satellites
Example #31
0
def collectData():
    printDBG(1, "Collecting data from Satellite")
    s = Satellite(credentials['hostname'])
    s.setUsername(credentials['username'])
    s.setPassword(credentials['password'])
    hcs = s.listHostCollections()
    for hc in hcs:
        printDBG(2, "Examining host collection " + hc['name'])
        hcInfo = s.getHostCollection(hc['id'])
        hcInfo['errata'] = {}
        hcInfo['errataRebootSuggested'] = False
        for hcID in hcInfo['host_ids']:
            printDBG(3, "Examining collection member host")
            errata = s.getHostErrata(str(hcID))
            for erratum in errata:
                hcInfo['errataRebootSuggested'] = hcInfo[
                    'errataRebootSuggested'] or erratum['reboot_suggested']
                erratumID = erratum['errata_id']
                if erratumID not in listOfErrata.keys():
                    listOfErrata[erratumID] = erratum
                if erratumID not in hcInfo['errata'].keys():
                    hcInfo['errata'][erratumID] = erratum
        if hcInfo['name'] not in listOfHostCollections.keys():
            listOfHostCollections[hcInfo['name']] = hcInfo
Example #32
0
def main():
	server = Satellite()
	server.bind_server("0.0.0.0", 27016)
	server.run_server()
Example #33
0
        with open(previous_measurements,'rb') as file:
            prev_db = pickle.load(file)
    else:
        using_previous = False


    # ------------------- Initial setup --------------------
    # GLD_root  = 'alex/array/home/Vaisala/feed_data/GLD'
    # NLDN_root = 'alex/array/home/Vaisala/feed_data/NLDN'
    GLD_root = 'GLD'

    sat_TLE  = ["1 40378U 15003C   15293.75287141  .00010129  00000-0  48835-3 0  9990",
                "2 40378  99.1043 350.5299 0153633 201.4233 158.0516 15.09095095 39471"]

    # Satellite object:
    sat = Satellite(sat_TLE[0], sat_TLE[1],'Firebird 4')

    # Measurement object:
    f = measurement_model(database = db_name, GLD_root=GLD_root, multiple_bands = True)

    # Start time:
    # start_time = "2015-11-01T00:45:00"
    tStep = datetime.timedelta(seconds=30) # Step size thru model
    cur_time = start_time
    mid_time = start_time + datetime.timedelta(days=15) # Midpoint of greediness-increasing curve
    max_greed = 0.95  # Maximum greed asypmtote
    #cur_time = datetime.datetime.strptime(start_time,  "%Y-%m-%dT%H:%M:%S")

    # Stop time:
    #stop_time = datetime.datetime(2015,11,1,2,45,00)
Example #34
0
                    coordinates.lat(), energy,
                    time_sampling_vector + f[3]) for energy in bands]) *
                    self.m.get_longitude_scaling(f[0], f[1], coordinates.lon(), I0=f[2]) * self.RES_DT ))
# #            
        return flux

if __name__== "__main__":
# -------------- Here's how to create a satellite and take some flux measurements: -------------
    #GLD_root  = 'alex/array/home/Vaisala/feed_data/GLD'
    #NLDN_root = 'alex/array/home/Vaisala/feed_data/NLDN'
    GLD_root = 'GLD'
    sat_TLE  = ["1 40378U 15003C   15293.75287141  .00010129  00000-0  48835-3 0  9990",
                "2 40378  99.1043 350.5299 0153633 201.4233 158.0516 15.09095095 39471"]

    # Satellite object:
    sat = Satellite(sat_TLE[0], sat_TLE[1],'Firebird 4')

    # Measurement object:
    f = measurement_model(database = "database_dicts.pkl", GLD_root = GLD_root, multiple_bands = True)

    # ---- Do The Thing:
    inTime = "2015-11-01T00:45:00"
    plottime = datetime.datetime.strptime(inTime,  "%Y-%m-%dT%H:%M:%S")

    sat.compute(plottime)
    sat.coords.transform_to('geomagnetic')

    # bands is a list of energy bands to sample at (depending on database, 1 thru 8)
    print "From banded measurement (all on):"
    print f.get_measurement(plottime, sat.coords, mode='banded',bands=f.m.E_bands)
    print "From single measurement:"