# A Simple UDP class
import socket
import msgpack
from bluesky.network.common import get_ownip
from bluesky import settings
settings.set_variable_defaults(discovery_port=11000)
IS_SERVER = 0
IS_CLIENT = 1
IS_REQUEST = 2
IS_REPLY = 4
class Discovery(object):
"""simple UDP ping class"""
handle = None # Socket for send/recv
port = 0 # UDP port we work on
address = '' # Own address
broadcast = '' # Broadcast address
def __init__(self, own_id, is_client=True):
self.address = get_ownip()
self.broadcast = '255.255.255.255'
self.port = settings.discovery_port
self.own_id = own_id
self.mask = IS_CLIENT if is_client else IS_SERVER
# Create UDP socket
self.handle = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
# Ask operating system to let us do broadcasts from socket
self.handle.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
from .windsim import WindSim
from .conditional import Condition
from .trails import Trails
from .adsbmodel import ADSB
from .asas import ASAS
from .pilot import Pilot
from .autopilot import Autopilot
from .activewpdata import ActiveWaypoint
from .turbulence import Turbulence
from .trafficgroups import TrafficGroups
# Register settings defaults
settings.set_variable_defaults(performance_model='openap')
if settings.performance_model == 'bada':
try:
print('Using BADA Performance model')
from .performance.bada.perfbada import PerfBADA as Perf
except Exception as err:# ImportError as err:
print(err)
print('Falling back to Open Aircraft Performance (OpenAP) model')
settings.performance_model = "openap"
from .performance.openap import OpenAP as Perf
elif settings.performance_model == 'openap':
print('Using Open Aircraft Performance (OpenAP) model')
from .performance.openap import OpenAP as Perf
else:
print('Using BlueSky legacy performance model')
""" This module provides PerfBase, the base class for aircraft
performance implementations.
"""
import numpy as np
from bluesky import settings
from bluesky.core import Entity, timed_function
from bluesky.stack import command
settings.set_variable_defaults(performance_dt=1.0)
class PerfBase(Entity, replaceable=True):
"""Base class for BlueSky aircraft performance implementations."""
def __init__(self):
super().__init__()
with self.settrafarrays():
# --- fixed parameters ---
self.actype = np.array([], dtype=str) # aircraft type
self.Sref = np.array([]) # wing reference surface area [m^2]
self.engtype = np.array([]) # integer, aircraft.ENG_TF...
# --- dynamic parameters ---
self.mass = np.array([]) # effective mass [kg]
self.phase = np.array([])
self.cd0 = np.array([])
self.k = np.array([])
self.bank = np.array([])
self.thrust = np.array([]) # thrust
self.drag = np.array([]) # drag
self.fuelflow = np.array([]) # fuel flow
from .conditional import Condition
from .trails import Trails
from .adsbmodel import ADSB
from .asas import ASAS
from .pilot import Pilot
from .autopilot import Autopilot
from .activewpdata import ActiveWaypoint
from .turbulence import Turbulence
from .trafficgroups import TrafficGroups
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(performance_model='openap',
snapdt=1.0,
instdt=1.0,
skydt=1.0,
asas_pzr=5.0,
asas_pzh=1000.0)
if settings.performance_model == 'bada':
try:
print('Using BADA Performance model')
from .performance.bada.perfbada import PerfBADA as Perf
except Exception as err: # ImportError as err:
print(err)
print('Falling back to Open Aircraft Performance (OpenAP) model')
settings.performance_model = "openap"
from .performance.openap import OpenAP as Perf
elif settings.performance_model == 'openap':
print('Using Open Aircraft Performance (OpenAP) model')
from .performance.openap import OpenAP as Perf
""" Airborne Separation Assurance System. Implements CD&R functionality together with
separate conflict detection and conflict resolution modules."""
import numpy as np
import bluesky as bs
from bluesky import settings
from bluesky.tools.simtime import timed_function
from bluesky.tools.aero import ft, nm
from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters
# Register settings defaults
settings.set_variable_defaults(prefer_compiled=False,
asas_dt=1.0,
asas_dtlookahead=300.0,
asas_mar=1.2,
asas_pzr=5.0,
asas_pzh=1000.0,
asas_vmin=200.0,
asas_vmax=500.0)
# Import default CD methods
StateBasedCD = False
if settings.prefer_compiled:
try:
from . import casas as StateBasedCD
print('StateBasedCD: using compiled version.')
except ImportError:
print(
'StateBasedCD: using default Python version, no compiled version for this platform.'
)
if not StateBasedCD:
from PyQt5 import uic
except ImportError:
from PyQt4.QtCore import Qt, pyqtSlot, QSize
from PyQt4.QtGui import QPixmap, QMainWindow, QIcon, QSplashScreen, \
QItemSelectionModel, QTreeWidgetItem, QPushButton
from PyQt4 import uic
# Local imports
from bluesky.sim.qtgl import StackTextEvent, PanZoomEvent, MainManager as manager
from bluesky import settings
is_osx = platform.system() == 'Darwin'
# Register settings defaults
settings.set_variable_defaults(data_path='data',
stack_text_color=(0, 255, 0),
stack_background_color=(102, 102, 102))
fg = settings.stack_text_color
bg = settings.stack_background_color
class Splash(QSplashScreen):
""" Splash screen: BlueSky logo during start-up"""
def __init__(self):
super(Splash, self).__init__(
QPixmap(settings.data_path + '/graphics/splash.gif'),
Qt.WindowStaysOnTopHint)
class MainWindow(QMainWindow):
""" BlueSky aircraft performance calculations."""
import os
from xml.etree import ElementTree
from math import *
import numpy as np
import bluesky as bs
from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \
kts, lbs, inch, sqft, fpm, vtas2cas
from .performance import esf, phases, calclimits, PHASE
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(perf_path='data/coefficients', verbose=False)
class CoeffBS:
"""
Coefficient class definition : get aircraft-specific coefficients from database
Created by : Isabel Metz
References:
- D.P. Raymer. Aircraft Design: A Conceptual Approach. AIAA Education Series.
American Institute of Aeronautics and Astronautics, Inc., Reston, U.S, fifth edition, 2012.
- R. Babikian. The Historical Fuel Efficiency Characteristics of Regional Aircraft from
Technological, Operational, and Cost Perspectives. Master's Thesis, Massachusetts
Institute of Technology, Boston, U.S.
"""
def __init__(self):
import numpy as np
import OpenGL.GL as gl
from ctypes import c_float, c_int, Structure
# Local imports
import bluesky as bs
from bluesky import settings
from bluesky.tools.aero import ft, nm, kts
from bluesky.sim.qtgl import PanZoomEvent, PanZoomEventType, MainManager as manager
from bluesky.navdb import load_aptsurface, load_coastlines
from .glhelpers import BlueSkyProgram, RenderObject, Font, UniformBuffer, \
update_buffer, create_empty_buffer
# Register settings defaults
settings.set_variable_defaults(gfx_path='data/graphics', text_size=13, apt_size=10, wpt_size=10, ac_size=16)
# Static defines
MAX_NAIRCRAFT = 10000
MAX_NCONFLICTS = 25000
MAX_ROUTE_LENGTH = 100
MAX_POLYPREV_SEGMENTS = 100
MAX_ALLPOLYS_SEGMENTS = 2000
MAX_CUST_WPT = 1000
MAX_TRAILLEN = MAX_NAIRCRAFT * 1000
REARTH_INV = 1.56961231e-7
# Colors
red = (255, 0, 0)
green = (0, 255, 0)
from .load_navdata_txt import load_navdata_txt
from .load_visuals_txt import load_coastline_txt
if settings.gui == 'qtgl':
from .load_visuals_txt import load_aptsurface_txt
else:
from .load_visuals_txt import pygame_load_rwythresholds
# Cache versions: increment these to the current date if the source data is updated
# or other reasons why the cache needs to be updated
coast_version = 'v20170101'
navdb_version = 'v20170101'
aptsurf_version = 'v20170101'
## Default settings
settings.set_variable_defaults(navdata_path='data/navdata', cache_path='data/cache')
sourcedir = settings.navdata_path
cachedir = settings.cache_path
class CacheFile():
def __init__(self, fname, version_ref):
print('cachefile constructor')
self.fname = fname
self.version_ref = version_ref
self.file = None
def check_cache(self):
if not path.isfile(self.fname):
raise Exception('Cachefile not found: ' + self.fname)
""" BlueSky aircraft performance calculations using BADA 3.xx."""
import numpy as np
import bluesky as bs
from bluesky.tools.aero import kts, ft, g0, a0, T0, gamma1, gamma2, beta, R
from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters
from .performance import esf, phases, calclimits, PHASE
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(perf_path_bada='data/coefficients/BADA', verbose=False)
from . import bada_coeff
if not bada_coeff.init(settings.perf_path_bada):
raise ImportError('BADA performance model: Error loading BADA files from ' + settings.perf_path_bada + '!')
else:
print('Using BADA performance model.')
class PerfBADA(TrafficArrays):
"""
Aircraft performance implementation based on BADA.
Methods:
reset() : clear current database
create(actype) : initialize new aircraft with performance parameters
delete(idx) : remove performance parameters from deleted aircraft
perf() : calculate aircraft performance
limits() : calculate flight envelope
Created by : Isabel Metz
Note: This class is based on
''' BlueSky colour palette loader. '''
from os import path
from bluesky import settings
settings.set_variable_defaults(colour_palette='bluesky-default', gfx_path='data/graphics')
def init():
# Load the palette file selected in settings
pfile = path.join(settings.gfx_path, 'palettes', settings.colour_palette)
if path.isfile(pfile):
print('Loading palette ' + settings.colour_palette)
exec(compile(open(pfile).read(), pfile, 'exec'), globals())
return True
else:
print('Palette file not found ' + pfile)
return False
def set_default_colours(**kwargs):
''' Register a default value for a colour. Use this functionality in the source file
where you intend to use those colours so that defaults are always available.
Example:
from bluesky.ui import palette
palette.set_default_colours(mycolor1=(255, 0, 0), mycolor2=(0, 0, 0))
This will make settings.mycolor1 and settings.mycolor2 available,
with the provided default values.'''
for key, value in kwargs.items():
if key not in globals():
globals()[key] = value
import OpenGL.GL as gl
from ctypes import c_float, c_int, Structure
# Local imports
import bluesky as bs
from bluesky import settings
from bluesky.ui import palette
from bluesky.tools.aero import ft, nm, kts
from bluesky.sim.qtgl import PanZoomEvent, PanZoomEventType, MainManager as manager
from bluesky.navdb import load_aptsurface, load_coastlines
from .glhelpers import BlueSkyProgram, RenderObject, Font, UniformBuffer, \
update_buffer, create_empty_buffer
# Register settings defaults
settings.set_variable_defaults(
gfx_path='data/graphics',
text_size=13, apt_size=10,
wpt_size=10, ac_size=16)
palette.set_default_colours(
aircraft=(0,255,0),
aptlabel=(220, 250, 255),
aptsymbol=(148, 178, 235),
background=(0,0,0),
coastlines=(85, 85, 115),
conflict=(255, 160, 0),
pavement=(160, 160, 160),
polys=(0,0,255),
previewpoly=(0, 204, 255),
route=(255, 0, 255),
runways=(100, 100, 100),
taxiways=(100, 100, 100),
""" BlueSky ADS-B datafeed plugin. Reads the feed from a Mode-S Beast server,
and visualizes traffic in BlueSky."""
import time
from bluesky import stack, settings, traf
from bluesky.tools.network import TcpSocket
from bluesky.tools import aero
import adsb_decoder as decoder
## Default settings
# Mode-S / ADS-B server hostname/ip, and server port
settings.set_variable_defaults(modeS_host='', modeS_port=0)
# Global data
reader = None
### Initialization function of the adsbfeed plugin.
def init_plugin():
# Initialize Modesbeast reader
global reader
reader = Modesbeast()
# Configuration parameters
config = {
'plugin_name': 'DATAFEED',
'plugin_type': 'sim',
'update_interval': 0.0,
'preupdate': reader.update
}
stackfunctions = {
"DATAFEED": [
''' Main stack functions. '''
import math
import os
import subprocess
import bluesky as bs
from bluesky.stack.cmdparser import Command, command, commandgroup
from bluesky.stack.basecmds import initbasecmds
from bluesky.stack import recorder
from bluesky.stack import argparser
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(start_location="EHAM", scenario_path="scenario")
# List of TMX commands not yet implemented in BlueSky
tmxlist = ("BGPASAS", "DFFLEVEL", "FFLEVEL", "FILTCONF", "FILTTRED", "FILTTAMB",
"GRAB", "HDGREF", "MOVIE", "NAVDB", "PREDASAS", "RENAME", "RETYPE",
"SWNLRPASAS", "TRAFRECDT", "TRAFLOGDT", "TREACT", "WINDGRID")
# Stack data
cmdstack = [] # The actual stack: Current commands to be processed
# Scenario details
scenname = "" # Currently used scenario name (for reading)
scentime = [] # Times of the commands from the read scenario file
scencmd = [] # Commands from the scenario file
sender_rte = None # bs net route to sender
def init(startup_scnfile):
Modification :
By :
Date :
------------------------------------------------------------------
"""
import os
from ctypes import c_void_p, pointer, sizeof
from PyQt5.QtGui import QImage
import OpenGL.GL as gl
import numpy as np
from bluesky import settings
msg1282 = False # GL error 1282 when quitting should only be reported once
# Register settings defaults
settings.set_variable_defaults(gfx_path='data/graphics')
def load_texture(fname):
img = QImage(fname)
ptr = c_void_p(int(img.constBits()))
tex_id = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, tex_id)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, img.width(), img.height(), 0, gl.GL_BGRA, gl.GL_UNSIGNED_BYTE, ptr)
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR_MIPMAP_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
return tex_id
def create_empty_buffer(size, target=gl.GL_ARRAY_BUFFER, usage=gl.GL_STATIC_DRAW):
""" BlueSky aircraft performance calculations."""
import os
from math import *
import numpy as np
import bluesky as bs
from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \
kts, lbs, inch, sqft, fpm, vtas2cas
from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters
from bluesky.traffic.performance.legacy.performance import esf, phases, calclimits, PHASE
from bluesky import settings
from bluesky.traffic.performance.legacy.coeff_bs import CoeffBS
# Register settings defaults
settings.set_variable_defaults(perf_path='data/performance/BS', verbose=False)
coeffBS = CoeffBS()
#tijdelijk om import error in traffic.py op te lossen
def test():
a = 1
print('dit is een test')
#tijdelijk voor oplossen import error in traffic .py
class PerfBS(TrafficArrays):
def __init__(self):
super(PerfBS, self).__init__()
import os
from math import *
import numpy as np
import bluesky as bs
from bluesky.tools.simtime import timed_function
from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \
kts, lbs, inch, sqft, fpm, vtas2cas
from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters
from bluesky.traffic.performance.legacy.performance import esf, phases, calclimits, PHASE
from bluesky import settings
from bluesky.traffic.performance.legacy.coeff_bs import CoeffBS
# Register settings defaults
settings.set_variable_defaults(perf_path='data/performance/BS',
performance_dt=1.0, verbose=False)
coeffBS = CoeffBS()
class PerfBS(TrafficArrays):
def __init__(self):
super(PerfBS,self).__init__()
self.warned = False # Flag: Did we warn for default perf parameters yet?
self.warned2 = False # Flag: Use of piston engine aircraft?
# prepare for coefficient readin
coeffBS.coeff()
with RegisterElementParameters(self):
# index of aircraft types in library
self.coeffidxlist = np.array([])
""" Implementation of BlueSky's plugin system. """
import ast
from os import path
import sys
from glob import glob
import imp
import bluesky as bs
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(plugin_path='plugins',
enabled_plugins=['datafeed'])
# Dict of descriptions of plugins found for this instance of bluesky
plugin_descriptions = dict()
# Dict of loaded plugins for this instance of bluesky
active_plugins = dict()
class Plugin(object):
def __init__(self, fname):
fname = path.normpath(path.splitext(fname)[0].replace('\\', '/'))
self.module_path, self.module_name = path.split(fname)
self.module_imp = fname.replace('/', '.')
self.plugin_doc = ''
self.plugin_name = ''
self.plugin_type = ''
self.plugin_stack = []
def check_plugin(fname):
import time
# Local imports
import bluesky as bs
from bluesky import settings, stack
from bluesky.tools import datalog, areafilter, plugin
from bluesky.tools.misc import txt2tim, tim2txt
from bluesky.network import Node
# Minimum sleep interval
MINSLEEP = 1e-3
onedayinsec = 24 * 3600 # [s] time of one day in seconds for clock time
# Register settings defaults
settings.set_variable_defaults(simdt=0.05)
class Simulation(Node):
''' The simulation object. '''
def __init__(self):
super(Simulation, self).__init__()
self.state = bs.INIT
self.prevstate = None
# Set starting system time [seconds]
self.syst = -1.0
# Benchmark time and timespan [seconds]
self.bencht = 0.0
self.benchdt = -1.0
""" BlueSky aircraft performance calculations."""
import os
from xml.etree import ElementTree
from math import *
import numpy as np
import bluesky as bs
from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \
kts, lbs, inch, sqft, fpm, vtas2cas
from .performance import esf, phases, calclimits, PHASE
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(perf_path='data/performance', verbose=False)
class CoeffBS:
"""
Coefficient class definition : get aircraft-specific coefficients from database
Created by : Isabel Metz
References:
- D.P. Raymer. Aircraft Design: A Conceptual Approach. AIAA Education Series.
American Institute of Aeronautics and Astronautics, Inc., Reston, U.S, fifth edition, 2012.
- R. Babikian. The Historical Fuel Efficiency Characteristics of Regional Aircraft from
Technological, Operational, and Cost Perspectives. Master's Thesis, Massachusetts
Institute of Technology, Boston, U.S.
"""
def __init__(self):
''' OpenAP performance library. '''
import os
import json
import numpy as np
import pandas as pd
from bluesky import settings
settings.set_variable_defaults(perf_path_openap="data/performance/OpenAP")
LIFT_FIXWING = 1 # fixwing aircraft
LIFT_ROTOR = 2 # rotor aircraft
ENG_TYPE_TF = 1 # turbofan, fixwing
ENG_TYPE_TP = 2 # turboprop, fixwing
ENG_TYPE_TS = 3 # turboshlft, rotor
synonyms_db = settings.perf_path_openap + "/synonym.dat"
fixwing_aircraft_db = settings.perf_path_openap + "/fixwing/aircraft.json"
fixwing_engine_db = settings.perf_path_openap + "/fixwing/engines.csv"
fixwing_envelops_dir = settings.perf_path_openap + "/fixwing/wrap/"
fixwing_dragpolar_db = settings.perf_path_openap + "/fixwing/dragpolar.csv"
rotor_aircraft_db = settings.perf_path_openap + "/rotor/aircraft.json"
class Coefficient():
def __init__(self):
self.acs_fixwing = self.__load_all_fixwing_flavor()
self.engines_fixwing = pd.read_csv(fixwing_engine_db, encoding='utf-8')
self.limits_fixwing = self.__load_all_fixwing_envelop()
self.acs_rotor = self.__load_all_rotor_flavor()
try:
from PyQt5.QtCore import QObject, QEvent, QTimer, pyqtSignal, \
QCoreApplication as qapp
except ImportError:
from PyQt4.QtCore import QObject, QEvent, QTimer, pyqtSignal, \
QCoreApplication as qapp
# Local imports
from bluesky import settings, MSG_OK
from .simevents import SimStateEventType, SimQuitEventType, BatchEventType, \
BatchEvent, StackTextEvent, StackTextEventType, SimQuitEvent, SetNodeIdType, \
SetActiveNodeType, AddNodeType
Listener.fileno = lambda self: self._listener._socket.fileno()
# Register settings defaults
settings.set_variable_defaults(max_nnodes=cpu_count())
def split_scenarios(scentime, scencmd):
start = 0
for i in range(1, len(scencmd) + 1):
if i == len(scencmd) or scencmd[i][:4] == 'SCEN':
scenname = scencmd[start].split()[1].strip()
yield (scenname, scentime[start:i], scencmd[start:i])
start = i
class MainManager(QObject):
instance = None
# Signals
nodes_changed = pyqtSignal(str, tuple, int)
activenode_changed = pyqtSignal(tuple, int)
""" BlueSky aircraft performance calculations."""
import os
from xml.etree import ElementTree
from math import *
import numpy as np
import bluesky as bs
from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \
kts, lbs, inch, sqft, fpm, vtas2cas
from .performance import esf, phases, calclimits, PHASE
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(perf_path='data/coefficients', verbose=False)
class CoeffBS:
"""
Coefficient class definition : get aircraft-specific coefficients from database
Created by : Isabel Metz
References:
- D.P. Raymer. Aircraft Design: A Conceptual Approach. AIAA Education Series.
American Institute of Aeronautics and Astronautics, Inc., Reston, U.S, fifth edition, 2012.
- R. Babikian. The Historical Fuel Efficiency Characteristics of Regional Aircraft from
Technological, Operational, and Cost Perspectives. Master's Thesis, Massachusetts
Institute of Technology, Boston, U.S.
"""
def __init__(self):
''' OpenAP performance library. '''
import os
import json
import numpy as np
import pandas as pd
from bluesky import settings
settings.set_variable_defaults(perf_path_openap="data/performance/OpenAP")
LIFT_FIXWING = 1 # fixwing aircraft
LIFT_ROTOR = 2 # rotor aircraft
ENG_TYPE_TF = 1 # turbofan, fixwing
ENG_TYPE_TP = 2 # turboprop, fixwing
ENG_TYPE_TS = 3 # turboshlft, rotor
fixwing_aircraft_db = settings.perf_path_openap + "/fixwing/aircraft.json"
fixwing_engine_db = settings.perf_path_openap + "/fixwing/engines.csv"
fixwing_envelops_dir = settings.perf_path_openap + "/fixwing/wrap/"
rotor_aircraft_db = settings.perf_path_openap + "/rotor/aircraft.json"
class Coefficient():
def __init__(self):
self.acs_fixwing = self.__load_all_fixwing_flavor()
self.engines_fixwing = pd.read_csv(fixwing_engine_db, encoding='utf-8')
self.limits_fixwing = self.__load_all_fixwing_envelop()
self.acs_rotor = self.__load_all_rotor_flavor()
self.limits_rotor = self.__load_all_rotor_envelop()
from bluesky import settings
from bluesky.ui import palette
from bluesky.ui.radarclick import radarclick
from bluesky.ui.qtgl import console
from bluesky.ui.qtgl.customevents import ACDataEvent, RouteDataEvent
from bluesky.tools.aero import ft, nm, kts
from bluesky.tools import geo
from bluesky.navdatabase import load_aptsurface, load_coastlines
from .glhelpers import BlueSkyProgram, RenderObject, Font, UniformBuffer, \
update_buffer, create_empty_buffer
# Register settings defaults
settings.set_variable_defaults(
gfx_path='data/graphics',
text_size=13, apt_size=10,
wpt_size=10, ac_size=16,
asas_vmin=200.0, asas_vmax=500.0)
palette.set_default_colours(
aircraft=(0,255,0),
aptlabel=(220, 250, 255),
aptsymbol=(148, 178, 235),
background=(0,0,0),
coastlines=(85, 85, 115),
conflict=(255, 160, 0),
pavement=(160, 160, 160),
polys=(0,0,255),
previewpoly=(0, 204, 255),
route=(255, 0, 255),
runways=(100, 100, 100),
try:
from collections.abc import Collection, MutableMapping
except ImportError:
# In python <3.3 collections.abc doesn't exist
from collections import Collection, MutableMapping
from PyQt5.QtGui import QImage, QOpenGLTexture, QOpenGLBuffer
import OpenGL.GL as gl
import numpy as np
from bluesky import settings
from bluesky.ui.qtgl.dds import DDSTexture
msg1282 = False # GL error 1282 when quitting should only be reported once
# Register settings defaults
settings.set_variable_defaults(gfx_path='data/graphics')
class Texture(QOpenGLTexture):
def __init__(self, fname=None):
super().__init__(QOpenGLTexture.Target2D)
if fname:
self.load(fname)
def load(self, fname):
if fname[-3:].lower() == 'dds':
tex = DDSTexture(fname)
self.setFormat(QOpenGLTexture.RGB_DXT1)
self.setSize(tex.width, tex.height)
self.setWrapMode(QOpenGLTexture.Repeat)
self.allocateStorage()
import time
# Local imports
import bluesky as bs
from bluesky import settings, stack
# from bluesky.traffic import Metric
from bluesky.tools import datalog, areafilter, plugin
from bluesky.tools.misc import txt2tim, tim2txt
from . import nodemanager as manager
from .simevents import StackTextEventType, BatchEventType, BatchEvent, \
SimStateEvent, SimQuitEventType, StackInitEvent
onedayinsec = 24 * 3600 # [s] time of one day in seconds for clock time
# Register settings defaults
settings.set_variable_defaults(simdt=0.05)
class Simulation(QObject):
# simulation modes
init, op, hold, end = list(range(4))
# =========================================================================
# Functions
# =========================================================================
def __init__(self):
super(Simulation, self).__init__()
self.running = True
self.state = Simulation.init
self.prevstate = None
""" BlueSky Datalogger """
# ToDo: Add description in comments
import os
import numbers
import itertools
from datetime import datetime
import numpy as np
from bluesky import settings, stack
from bluesky.tools import varexplorer as ve
import bluesky as bs
# Register settings defaults
settings.set_variable_defaults(log_path='output')
logprecision = '%.8f'
# Dict to contain the definitions of periodic loggers
periodicloggers = dict()
# Dict to contain all loggers (also the periodic loggers)
allloggers = dict()
def crelog(name, dt=None, header=''):
''' Create a new logger from the stack. '''
allloggers[name] = CSVLogger(name, dt or 0.0, header)
if dt:
periodicloggers[name] = allloggers[name]
import time, datetime
# Local imports
import bluesky as bs
from bluesky import settings, stack
from bluesky.tools import datalog, areafilter, plugin, plotter
from bluesky.tools.misc import txt2tim, tim2txt
# Minimum sleep interval
MINSLEEP = 1e-3
onedayinsec = 24 * 3600 # [s] time of one day in seconds for clock time
# Register settings defaults
settings.set_variable_defaults(simdt=0.05,
simevent_port=10000,
simstream_port=10001)
def Simulation(detached):
""" Return Simulation object either in normal network-attached mode
or detached mode.
"""
if detached:
from bluesky.network.detached import Node
else:
from bluesky.network.node import Node
class SimulationClass(Node):
''' The simulation object. '''
def __init__(self):
""" BlueSky aircraft performance calculations using BADA 3.xx."""
import numpy as np
import bluesky as bs
from bluesky.tools.aero import kts, ft, g0, a0, T0, gamma1, gamma2, beta, R, vtas2cas
from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters
from bluesky.traffic.performance.legacy.performance import esf, phases, calclimits, PHASE
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(perf_path_bada='data/performance/BADA', verbose=False)
from . import coeff_bada
if not coeff_bada.init(settings.perf_path_bada):
raise ImportError('BADA performance model: Error loading BADA files from ' + settings.perf_path_bada + '!')
else:
print('Using BADA performance model.')
class PerfBADA(TrafficArrays):
"""
Aircraft performance implementation based on BADA.
Methods:
reset() : clear current database
create(actype) : initialize new aircraft with performance parameters
delete(idx) : remove performance parameters from deleted aircraft
perf() : calculate aircraft performance
limits() : calculate flight envelope
Created by : Isabel Metz
Note: This class is based on
''' Loader functions for navigation visualisation data. '''
import pickle
from bluesky import settings
from bluesky.tools import cachefile
from bluesky.ui.loadvisuals_txt import load_coastline_txt, load_aptsurface_txt
# Cache versions: increment these to the current date if the source data is updated
# or other reasons why the cache needs to be updated
coast_version = 'v20170101'
navdb_version = 'v20170101'
aptsurf_version = 'v20171116'
## Default settings
settings.set_variable_defaults(navdata_path='data/navdata')
sourcedir = settings.navdata_path
def load_coastlines():
''' Load coastline data for gui. '''
with cachefile.openfile('coastlines.p', coast_version) as cache:
try:
coastvertices = cache.load()
coastindices = cache.load()
except (pickle.PickleError, cachefile.CacheError) as e:
print(e.args[0])
coastvertices, coastindices = load_coastline_txt()
cache.dump(coastvertices)
cache.dump(coastindices)
# A Simple UDP class
import socket
import msgpack
from bluesky.network.common import get_ownip
from bluesky import settings
settings.set_variable_defaults(discovery_port=11000)
IS_SERVER = 0
IS_CLIENT = 1
IS_REQUEST = 2
IS_REPLY = 4
class Discovery(object):
"""simple UDP ping class"""
handle = None # Socket for send/recv
port = 0 # UDP port we work on
address = '' # Own address
broadcast = '' # Broadcast address
def __init__(self, own_id, is_client=True):
self.address = get_ownip()
self.broadcast = '255.255.255.255'
self.port = settings.discovery_port
self.own_id = own_id
self.mask = IS_CLIENT if is_client else IS_SERVER
# Create UDP socket
self.handle = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
from PyQt5 import uic
except ImportError:
from PyQt4.QtCore import Qt, pyqtSlot, QSize
from PyQt4.QtGui import QPixmap, QMainWindow, QIcon, QSplashScreen, \
QItemSelectionModel, QTreeWidgetItem, QPushButton
from PyQt4 import uic
# Local imports
from bluesky.sim.qtgl import StackTextEvent, PanZoomEvent, MainManager as manager
from bluesky import settings
is_osx = platform.system() == 'Darwin'
# Register settings defaults
settings.set_variable_defaults(gfx_path='data/graphics', stack_text_color=(0, 255, 0), stack_background_color=(102, 102, 102))
fg = settings.stack_text_color
bg = settings.stack_background_color
class Splash(QSplashScreen):
""" Splash screen: BlueSky logo during start-up"""
def __init__(self):
super(Splash, self).__init__(QPixmap(os.path.join(settings.gfx_path, 'splash.gif')), Qt.WindowStaysOnTopHint)
class MainWindow(QMainWindow):
""" Qt window process: from .ui file read UI window-definitionof main window """
def __init__(self, app, radarwidget):
super(MainWindow, self).__init__()
import os
import sys
import pygrib
import datetime
import requests
import numpy as np
import bluesky as bs
from bluesky import settings, stack
from bluesky.core import timed_function
from bluesky.traffic.windsim import WindSim
settings.set_variable_defaults(
windgfs_url=
"https://www.ncei.noaa.gov/data/global-forecast-system/access/historical/analysis/"
)
# nlayer = 23
datadir = settings.data_path + '/grib/'
if not os.path.exists(datadir):
os.makedirs(datadir)
def init_plugin():
global windgfs
windgfs = WindGFS()
config = {'plugin_name': 'WINDGFS', 'plugin_type': 'sim'}
return config
Xavier Olive, 2018
Joost Ellerbroek, 2018
"""
import time
import requests
import numpy as np
from os import path
try:
import cPickle as pickle
except ImportError:
import pickle
from bluesky import stack, settings, traf, scr
from bluesky.tools import RegisterElementParameters, TrafficArrays, cachefile
settings.set_variable_defaults(opensky_user=None, opensky_password=None,
opensky_ownonly=False)
# Globals
actypedb_version = 'v20180126'
reader = None
actypes = dict()
def init_plugin():
global reader
reader = OpenSkyListener()
# Load aircraft type database
get_actypedb()
config = {
'plugin_name': 'OPENSKY',
import cPickle as pickle
except ImportError:
import pickle
from bluesky import settings
from load_navdata_txt import load_navdata_txt
from load_visuals_txt import load_coastline_txt
if settings.gui == 'qtgl':
from load_visuals_txt import load_aptsurface_txt
else:
from load_visuals_txt import pygame_load_rwythresholds
## Default settings
settings.set_variable_defaults(navdata_path='data/navdata',
cache_path='data/cache')
sourcedir = settings.navdata_path
cachedir = settings.cache_path
def check_cache(cachefile, *sources):
if not path.isfile(cachefile):
return False
cachetm = path.getmtime(cachefile)
for source in sources:
if path.isfile(source) and path.getmtime(source) > cachetm:
return False
return True
""" BlueSky aircraft performance calculations."""
import os
import numpy as np
from xml.etree import ElementTree
from math import *
import bluesky as bs
from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \
kts, lbs, inch, sqft, fpm, vtas2cas
from performance import esf, phases, calclimits, PHASE
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(data_path='data', verbose=False)
class CoeffBS:
"""
Coefficient class definition : get aircraft-specific coefficients from database
Created by : Isabel Metz
References:
- D.P. Raymer. Aircraft Design: A Conceptual Approach. AIAA Education Series.
American Institute of Aeronautics and Astronautics, Inc., Reston, U.S, fifth edition, 2012.
- R. Babikian. The Historical Fuel Efficiency Characteristics of Regional Aircraft from
Technological, Operational, and Cost Perspectives. Master's Thesis, Massachusetts
Institute of Technology, Boston, U.S.
"""
def __init__(self):
return
from bluesky import settings
from bluesky.ui import palette
from bluesky.ui.radarclick import radarclick
from bluesky.ui.qtgl import console
from bluesky.ui.qtgl.customevents import ACDataEvent, RouteDataEvent
from bluesky.tools.aero import ft, nm, kts
from bluesky.tools import geo
from bluesky.navdatabase import load_aptsurface, load_coastlines
from .glhelpers import ShaderSet, ShaderProgram, VertexAttributeObject, Font, \
GLBuffer, Circle, Rectangle, Texture
# Register settings defaults
settings.set_variable_defaults(gfx_path='data/graphics',
text_size=13,
apt_size=10,
wpt_size=10,
ac_size=16,
asas_vmin=200.0,
asas_vmax=500.0)
palette.set_default_colors(aircraft=(0, 255, 0),
aptlabel=(220, 250, 255),
aptsymbol=(148, 178, 235),
background=(0, 0, 0),
coastlines=(85, 85, 115),
conflict=(255, 160, 0),
pavement=(160, 160, 160),
polys=(0, 0, 255),
previewpoly=(0, 204, 255),
route=(255, 0, 255),
runways=(100, 100, 100),
""" Airborne Separation Assurance System. Implements CD&R functionality together with
separate conflict detection and conflict resolution modules."""
import numpy as np
import bluesky as bs
from bluesky import settings
from bluesky.tools.simtime import timed_function
from bluesky.tools.aero import ft, nm
from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters
# Register settings defaults
settings.set_variable_defaults(prefer_compiled=False, asas_dt=1.0,
asas_dtlookahead=300.0, asas_mar=1.2,
asas_pzr=5.0, asas_pzh=1000.0,
asas_vmin=200.0, asas_vmax=500.0)
# Import default CD methods
StateBasedCD = False
if settings.prefer_compiled:
try:
from . import casas as StateBasedCD
print('StateBasedCD: using compiled version.')
except ImportError:
print('StateBasedCD: using default Python version, no compiled version for this platform.')
if not StateBasedCD:
print('StateBasedCD: using Python version.')
from . import StateBasedCD
# Import default CR methods
from . import DoNothing
from . import Eby
import numpy as np
import OpenGL.GL as gl
from ctypes import c_float, c_int, Structure
# Local imports
import bluesky as bs
from bluesky import settings
from bluesky.tools.aero import ft, nm, kts
from bluesky.sim.qtgl import PanZoomEvent, PanZoomEventType, MainManager as manager
from bluesky.navdb import load_aptsurface, load_coastlines
from .glhelpers import BlueSkyProgram, RenderObject, Font, UniformBuffer, \
update_buffer, create_empty_buffer
# Register settings defaults
settings.set_variable_defaults(text_size=13,
apt_size=10,
wpt_size=10,
ac_size=16)
# Static defines
MAX_NAIRCRAFT = 10000
MAX_NCONFLICTS = 25000
MAX_ROUTE_LENGTH = 100
MAX_POLYPREV_SEGMENTS = 100
MAX_ALLPOLYS_SEGMENTS = 2000
MAX_CUST_WPT = 1000
MAX_TRAILLEN = MAX_NAIRCRAFT * 1000
REARTH_INV = 1.56961231e-7
# Colors
red = (255, 0, 0)
import datetime
import time
# Local imports
import bluesky as bs
from bluesky import settings, stack
from bluesky.tools import datalog, areafilter, plugin, plotter
# Minimum sleep interval
MINSLEEP = 1e-3
onedayinsec = 24 * 3600 # [s] time of one day in seconds for clock time
# Register settings defaults
settings.set_variable_defaults(simdt=0.05, simevent_port=10000, simstream_port=10001)
def Simulation(detached):
""" Return Simulation object either in normal network-attached mode
or detached mode.
"""
if detached:
from bluesky.network.detached import Node
else:
from bluesky.network.node import Node
class SimulationClass(Node):
''' The simulation object. '''
def __init__(self):
super(SimulationClass, self).__init__(settings.simevent_port,
""" Autocomplete filenames in the BlueSky console."""
import glob
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(scenario_path='scenario')
previous_g = ''
# Case insensitive file search
def iglob(pattern):
def either(c):
return '[%s%s]' % (c.lower(), c.upper()) if c.isalpha() else c
return glob.glob(''.join(map(either, pattern)))
def reset():
global previous_g
previous_g = ''
def complete(cmd):
""" Command line IC + filename completion function """
lcmd = cmd.upper().split()
newcmd = cmd
displaytext = ''
if lcmd[0] in ['IC', 'BATCH', 'CALL', 'PCALL']:
global previous_g
g = settings.scenario_path
Xavier Olive, 2018
Joost Ellerbroek, 2018
"""
import time
import requests
import numpy as np
from os import path
try:
import cPickle as pickle
except ImportError:
import pickle
from bluesky import stack, settings, traf, scr
from bluesky.tools import RegisterElementParameters, TrafficArrays, cachefile
settings.set_variable_defaults(opensky_user=None, opensky_password=None)
# Globals
actypedb_version = 'v20180126'
reader = None
actypes = dict()
def init_plugin():
global reader
reader = OpenSkyListener()
# Load aircraft type database
get_actypedb()
config = {
'plugin_name': 'OPENSKY',
""" Implementation of BlueSky's plugin system. """
import ast
from os import path
import sys
from glob import glob
import imp
import bluesky as bs
from bluesky import settings
from bluesky.tools import varexplorer as ve
# Register settings defaults
settings.set_variable_defaults(plugin_path='plugins', enabled_plugins=['datafeed'])
# Dict of descriptions of plugins found for this instance of bluesky
plugin_descriptions = dict()
# Dict of loaded plugins for this instance of bluesky
active_plugins = dict()
class Plugin(object):
def __init__(self, fname):
fname = path.normpath(path.splitext(fname)[0].replace('\\', '/'))
self.module_path, self.module_name = path.split(fname)
self.module_imp = fname.replace('/', '.')
self.plugin_doc = ''
self.plugin_name = ''
self.plugin_type = ''
self.plugin_stack = []
def check_plugin(fname):
plugin = None
with open(fname, 'rb') as f:
from bluesky import settings
if not settings.node_only:
from bluesky.sim.qtgl.mainmanager import MainManager
from bluesky.ui.qtgl import Gui
from bluesky.tools.network import StackTelnetServer
if __name__ == "__main__":
print(" ***** BlueSky Open ATM simulator *****")
print("Distributed under GNU General Public License v3")
# Global gui object for easy access in interactive python shell
gui = None
# Register settings defaults
settings.set_variable_defaults(telnet_port=8888)
# Create custom system-wide exception handler. For now it replicates python's
# default traceback message. This was added to counter a new PyQt5.5 feature
# where unhandled exceptions would result in a qFatal with a very uninformative
# message.
def exception_handler(exc_type, exc_value, exc_traceback):
traceback.print_exception(exc_type, exc_value, exc_traceback)
sys.exit()
sys.excepthook = exception_handler
# =============================================================================
# Start the mainloop (and possible other threads)
''' Load visual data from text files.'''
import os
from math import cos, radians, degrees, sqrt, atan2, sin, asin
from zipfile import ZipFile
import numpy as np
from bluesky import settings
## Default settings
settings.set_variable_defaults(navdata_path='data/navdata')
REARTH_INV = 1.56961231e-7
def load_coastline_txt():
# -------------------------COASTLINE DATA----------------------------------
# Init geo (coastline) data and convert pen up/pen down format of
# coastlines to numpy arrays with lat/lon
coast = []
clat = clon = 0.0
with open(os.path.join(settings.navdata_path, 'coastlines.dat'), 'r') as f:
print("Reading coastlines.dat")
for line in f:
line = line.strip()
if not (line == "" or line[0] == '#'):
arg = line.split()
if len(arg) == 3:
lat, lon = float(arg[1]), float(arg[2])
if arg[0] == 'D':
coast.append([clat, clon, lat, lon])
clat, clon = lat, lon
# Sort the line segments by longitude of the first vertex
from .windsim import WindSim
from .conditional import Condition
from .trails import Trails
from .adsbmodel import ADSB
from .asas import ASAS
from .pilot import Pilot
from .autopilot import Autopilot
from .activewpdata import ActiveWaypoint
from .turbulence import Turbulence
from .trafficgroups import TrafficGroups
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(performance_model='openap', snapdt=1.0, instdt=1.0, skydt=1.0, asas_pzr=5.0, asas_pzh=1000.0)
if settings.performance_model == 'bada':
try:
print('Using BADA Performance model')
from .performance.bada.perfbada import PerfBADA as Perf
except Exception as err:# ImportError as err:
print(err)
print('Falling back to Open Aircraft Performance (OpenAP) model')
settings.performance_model = "openap"
from .performance.openap import OpenAP as Perf
elif settings.performance_model == 'openap':
print('Using Open Aircraft Performance (OpenAP) model')
from .performance.openap import OpenAP as Perf
else:
print('Using BlueSky legacy performance model')
""" BlueSky Datalogger """
# ToDo: Add description in comments
import os
import numbers
from datetime import datetime
import numpy as np
from bluesky import settings, stack
import bluesky as bs
# Register settings defaults
settings.set_variable_defaults(log_path='output')
logprecision = '%.8f'
# Dict to contain the definitions of periodic loggers
periodicloggers = dict()
# Dict to contain all loggers (also the periodic loggers)
allloggers = dict()
def registerLogParameters(name, dataparent):
if name not in allloggers:
allloggers[name] = CSVLogger(name)
allloggers[name].dataparents.append(dataparent)
return allloggers[name]
""" BlueSky aircraft performance calculations using BADA 3.xx."""
import numpy as np
import bluesky as bs
from bluesky.tools.aero import kts, ft, g0, a0, T0, gamma1, gamma2, beta, R
from bluesky.tools.dynamicarrays import DynamicArrays, RegisterElementParameters
from performance import esf, phases, calclimits, PHASE
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(perf_path_bada='data/coefficients/BADA',
verbose=False)
import bada_coeff
if not bada_coeff.init(settings.perf_path_bada):
raise ImportError(
'BADA performance model: Error loading BADA files from ' +
settings.perf_path_bada + '!')
else:
print 'Using BADA performance model.'
class PerfBADA(DynamicArrays):
"""
Aircraft performance implementation based on BADA.
Methods:
reset() : clear current database
create(actype) : initialize new aircraft with performance parameters
delete(idx) : remove performance parameters from deleted aircraft
perf() : calculate aircraft performance
limits() : calculate flight envelope
AMANEventType, NUMEVENTS
from .mainwindow import MainWindow, Splash
from .docwindow import DocWindow
from .radarwidget import RadarWidget
from .nd import ND
print('Using Qt ' + QT_VERSION_STR + ' for windows and widgets')
# Qt smaller than 5.6.2 needs a different approach to pinch gestures
correct_pinch = False
if QT_VERSION <= 0x050600:
import platform
correct_pinch = platform.system() == 'Darwin'
# Register settings defaults
settings.set_variable_defaults(scenario_path='scenario')
class Gui(QApplication):
modes = ['Init', 'Operate', 'Hold', 'End']
def __init__(self):
super(Gui, self).__init__([])
self.acdata = ACDataEvent()
self.routedata = RouteDataEvent()
self.radarwidget = None
self.mousedragged = False
self.mousepos = (0, 0)
self.prevmousepos = (0, 0)
self.panzoomchanged = False
self.simt = 0.0
""" External control plugin for Machine Learning applications. """ # Import the global bluesky objects. Uncomment the ones you need from bluesky import stack, sim, traf, settings, tools #, net #, navdb, traf, sim, scr, tools import numpy as np import collections import time from bluesky.traffic import autopilot from gym import spaces from ray.rllib.utils.policy_client import PolicyClient settings.set_variable_defaults(n_ac=1, training_enabled=True, acspd=250, nr_nodes=4, min_lat = 51 , max_lat = 54, min_lon =2 , max_lon = 8, n_neighbours=2 ) print(settings.n_ac) client_mc = None reward = None idx_mc = None reset_bool = True eid = None obs = None prev_obs = None connected = False first_time = None done = None delete_dict = None done_count = 0 lat_eham = 52.18 lon_eham = 4.45 ### Initialization function of your plugin. Do not change the name of this ### function, as it is the way BlueSky recognises this file as a plugin. # Additional initilisation code
''' Traffic OpenGL visualisation. '''
import numpy as np
from bluesky.ui.qtgl import glhelpers as glh
import bluesky as bs
from bluesky.tools import geo
from bluesky import settings
from bluesky.ui import palette
from bluesky.tools.aero import ft, nm, kts
# Register settings defaults
settings.set_variable_defaults(
text_size=13, ac_size=16,
asas_vmin=200.0, asas_vmax=500.0)
palette.set_default_colours(
aircraft=(0, 255, 0),
conflict=(255, 160, 0),
route=(255, 0, 255),
trails=(0, 255, 255))
# Static defines
MAX_NAIRCRAFT = 10000
MAX_NCONFLICTS = 25000
MAX_ROUTE_LENGTH = 500
ROUTE_SIZE = 500
TRAILS_SIZE = 1000000
class Traffic(glh.RenderObject, layer=100):
''' Traffic OpenGL object. '''
""" BlueSky aircraft performance calculations using BADA 3.xx."""
import numpy as np
import bluesky as bs
from bluesky.tools.simtime import timed_function
from bluesky.tools.aero import kts, ft, g0, vtas2cas
from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters
from bluesky.traffic.performance.legacy.performance import esf, phases, calclimits, PHASE
from bluesky import settings
from . import coeff_bada
# Register settings defaults
settings.set_variable_defaults(perf_path_bada='data/performance/BADA',
performance_dt=1.0,
verbose=False)
if not coeff_bada.init(settings.perf_path_bada):
raise ImportError(
'BADA performance model: Error loading BADA files from ' +
settings.perf_path_bada + '!')
else:
print('Using BADA performance model.')
class PerfBADA(TrafficArrays):
"""
Aircraft performance implementation based on BADA.
Methods:
reset() : clear current database
create(actype) : initialize new aircraft with performance parameters
delete(idx) : remove performance parameters from deleted aircraft
from bluesky import settings
# Register settings defaults
settings.set_variable_defaults(prefer_compiled=False)
from .walltime import Timer
from .trafficarrays import RegisterElementParameters, TrafficArrays
from .signal import Signal
if settings.prefer_compiled:
try:
from . import cgeo as geo
print('Using compiled geo functions')
except ImportError:
from . import geo
print('Using Python-based geo functions')
else:
from . import geo
print('Using Python-based geo functions')
from .trafficarrays import RegisterElementParameters, TrafficArrays
from . import cachefile
try:
from PyQt5.QtCore import QObject, QEvent, QTimer, pyqtSignal, \
QCoreApplication as qapp
except ImportError:
from PyQt4.QtCore import QObject, QEvent, QTimer, pyqtSignal, \
QCoreApplication as qapp
# Local imports
from bluesky import settings
from .simevents import SimStateEventType, SimQuitEventType, BatchEventType, \
BatchEvent, StackTextEvent, SimQuitEvent, SetNodeIdType, \
SetActiveNodeType, AddNodeType
Listener.fileno = lambda self: self._listener._socket.fileno()
# Register settings defaults
settings.set_variable_defaults(max_nnodes=cpu_count())
def split_scenarios(scentime, scencmd):
start = 0
for i in range(1, len(scencmd) + 1):
if i == len(scencmd) or scencmd[i][:4] == 'SCEN':
scenname = scencmd[start].split()[1].strip()
yield (scenname, scentime[start:i], scencmd[start:i])
start = i
class MainManager(QObject):
instance = None
# Signals
nodes_changed = pyqtSignal(str, tuple, int)
activenode_changed = pyqtSignal(tuple, int)
