import system # Create the computer system and power it up. sys = system.System() sys.power_on()
def new_system(self):
import system
system = system.System(rc=self)
log.debug('loaded system {!r}'.format(system))
return system
def Steuerung():
overtrieb = ver.Vertrieb(files_dict)
oprot.SchreibeInProtokoll('Vertrieb wurde angelegt')
oantrag = antrag.Antrag(files_dict)
oprot.SchreibeInProtokoll('Anträge wurden angelegt')
file_vertrieb = overtrieb.file_vertrieb
oantrag.LegeVerriebstabelleFest(file_vertrieb)
#oantrag_oe = oe_antrag.OE_Antarg(files_dict)
osys = system.System(files_dict)
file_system_antrag = oantrag.file_system_antrag
osys.LegeAntragstabelleFest(file_system_antrag)
obil = bil.Bilanz(files_dict)
oprot.SchreibeInProtokoll('Bilanz wurde angelegt')
obil.Init_Bilanz(jahr_beginn)
okap = kap.Kapitalanlagen(files_dict)
oprot.SchreibeInProtokoll('Kapitalanlagen wurden angelegt')
okap.Init_KA(jahr_beginn)
jahr = int(jahr_beginn)
files_dict['jahr_aktuell'] = jahr
ka_sa_dict.clear()
LeseAusFensterMainAlleEingaben()
wSpielwindow.label_Jahr.setText(str(jahr))
#die Tabelle im Dialog mit Ergebnissen der Bilanz wird angelegt:
LegeBilanzTabelleAn(obil)
#die Tabelle im Dialog mit Ergebnissen der GuV wird angelegt:
LegeGuVTabelleAn(obil)
#solange im Spielwindow okay geclickt wird, dann wird ein Jahr weiter gespielt:
while wSpielwindow.exec_() == widgets.QDialog.Accepted:
files_dict['jahr_aktuell'] = jahr
if Kontrollen() == False:
continue
#es werden alle Eingaben aus dem Dialog ausgelesen:
LeseAusFensterSpielAlleEingaben()
von = str(jahr) + '01' + '01'
bis = str(jahr) + '12' + '31'
LeseAusFensterSpielAlleEingaben()
okap.Init_SA(ka_sa_dict)
obil.ErstelleBilanzAnfang(jahr)
overtrieb.SchreibeNeugeschaeft(vertrieb_dict)
okap.Beginn(jahr)
okap.Fortschreibung(jahr)
osys.Fortschreibung(von, bis)
oantrag.LeseVertrieb(jahr)
osys.Policiere(jahr)
osys.ErstelleStatistik(von, bis)
obil.ErstelleBilanzEnde(jahr)
okap.ZeichneKapitalanlagen(jahr)
jahr += 1
files_dict['jahr_aktuell'] = jahr
LegeBilanzTabelleAn(obil) #Ergebnisse der Bilanz
LegeGuVTabelleAn(obil) #Ergebnisse der GuV
wSpielwindow.label_Jahr.setText(str(jahr))
file_grafik = files_dict.get('grafik_file_entwicklung_renten')
icon = gui.QIcon(file_grafik)
wSpielwindow.pushButton_Entwicklung_Renten.setIcon(icon)
hoehe = LeseGroesseEinesButtonsAus(
wSpielwindow.pushButton_Entwicklung_Renten).get('hoehe') - 10
breite = LeseGroesseEinesButtonsAus(
wSpielwindow.pushButton_Entwicklung_Renten).get('breite') - 10
wSpielwindow.pushButton_Entwicklung_Renten.setIconSize(
core.QSize(breite, hoehe))
file_grafik = files_dict.get('file_grafik_zsk')
icon = gui.QIcon(file_grafik)
wSpielwindow.pushButton_ZSK.setIcon(icon)
hoehe = LeseGroesseEinesButtonsAus(
wSpielwindow.pushButton_ZSK).get('hoehe') - 10
breite = LeseGroesseEinesButtonsAus(
wSpielwindow.pushButton_ZSK).get('breite') - 10
wSpielwindow.pushButton_ZSK.setIconSize(core.QSize(breite, hoehe))
file_grafik = files_dict.get('grafik_file_statistik_anzahl')
icon = gui.QIcon(file_grafik)
wSpielwindow.pushButton_statistik_anzahl.setIcon(icon)
hoehe = LeseGroesseEinesButtonsAus(
wSpielwindow.pushButton_statistik_anzahl).get('hoehe') - 10
breite = LeseGroesseEinesButtonsAus(
wSpielwindow.pushButton_statistik_anzahl).get('breite') - 10
wSpielwindow.pushButton_statistik_anzahl.setIconSize(
core.QSize(breite, hoehe))
oprot.SchreibeInProtokoll("ENDE erreicht!!!")
print("**** Ende ****")
def main():
sys = system.System()
sys.record(duration=20)
sys.calibrate()
import system
import inputmod
import outputmod
import environment
import sys
environmentvariable = environment.Environment()
system = system.System(environmentvariable)
inputmodule = inputmod.InputModule(sys.argv[1], system)
inputmodule.ReadInput()
system.CalculateEquilibrium()
outputfile = raw_input('Enter output filename: ')
outputmodule = outputmod.OutputModule(outputfile, system)
outputmodule.WriteOutput()
def initialize_system(self):
sys = system.System()
mol = sys.add_macromolecule(name="Temp", sequence="LALALAND")
return mol
def initialize_system():
sys = system.System()
return sys.add_macromolecule("MEGAMAN", "test_molecule")
def main():
solver = lambda sys, x0: continuation.newton_solver(
sys, x0, finite_differences_stepsize=FINITE_DIFFERENCES_STEPSIZE)
""" SCIPY SOLVER """
# def solver(sys, x0):
# solution = scipy.optimize.root(sys, x0, tol=1e-6)
# print("Solution vector: ", solution.x)
# print("Solution value: ", solution.fun)
# print("Parameter: ", solution.x[0])
# if solution.success:
# return solution.x
# return None
controller = system.ProportionalController(KP, [1, 0], [0, 1])
blackbox_system = system.System([1, 0], duffing, TRANSIENT_TIME,
EVALUATION_TIME, 10, controller)
par_0, par_1 = STARTER_PARAMS
signal_0 = blackbox_system(par_0)
signal_1 = blackbox_system(par_1)
# Discretisation size, initial signal, period of initial signal
discretisor = discretise.SplinesDiscretisor(DSIZE)
starters = [
build_continuation_vector(signal_0, discretisor, par_0),
build_continuation_vector(signal_1, discretisor, par_1),
]
continuer = DuffingContinuation(blackbox_system, discretisor)
continuation_solutions, message = continuer.run_continuation(
starters, solver=solver, stepsize=STEPSIZE, par_range=[0.5, 2])
print(message)
# Parse output
parameter_points = [s.parameter for s in continuation_solutions]
cbc_amplitudes = [get_amplitude(s) for s in continuation_solutions]
analytic_amplitudes = [
get_analytic_amplitude(a, w)
for a, w in zip(cbc_amplitudes, parameter_points)
]
# Plot results
fig, ax = plt.subplots()
ax.plot(parameter_points, cbc_amplitudes, color="k")
ax.set_xlabel("Forcing frequency")
ax.set_ylabel("Response amplitude")
plt.show()
# Plot results
fig, ax = plt.subplots()
ax.plot(
parameter_points,
cbc_amplitudes,
marker="x",
color="k",
label="CBC results",
)
ax.plot(
parameter_points,
analytic_amplitudes,
marker="x",
label="Analytic results",
)
ax.legend()
ax.set_xlabel("Forcing amplitude")
ax.set_ylabel("Response amplitude")
plt.show()
model.cortical = spa.Cortical(spa.Actions('result = inA * inB'),
synapse=pstc,
neurons_cconv=n_cconv)
input_A = nengo.Node(None, size_in=D)
input_B = nengo.Node(None, size_in=D)
output = nengo.Node(None, size_in=D)
nengo.Connection(input_A, model.inA.state.input, synapse=None)
nengo.Connection(input_B, model.inB.state.input, synapse=None)
nengo.Connection(model.result.state.output, output, synapse=None)
sim = nengo.Simulator(model, dt=dt)
# convert this model into cores and messages
import system
s = system.System(model, sim)
# Now run the model with a fixed input to evaluate it
T = 0.2
dt = sim.dt
steps = int(T/dt)
# generate the random input
vocab = spa.Vocabulary(D, rng=np.random.RandomState(seed=seed))
A = vocab.parse('A').v
B = vocab.parse('B').v
ideal_result = vocab.parse('A*B').v
data_A = []
data_B = []
def __init__(self, rowcount = NO_OF_ROWS, rowlength = ROW_LENGTH, rotation = 90):
self.Event = threading.Event()
self.threadLock = threading.Lock()
threading.Thread.__init__(self, name='mytft')
self.q = Queue(maxsize=12)
self.rowcount = rowcount+1
self.rowlength = rowlength
self.last_prog_row = LAST_PROG_ROW
self.rotation = rotation
# Setup which pins we are using to control the hardware display
if protoboard:
# These are for the 2.2" tft soldered onto proto board.
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D18)
reset_pin = digitalio.DigitalInOut(board.D23)
else: # wired tft
cs_pin = digitalio.DigitalInOut(board.CE0)
dc_pin = digitalio.DigitalInOut(board.D17)
reset_pin = digitalio.DigitalInOut(board.D23)
# Setup SPI bus using hardware SPI:
spi = board.SPI()
self.disp = ili9341.ILI9341(spi, rotation=0,cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=BAUDRATE)
if self.disp.rotation % 180 == 90:
height = self.disp.width # we swap height/width to rotate it to landscape!
width = self.disp.height
else:
width = self.disp.width # we swap height/width to rotate it to landscape!
height = self.disp.height
self.image = Image.new("RGB", (width, height)) # Draw and text
self.draw = ImageDraw.Draw(self.image) # Get drawing object to draw on image.
# Load a TTF Font
self.big_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", BIGFONTSIZE)
self.time_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", SMALLFONTSIZE)
# self.disp = TFT.ILI9341(DC, rst=RST, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=64000000))
# self.disp.begin()
# self.disp.clear() # black
self.old_text = [' ' for i in range(self.rowcount)] # used for clearing oled text
# self.font = ImageFont.load_default()
# self.font = ImageFont.truetype('binary/morningtype.ttf',FONTSIZE)
# self.font = ImageFont.truetype('binary/secrcode.ttf',FONTSIZE)
# self.font = ImageFont.truetype('binary/DS-DIGI.TTF',FONTSIZE)
# self.font = [ImageFont.load_default() for i in range(self.rowcount)]
# self.fontsize = [DEFAULT_FONT_SIZE for i in range(self.rowcount)]
# self.fontsize[BIG_ROW] = 36
# if TESTING:
# self.fontsize[2] = 24
# self.fontsize[3] = 24
# for i in range(self.rowcount):
# self.font[i] = ImageFont.truetype(FONT_DIR+'Hack-Regular.ttf',self.fontsize[i])
# setup row colours
self.rowcolour = [WHITE for i in range(self.rowcount)] # set the defaults
self.rowcolour[0] = YELLOW
# self.rowcolour[self.rowcount-1] = BLUE
# self.calc_offsets()
# GPIO.setmode(GPIO.BCM)
# GPIO.setup(LED,GPIO.OUT)
# pi_pwm=GPIO.PWM(LED,100) # pin number, frquency
# pi_pwm.start(100) # duty cycle
# GPIO.setup(L_BUTTON, GPIO.IN, pull_up_down = GPIO.PUD_UP)
# GPIO.setup(R_BUTTON, GPIO.IN, pull_up_down = GPIO.PUD_UP)
self.myalarm = alarm.Alarm()
self.mypwm = pwm.PWM()
self.mysystem = system.System()
# Python standard library
import sys
sys.path.append(
'/home/prestonh/Desktop/Programming/gamedev/shoot/shoot/entity')
sys.path.append(
'/home/prestonh/Desktop/Programming/gamedev/shoot/shoot/component')
sys.path.append(
'/home/prestonh/Desktop/Programming/gamedev/shoot/shoot/system')
# Game
import system
if __name__ == "__main__":
system = system.System()
sys.exit(system.Run())
def draw_menu(stdscr):
k = 0
zoom = 200
selected_object = 4
show_info = True
# Declaration of strings
title = "JUNO DASHBOARD"
statusbarstr = " q: exit u: update n: next object i: toggle info +/-: zoom"
# Clear and refresh screen
stdscr.clear()
curses.curs_set(0)
# Start colors in curses
curses.start_color()
curses.init_pair(1, curses.COLOR_CYAN, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_WHITE)
curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLACK)
# Set up system
sol_system = system.System()
sol_system.set_observer_code("672@399")
sol_system.add_object("Io", "501", "4,20,21", "\u00B0")
sol_system.add_object("Europa", "502", "4,20,21", "\u00B0")
sol_system.add_object("Ganymede", "503", "4,20,21", "\u00B0")
sol_system.add_object("Callisto", "504", "4,20,21", "\u00B0")
sol_system.add_object("Jupiter", "599", "4,20,21", "\u00A4")
sol_system.add_object("Juno", "-61", "4,20,21", "Y")
# Object notes
sol_system.get_object("Juno").notes = "Launch: Aug 5, 2011 16:25 UTC\nEarth Flyby: Oct 9, 2013 19:21:25 UTC\nArrive Jupiter: Jul 5, 2016 02:30 UTC\nDimensions: 20m\nSolar-powered, spin-stabilized spacecraft\nThree 2x9m solar panels around hexagonal bus\nGravity/radio science system\nSix-wavelength microwave radiometer\nVector magnetometer\nPlasma and energetic particle detectors\nRadio/plasma wave experiment\nUltraviolet imager/spectrometer\nInfrared imager/spectrometer\nBipropellant engine\nRCS thrusters"
# First update
sol_system.set_datetime_utc(datetime.utcnow())
sol_system.update()
jupiter = sol_system.get_object("Jupiter")
# Loop where k is the last character pressed
while (k != ord('q')):
# Check select next object key
if (k == ord('n')):
selected_object += 1
if (selected_object == len(sol_system.objects)):
selected_object = 0
# Check info toggle key
if (k == ord('i')):
if (show_info):
show_info = False
elif (not show_info):
show_info = True
# Check zoom key
if (k == ord('+')):
if (zoom == 1):
zoom = 0
zoom += 20
zoom = int(zoom)
elif (k == ord('-')):
zoom -= 20
zoom = int(zoom)
if (zoom < 1):
zoom = 1
# Initialization
stdscr.clear()
height, width = stdscr.getmaxyx()
# Render title
stdscr.attron(curses.color_pair(2))
stdscr.attron(curses.A_BOLD)
stdscr.addstr(0, 0, title)
stdscr.attroff(curses.color_pair(2))
stdscr.attroff(curses.A_BOLD)
# Render status bar
stdscr.attron(curses.color_pair(3))
stdscr.addstr(height-1, 0, statusbarstr)
stdscr.addstr(height-1, len(statusbarstr), " " * (width - len(statusbarstr) - 1))
stdscr.attroff(curses.color_pair(3))
# Update system
if (k == ord('u')):
sol_system.set_datetime_utc(datetime.utcnow())
sol_system.update()
# Render time
date = jupiter.get_value("Date__(UT)__HR:MN:SC.fff")
lt = jupiter.get_value("1-way_down_LT")
stdscr.addstr(0, width-len(date + " (UTC)")-1, date + " (UTC)")
# Center calculation
center_x = int(width // 2)
center_y = int(height // 2)
# Render display Box
stdscr.addstr(height - 4, 6, "\u2517") # lower-left
stdscr.addstr(3, width - 6, "\u2513") # upper-right
stdscr.addstr(height - 4, width - 8, "\u251B") # lower-right
stdscr.addstr(3, 6, "\u250F") # upper-left
stdscr.addstr(height - 3, 6, str(zoom) + "x (chars/deg)")
# Render jupiter bounds
jupiter_radius = zoom / 100 / 2
stdscr.addstr(center_y, center_x + int(jupiter_radius), "*") # right
stdscr.addstr(center_y, center_x - int(jupiter_radius), "*") # left
stdscr.addstr(center_y + int(jupiter_radius / 2), center_x, "*") # down
stdscr.addstr(center_y - int(jupiter_radius / 2), center_x, "*") # up
stdscr.addstr(center_y - int(jupiter_radius * 0.71 / 2), center_x + int(jupiter_radius * 0.71), "*") # upper-right
stdscr.addstr(center_y - int(jupiter_radius * 0.71 / 2), center_x - int(jupiter_radius * 0.71), "*") # upper-left
stdscr.addstr(center_y + int(jupiter_radius * 0.71 / 2), center_x + int(jupiter_radius * 0.71), "*") # lower-right
stdscr.addstr(center_y + int(jupiter_radius * 0.71 / 2), center_x - int(jupiter_radius * 0.71), "*") # lower-left
# Render objects
for obj in sol_system.objects:
offset_deg_x = float(obj.get_value("Azi_(a-app)")) - float(jupiter.get_value("Azi_(a-app)"))
offset_deg_y = float(obj.get_value("Elev_(a-app)")) - float(jupiter.get_value("Elev_(a-app)"))
pos_x = center_x + int(offset_deg_x * zoom)
pos_y = center_y - int(offset_deg_y * (zoom / 2))
if (pos_x > 3 and pos_x < width - len(obj.name) - 3 and pos_y > 3 and pos_y < height - 3):
stdscr.addstr(pos_y, pos_x, obj.symbol)
if (sol_system.objects[selected_object].name == obj.name):
stdscr.addstr(pos_y, pos_x + 2, obj.name.upper(), curses.color_pair(4))
else:
stdscr.addstr(pos_y, pos_x + 2, obj.name.upper(), curses.color_pair(1))
# Render selected object data
obj = sol_system.objects[selected_object]
z_distance = float(obj.get_value("delta")) - float(jupiter.get_value("delta"))
stdscr.addstr(2, 0, obj.name)
stdscr.addstr(3, 0, "Apparent Azi/Elev: " + obj.get_value("Azi_(a-app)") + ", " + obj.get_value("Elev_(a-app)"), curses.color_pair(1))
stdscr.addstr(4, 0, "Distance: " + obj.get_value("delta") + " km", curses.color_pair(1))
stdscr.addstr(5, 0, "1-way LT: " + obj.get_value("1-way_down_LT") + " min", curses.color_pair(1))
stdscr.addstr(6, 0, "Z-distance from Jupiter: " + str(z_distance) + " km", curses.color_pair(1))
# Extra info
if (show_info):
stdscr.addstr(8, 0, obj.notes, curses.color_pair(1))
# Refresh screen
stdscr.refresh()
# Wait for next input
k = stdscr.getch()
def _build_system(self):
self._system = system.System()
self._build_system_blocks()
self._system.sampling_frequency = self._data.sampling_freq
def low_alpha_mode1():
magnets = system.System()
magnets.load_state(2.05, down=True)
modes = magnets.labeled_spectra()
for mode in modes:
print(modes[mode][0])
import os
import keyboard
import mouse
import system
import window
import gui
if __name__ == "__main__":
#x = input("Write over old data? (y/n) ")
x = 'y'
msg = "testing thread from main.py"
kb = keyboard.Keyboard(erase=x)
mo = mouse.Mouse(erase=x)
sy = system.System(erase=x)
wn = window.Window(erase=x)
dash = gui.Gui()
th0 = th.Thread(target=kb.data_stream, daemon=True)
th1 = th.Thread(target=mo.data_stream, daemon=True)
th2 = th.Thread(target=sy.data_stream, daemon=True)
th3 = th.Thread(target=wn.data_stream, daemon=True)
try:
"""
with cf.ThreadPoolExecutor() as exe:
th1 = exe.submit(kb.data_stream)
th2 = exe.submit(mo.data_stream)
th3 = exe.submit(sy.data_stream)
th4 = exe.submit(wn.data_stream)
"""
def run(time, n, radio):
startTime = datetime.now()
list = []
for i in range(n):
list.append(dk.Disk(str(i), radius = radio))
sistema = sy.System(time, list)
sistema.initialize()
sistema.create_events(sistema.particles, [])
sistema.build_binary_heap()
sistema.main_loop()
tiempos = []
for i in range(len(sistema.res_mean_vel_2)):
tiempos.append(i)
print (datetime.now() - startTime)
pos = sistema.lista_grande
print("FREE PATH VALUE: ")
print(sistema.l2)
return
##############################################
fig2, ax2 = plt.subplots()
ax2.plot(tiempos, sistema.res_mean_vel_2, '-')
ax2.set(xlabel='Evento', ylabel='Res',
title='We dont know')
ax2.grid()
################################################
fig = plt.figure()
ax = plt.axes(xlim=(0, sy.LX), ylim=(0, sy.LY))
ax.set_facecolor('k')
ax.set(xlabel='x', ylabel='y',
title=str(n)+" Partículas")
ax.set_aspect('equal')
patches = []
for i in range(len(pos)):
x, y, z = random.uniform(0, 1), random.uniform(0, 1), random.uniform(0.5, 1)
color_t = (x,y,z)
patches.append(plt.Circle((5,5), radio, color = color_t))
def init():
for i in range(len(patches)):
x0 = pos[i][0][0]
y0 = pos[i][1][0]
patches[i].center = (x0, y0)
ax.add_patch(patches[i])
a = tuple(patches)
return a
def animate(i):
j = 0
for patch in patches:
x, y = patch.center
x = pos[j][0][i]
y = pos[j][1][i]
patch.center = (x,y)
j += 1
a = tuple(patches)
return a
anim = animation.FuncAnimation(fig, animate,
init_func=init,
frames=len(pos[0][0]),
interval=20,
blit=True)
plt.show()
def __init__(self):
self.logger = logging.getLogger(__name__)
self.displaytype = keys.display
self.cloud = keys.cloud
if self.displaytype == 'oled':
try:
import oled
self.display = oled.Oled()
self.display.writerow(TITLE_ROW, "Starting up")
except:
self.logger.error('Oled failed init.')
sys.exit(0)
elif self.displaytype == 'uoled':
try:
import uoled
print('Setting up uoled')
self.display = uoled.Screen()
except:
print('Uoled failed init.')
self.logger.error('Uoled failed init.')
sys.exit(0)
elif self.displaytype == 'uoledada':
try:
import uoledada
print('Setting up uoledada')
self.display = uoledada.Screen()
except:
print('Uoledada failed init.')
self.logger.error('Uoledada failed init.')
sys.exit(0)
elif self.displaytype == 'uoledi2c':
try:
import uoledi2c
print('Setting up uoledi2c')
self.display = uoledi2c.Screen()
except:
print('Uoledi2c failed init.')
self.logger.error('Uoledi2c failed init.')
sys.exit(0)
elif self.displaytype == '7seg':
try:
import sevenseg
self.sevenseg = sevenseg.Sevenseg()
except:
self.logger.error('7seg failed init.')
sys.exit(0)
elif self.displaytype == 'tft':
print("setting up newtft")
try:
import newtft # note newtft based on latest adafruit lib
self.display = newtft.Screen()
except:
self.logger.error('newtft failed init.')
sys.exit(0)
else:
self.logger.error('No display specified.')
print('No display specified')
sys.exit(0)
if self.cloud == 'none':
try:
import dummycloud
self.myCloud = dummycloud.Mydummycloud()
self.display.cloud_type = 'file'
print('Using dummy cloud')
except:
self.display.newwriterow(1, "Dummycloud failed init")
self.logger.error('Dummycloud failed init.')
sys.exit(0)
elif self.cloud == 'ubidots':
try:
import myubidots
self.myCloud = myubidots.Myubidots()
self.display.cloud_type = 'ubidots'
print('Ubidots cloud')
except:
self.display.newwriterow(1, "Ubidots failed init")
self.logger.error('Ubidots failed init.')
sys.exit(0)
elif self.cloud == 'beebotte':
try:
import mybeebotte
self.myCloud = mybeebotte.Mybeebotte(no_sensors=2)
self.display.cloud_type = 'beebotte'
self.display.writerow(
CLOUD_ROW4,
keys.beebotte_variable + ' ' + keys.beebotte_variable2)
print('Beebotte cloud')
except:
self.display.writerow(TITLE_ROW, "Beebotte failed init")
self.logger.error('Beebotte failed init.')
print("Beebotte failed init.", sys.exc_info()[0])
sys.exit(0)
else:
self.logger.error('Cloud type not specified. Check keys file.')
print('Cloud type not specified. Check keys file.')
self.display.cloud_type = 'no cloud'
sys.exit(0)
self.cloud_error = False
try:
self.myDS = DS18B20.DS18B20()
except:
self.display.writerow(1, "Sensor init failed")
self.logger.error('Sensor init failed.')
sys.exit(0)
self.myAlarm = alarm.Alarm()
self.mySystem = system.System()
hostname = self.mySystem.hostname()
self.display.newwriterow(STATUS_ROW, 'Hostname:' + hostname)
self.display.newwriterow(CLOUD_ROW, 'Cloud:' + self.cloud)
self.log_counter = 0
self.cloud_counter = 0
self.display.newwriterow(TITLE_ROW, 'Thermometer')
if BIG_TEXT == False:
self.display.newwriterow(LABELS_ROW, 'Min Now Max ')
import time
import system
import sys
import tkinter as tk
from tkinter import ttk
from tkinter import messagebox
selected_administrator = 0
sy = system.System() # 实例化System对象
# Basic window settings
root = tk.Tk() # 根页面初始化
root.title("超市配送系统")
root.geometry("700x400")
# Main frame
frame_main = ttk.Frame(root, padding="3 3 12 12") # 主页面frame
# Secondry frame
frame_left = ttk.Frame(frame_main) # 左部分frame
frame_right = ttk.Frame(frame_main) # 右部分frame
# Third frame
frame_left_button = ttk.Frame(frame_left,
relief="sunken",
borderwidth=1,
padding="0 0 0 100")
frame_left_clock = ttk.Frame(frame_left)
# Left button
button_order = ttk.Button(frame_left_button, text="订单管理")
button_stock = ttk.Button(frame_left_button, text="库存管理")
button_customer = ttk.Button(frame_left_button, text="客户管理")
button_courier = ttk.Button(frame_left_button, text="配送员管理")
button_administrator = ttk.Button(frame_left_button, text="管理员管理")
def __init__(self):
self.qapp = QApplication([])
super().__init__()
self.setFixedSize(1080, 700)
self.move(100, 10)
self.setWindowTitle(
'Лабораторная работа №5 по моделированию.'
'Жарова ИУ7-73Б'
)
self.normal_label = QLabel('Параметры\nклиентов', self)
self.normal_label.setFixedSize(300, 50)
self.normal_label.move(50, 50)
self.client = 10
self.client_label = QLabel('average =', self)
self.client_label.setFixedSize(100, 50)
self.client_label.move(50, 100)
self.client_line_edit = QLineEdit(str(self.client), self)
self.client_line_edit.setFixedSize(100, 50)
self.client_line_edit.move(120, 100)
self.client_delta = 2
self.client_delta_label = QLabel(' +-', self)
self.client_delta_label.setFixedSize(100, 50)
self.client_delta_label.move(220, 100)
self.client_delta_line_edit = QLineEdit(str(self.client_delta), self)
self.client_delta_line_edit.setFixedSize(100, 50)
self.client_delta_line_edit.move(250, 100)
self.op_label = QLabel('Параметры\nоператоров', self)
self.op_label.setFixedSize(300, 100)
self.op_label.move(380, 20)
self.op1_m = 20
self.op1_m_label = QLabel('average1 =', self)
self.op1_m_label.setFixedSize(100, 50)
self.op1_m_label.move(380, 100)
self.op1_m_line_edit = QLineEdit(str(self.op1_m), self)
self.op1_m_line_edit.setFixedSize(100, 50)
self.op1_m_line_edit.move(460, 100)
self.op1_delta = 5
self.op1_delta_label = QLabel(' +-', self)
self.op1_delta_label.setFixedSize(100, 50)
self.op1_delta_label.move(560, 100)
self.op1_delta_line_edit = QLineEdit(str(self.op1_delta), self)
self.op1_delta_line_edit.setFixedSize(100, 50)
self.op1_delta_line_edit.move(590, 100)
self.op2_m = 40
self.op2_m_label = QLabel('average2 =', self)
self.op2_m_label.setFixedSize(100, 50)
self.op2_m_label.move(380, 160)
self.op2_m_line_edit = QLineEdit(str(self.op2_m), self)
self.op2_m_line_edit.setFixedSize(100, 50)
self.op2_m_line_edit.move(460, 160)
self.op2_delta = 10
self.op2_delta_label = QLabel(' +-', self)
self.op2_delta_label.setFixedSize(100, 50)
self.op2_delta_label.move(560, 160)
self.op2_delta_line_edit = QLineEdit(str(self.op2_delta), self)
self.op2_delta_line_edit.setFixedSize(100, 50)
self.op2_delta_line_edit.move(590, 160)
self.op3_m = 40
self.op3_m_label = QLabel('average3 =', self)
self.op3_m_label.setFixedSize(100, 50)
self.op3_m_label.move(380, 220)
self.op3_m_line_edit = QLineEdit(str(self.op3_m), self)
self.op3_m_line_edit.setFixedSize(100, 50)
self.op3_m_line_edit.move(460, 220)
self.op3_delta = 20
self.op3_delta_label = QLabel(' +-', self)
self.op3_delta_label.setFixedSize(100, 50)
self.op3_delta_label.move(560, 220)
self.op3_delta_line_edit = QLineEdit(str(self.op3_delta), self)
self.op3_delta_line_edit.setFixedSize(100, 50)
self.op3_delta_line_edit.move(590, 220)
self.comp_label = QLabel('Параметры\nкомпьютеров', self)
self.comp_label.setFixedSize(300, 100)
self.comp_label.move(720, 20)
self.comp1 = 15
self.comp1_label = QLabel('const1 =', self)
self.comp1_label.setFixedSize(100, 50)
self.comp1_label.move(720, 100)
self.comp1_m_line_edit = QLineEdit(str(self.comp1), self)
self.comp1_m_line_edit.setFixedSize(100, 50)
self.comp1_m_line_edit.move(785, 100)
self.comp2 = 30
self.comp2_label = QLabel('const2 =', self)
self.comp2_label.setFixedSize(100, 50)
self.comp2_label.move(720, 160)
self.comp2_m_line_edit = QLineEdit(str(self.comp2), self)
self.comp2_m_line_edit.setFixedSize(100, 50)
self.comp2_m_line_edit.move(785, 160)
self.method_label = QLabel('Метод рассчета', self)
self.method_label.setFixedSize(200, 100)
self.method_label.move(920, 14)
self.method_box = QComboBox(self)
self.method_box.addItems(['delta t', 'events'])
self.method_box.setFixedSize(140, 60)
self.method_box.move(920, 90)
self.method_box.currentTextChanged.connect(self.select_method)
self.dt = 0.01
self.dt_label = QLabel('dt =', self)
self.dt_label.setFixedSize(200, 100)
self.dt_label.move(920, 135)
self.dt_line_edit = QLineEdit(str(self.dt), self)
self.dt_line_edit.setFixedSize(100, 50)
self.dt_line_edit.move(960, 160)
self.select_method()
self.n = 300
self.n_label = QLabel('Обработать \nзаявок (n) = ', self)
self.n_label.setFixedSize(100, 50)
self.n_label.move(50, 200)
self.n_line_edit = QLineEdit(str(self.n), self)
self.n_line_edit.setFixedSize(100, 50)
self.n_line_edit.move(140, 200)
self.system = system.System(
client_law=UniformDistributionLaw(a=8, b=12),
op1_law=UniformDistributionLaw(a=15, b=25),
op2_law=UniformDistributionLaw(a=30, b=50),
op3_law=UniformDistributionLaw(a=20, b=60),
comp1_law=ConstantDistributionLaw(c=15),
comp2_law=ConstantDistributionLaw(c=30),
n=self.n, dt=1, method='delta t'
)
result = self.system.calculate()
self.button = QPushButton('Провести рассчет', self)
self.button.setFixedSize(500, 100)
self.button.clicked.connect(self.calculate)
self.button.move(100, 500)
self.result_label = QLabel('Результаты рассчета', self)
self.result_label.setFixedSize(200, 100)
self.result_label.move(760, 280)
self.generated_count_label = QLabel('Количество\nобработанных заявок =', self)
self.generated_count_label.setFixedSize(300, 50)
self.generated_count_label.move(720, 420)
#self.generated_count_label.hide()
self.generated_count_line_edit = QLineEdit(str(result['generated_count']), self)
self.generated_count_line_edit.setFixedSize(100, 50)
self.generated_count_line_edit.move(880, 420)
#self.generated_count_line_edit.hide()
self.processed_count_label = QLabel('Количество\nобработанных заявок =', self)
self.processed_count_label.setFixedSize(300, 50)
self.processed_count_label.move(720, 420)
self.processed_count_label.hide()
self.processed_count_line_edit = QLineEdit(str(result['processed_count']), self)
self.processed_count_line_edit.setFixedSize(100, 50)
self.processed_count_line_edit.move(880, 420)
self.processed_count_line_edit.hide()
self.rejected_count_label = QLabel('Количество\nпропущенных заявок =', self)
self.rejected_count_label.setFixedSize(300, 50)
self.rejected_count_label.move(720, 480)
self.rejected_count_line_edit = QLineEdit(str(result['rejected_count']), self)
self.rejected_count_line_edit.setFixedSize(100, 50)
self.rejected_count_line_edit.move(880, 480)
self.rejected_probability_label = QLabel('Вероятность\nотказа =', self)
self.rejected_probability_label.setFixedSize(300, 50)
self.rejected_probability_label.move(720, 540)
self.rejected_probability_line_edit = QLineEdit(str(round(result['rejected_count'] / (result['generated_count'] + result['rejected_count']), 4)), self)
self.rejected_probability_line_edit.setFixedSize(100, 50)
self.rejected_probability_line_edit.move(880, 540)
outputdir2 = "./output2" # output directory for the simulation results.
outputdir3 = "./output3" # output directory for the simulation results.
outputdir4 = "./output4" # output directory for the simulation results.
outputdir5 = "./output5" # output directory for the simulation results.
sequence = "GMAEDMAADEVTAPPRKVLIISAGASHSVALLSGDIVCSWGRGEDGQLGHGDAEDRPSPTQLSALDGHQIVSVTCGADHTVAYSQSGMEVYSWGWGDFGRLGHGNSSDLFTPLPIKALHGIRIKQIACGDSHCLAVTMEGEVQSWGRNQNGQLGLGDTEDSLVPQKIQAFEGIRIKMVAAGAEHTAAVTEDGDLYGWGWGRYGNLGLGDRTDRLVPERVTSTGGEKMSMVACGWRHTISVSYSGALYTYGWSKYGQLGHGDLEDHLIPHKLEALSNSFISQISGGWRHTMALTSDGKLYGWGWNKFGQVGVGNNLDQCSPVQVRFPDDQKVVQVSCGWRHTLAVTERNNVFAWGRGTNGQLGIGESVDRNFPKIIEALSVDGASGQHIESSNIDPSSGKSWVSPAERYAVVPDETGLTDGSSKGNGGDISVPQTDVKRVRI" # FASTA sequence
resrange = (100, 200
) # Residue range is a tuple in pdb numbering (starts at 1).
num_best_models = 200
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
### Analysis.
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
# Initialize System
sys = system.System(output_dir=None)
mol = sys.add_macromolecule(sequence, "ERa")
state = mol.get_apo_state()
#mol.add_state("088074")
pof = analysis.ParseOutputFile(outputdir + "/models_scores_sigmas-ERa_Apo.dat",
state)
pof2 = analysis.ParseOutputFile(
outputdir2 + "/models_scores_sigmas-ERa_Apo.dat", state)
pof3 = analysis.ParseOutputFile(
outputdir3 + "/models_scores_sigmas-ERa_Apo.dat", state)
pof4 = analysis.ParseOutputFile(
outputdir4 + "/models_scores_sigmas-ERa_Apo.dat", state)
pof4 = analysis.ParseOutputFile(
outputdir5 + "/models_scores_sigmas-ERa_Apo.dat", state)
import system
from systems.solar_system import solar_radius as SR
from systems.solar_system import earth_radius as ER
from systems.solar_system import astronomical_unit as AU
# name, periapsis, apoapsis, radius, color, rings, ringscolor, systems
h = system.System('Trappist 1 h', AU*0.062, AU*0.062, ER*0.33, (39, 150, 89), 0, (0,0,0), [])
g = system.System('Trappist 1 g', AU*0.047, AU*0.047, ER*1.15, (211, 0, 106), 0, (0,0,0), [])
f = system.System('Trappist 1 f', AU*0.039, AU*0.039, ER*0.93, (185, 0, 211), 0, (0,0,0), [])
e = system.System('Trappist 1 e', AU*0.029, AU*0.029, ER*0.77, (87, 0, 211), 0, (0,0,0), [])
d = system.System('Trappist 1 d', AU*0.022, AU*0.022, ER*0.30, (0, 60, 211), 0, (0,0,0), [])
c = system.System('Trappist 1 c', AU*0.016, AU*0.016, ER*1.16, (0, 182, 211), 0, (0,0,0), []) # random size next to jupiter since mass is close
b = system.System('Trappist 1 b', AU*0.012, AU*0.012, ER*1.02, (48, 152, 48), 0, (0,0,0), [])
planets = [b, c, d, e, f, g, h]
trappist_1 = system.System('Trappist 1', 0, 0, 0.119*SR, (249, 127, 50), 0, (0,0,0), planets)
import system
from matplotlib import pyplot
import time
import numpy
pi = numpy.pi
magnets = system.System()
def shift_outers(state_in, epsi=10.**-2):
delta = numpy.zeros(len(state_in))
delta[1:7] = epsi
return delta
def oscilation_path(alpha, del_state, T_end=5., down=False):
magnets.load_state(alpha, down=down)
magnets.elapsed = 0.
state_0 = numpy.array(magnets.state)
magnets.state+=del_state
path = [(0, del_state[:7])]
E_0 = magnets.total_PE()+magnets.total_KE()
# print(magnets.gamma)
# print(magnets.elapsed, T_end)
while magnets.elapsed < T_end:
magnets.advance_in_time()
E_t = magnets.total_PE()+magnets.total_KE()
delta = magnets.state[:7]-state_0[:7]
path.append((magnets.elapsed, tuple(delta)))
print(alpha, abs((E_t-E_0)/E_0))
return path
install_mode = installmode.Graphical
else:
install_mode = installmode.Normal
# Sort out the extra arguments
opt_args = {"root": [], "geant4": [], "curl": [], "xrootd": []}
if options.root_arguments is not None:
opt_args["root"] = options.root_arguments.split()
if options.geant4_arguments is not None:
opt_args["geant4"] = options.geant4_arguments.split()
if options.curl_arguments is not None:
opt_args["curl"] = options.curl_arguments.split()
if options.xrootd_arguments is not None:
opt_args["xrootd"] = options.xrootd_arguments.split()
try:
install_system = system.System(logger, options.cache_path,
options.install_path, install_mode,
opt_args)
except snoing_exceptions.InstallModeException, e:
print e.args[0], "The existing installation is ", installmode.Text[
e.
SystemMode], ". You've requested the installation to be ", installmode.Text[
e.CommandMode]
print "You can install to a new path using the -i option or delete the existing installation and start again."
print_error_message()
except snoing_exceptions.SystemException, e:
print e.args[0], ":", e.Details
print_error_message()
if options.clean:
install_system.clean_cache()
# Now create the package manage and populate it
package_manager = packagemanager.PackageManager(install_system, logger)
def setUp(self):
self.system = system.System()
self.system.LoadConfig('testdata/test_config.protoascii')
def __init__(self):
self.currentUser = None
self.Game = None
self.System = system.System()
def run(time, n, radio):
startTime = datetime.now()
list = []
for i in range(n):
list.append(dk.Disk(str(i), radius=radio))
sistema = sy.System(time, list)
sistema.set_random_velocities()
#La multiplicación de nxm debe dar el número de particulas.
sistema.set_rect_red(10, 10)
sistema.create_events(sistema.particles, [])
sistema.build_binary_heap()
sistema.main_loop()
tiempos = []
for i in range(len(sistema.momentos_x)):
tiempos.append(i)
print(datetime.now() - startTime)
pos = sistema.lista_grande
##############################################
fig2, ax2 = plt.subplots()
ax2.plot(tiempos, sistema.momentos_x)
ax2.set(xlabel='Evento',
ylabel='Momentum',
title='Conservación de Momentum Lineal')
ax2.grid()
################################################
fig = plt.figure()
ax = plt.axes(xlim=(0, sy.LX), ylim=(0, sy.LY))
ax.set_facecolor('k')
ax.set(xlabel='x', ylabel='y', title=str(n) + " Partículas")
ax.set_aspect('equal')
patches = []
for i in range(len(pos)):
x, y, z = random.uniform(0,
1), random.uniform(0,
1), random.uniform(0.5, 1)
color_t = (x, y, z)
patches.append(plt.Circle((5, 5), radio, color=color_t))
def init():
for i in range(len(patches)):
x0 = pos[i][0][0]
y0 = pos[i][1][0]
patches[i].center = (x0, y0)
ax.add_patch(patches[i])
a = tuple(patches)
return a
def animate(i):
j = 0
for patch in patches:
x, y = patch.center
x = pos[j][0][i]
y = pos[j][1][i]
patch.center = (x, y)
j += 1
a = tuple(patches)
return a
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=len(pos[0][0]),
interval=20,
blit=True)
plt.show()
def __init__(self) : #creat initial number of solutions
for i in range(0,variables.number_Systems,1) :
System = system.System()
self.members.append(System)
###########################################
### Simulation Parameters
num_exp_bins = 40 # Number of log(kex) values for sampling. 15-20 is generally sufficient.
init = "random" # How to initialize - either "random" or "enumerate". Enumerate is slower but sampling will converge faster
nsteps = 10000 # equilibrium steps. 5000 to 10000
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
### Here the real work begins....
### You should not have to change anything beneath this line.
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
############################################
### System Setup:
# Initialize model
sys = system.System(output_dir = outputdir, noclobber=False)
mol = sys.add_macromolecule(sequence, "Test")
state = mol.get_apo_state()
state2 = mol.add_state("Apo2")
# Alternatively, you can use this single line macro, which is equivalent
#state = system.setup_single_state(sequence, "UVR8", output_dir = "test_output")
# Import data
dataset = hxio.import_HXcolumns("simulated_data.dat", # HX Columns input file
sequence, # FASTA sequence string
name="Data", # A string identifier for the dataset (optional)
percentD=False, # Is the data in percent deuterium (True) or absolute deuterons (False)
conditions=None, # A data.Conditions object specifying pH, Temp, etc... None uses a standard set of conditions
error_estimate=2.0, # The initial estimate for experimental SD in % deuterium untis.
n_fastamides=2, # Number of fast exchanging N-terminal amides
offset=offset) # Numbering offset between data and FASTA file. (positive or negative integer)
import system
from systems.solar_system import solar_radius as SR
from systems.solar_system import earth_radius as ER
from systems.solar_system import astronomical_unit as AU
# name, periapsis, apoapsis, radius, color, rings, ringscolor, systems
g = system.System('Kepler 11 g', AU * 0.466, AU * 0.466, ER * 3.33,
(211, 0, 106), 0, (0, 0, 0), [])
f = system.System('Kepler 11 f', AU * 0.013, AU * 0.013, ER * 2.49,
(185, 0, 211), 0, (0, 0, 0), [])
e = system.System('Kepler 11 e', AU * 0.012, AU * 0.012, ER * 3.12,
(87, 0, 211), 0, (0, 0, 0), [])
d = system.System('Kepler 11 d', AU * 0.004, AU * 0.004, ER * 3.12,
(0, 60, 211), 0, (0, 0, 0), [])
c = system.System('Kepler 11 c', AU * 0.026, AU * 0.026, ER * 2.87,
(0, 182, 211), 0, (0, 0, 0),
[]) # random size next to jupiter since mass is close
b = system.System('Kepler 11 b', AU * 0.091, AU * 0.091, ER * 1.83,
(48, 152, 48), 0, (0, 0, 0), [])
planets = [b, c, d, e, f, g]
kepler_11 = system.System('Kepler 11', 0, 0, 1.021 * SR, (252, 238, 33), 0,
(0, 0, 0), planets)
