def tallenna_kuvaaja():
"""
Napinkäsittelijä, joka tallentaa nykyisen kuvaajan .png-muodossa.
Polun määrittely perustuu ikkunasto-moduulin avaa_tallennusikkuna-funktioon,
mutta siihen on lisätty argumentteja, jotka löytyvät tkinter-dokumentaatiosta:
https://infohost.nmt.edu/tcc/help/pubs/tkinter/web/tkFileDialog.html
"""
polku = filedialog.asksaveasfilename(defaultextension=".png",
filetypes=[("PNG", ".png"),
("JPEG", ".jpg"),
("TIFF", ".tif"),
("PDF", ".pdf")],
initialdir=".",
title="Tallenna kuvaaja")
if polku:
try:
ELEMENTIT["kuvaaja"].savefig(polku)
except ValueError:
ikkunasto.avaa_viesti_ikkuna("Tallennus epäonnistui",
"Tiedostotyyppiä ei tueta.", True)
else:
tallennusotsikko = "Kuvaaja tallennettu"
tallennusviesti = "Kuvaaja tallennettu nimellä {}"
tallennusteksti = "Kuvaaja tallennettu kohteeseen:\n{}"
tiedostonimi = polku.rsplit("/", 1)
ikkunasto.avaa_viesti_ikkuna(
tallennusotsikko, tallennusviesti.format(tiedostonimi[1]))
ikkunasto.kirjoita_tekstilaatikkoon(
ELEMENTIT["tekstilaatikko"],
tallennusteksti.format(tiedostonimi[0]))
def lisaaKomponentti():
"""
Lisää komponentin haaraan.
"""
komp = ikn.lue_kentan_sisalto(KLIITTYMÄ["syote"[0]]).strip().lower()
arvo = ikn.lue_kentan_sisalto(KLIITTYMÄ["syote"[1]]).strip()
id = ikn.lue_kentan_sisalto(KLIITTYMÄ["syote"[2]]).strip()
sallitut = ("v", "r", "k", "l", "c")
if not komp in sallitut:
ikn.avaa_viesti_ikkuna("Virhe!", "Komponentti ei ollut kelvollinen.",
True)
ikn.tyhjaa_kentan_sisalto(KLIITTYMÄ["syote"[0]])
return
if komp == "v":
komp = "r"
elif komp == "k":
komp = "l"
arvo = sim.muunnaSi(arvo)
if not arvo:
ikn.avaa_viesti_ikkuna("Virhe!", "Arvo ei ollut kelvollinen.", True)
ikn.tyhjaa_kentan_sisalto(KLIITTYMÄ["syote"[1]])
return
komp = (komp, arvo)
id = tarkistaID(id)
KLIITTYMÄ["komponentit"][id].append(komp)
komponenttilistaus()
piirtaja()
def tilasto():
try:
with open("tilasto.txt") as luku:
sisalto = luku.readlines()
pelit, voitot, tappiot = sisalto[0].split(",")
voitot = int(voitot)
tappiot = int(tappiot.strip(" "))
pelit = int(pelit)
if pelit == 0:
voittoprosentti = 0
else:
voittoprosentti = voitot / pelit * 100
aika1, pvm1 = sisalto[1].split("p")
aika2, pvm2 = sisalto[2].split("p")
aika3, pvm3 = sisalto[3].split("p")
pvm1 = pvm1.strip(" ")
pvm2 = pvm2.strip(" ")
return "Pelatut pelit: {} \nVoitot: {} \nTappiot: {} \nVoittoprosentti: {:.2f} \n\nParhaat ajat: \n\n\
10 x 10 ruudukko, 10 miinaa: \nNopein aika {}s pelattu {} \n20 x 20 ruudukko, 50 miinaa: \
\nNopein aika {}s pelattu {} \n25 x 25 ruudukko, 100 miinaa: \nNopein aika {}s pelattu {}\
".format(pelit, voitot, tappiot, voittoprosentti, aika1, pvm1, aika2, pvm2,
aika3, pvm3)
except IOError:
ik.avaa_viesti_ikkuna("Virhe",
"Ole hyvä ja nollaa tilastot",
virhe=True)
return "Ei tilastoja."
def avaa_kansio():
"""
Napinkäsittelijä, joka pyytää käyttäjää valitsemaan kansion avaamalla kansioselaimen.
Lataa datan valitusta kansiosta ja syöttää sen lue_data-funktiolle käsittelyyn.
Tulostaa sitten tekstilaatikkoon listan virheellisistä tiedostoista ja
ilmoittaa montako tiedostoa ladattiin onnistuneesti.
Kutsuu lopuksi piirra_data-funktiota kuvaajan piirtämiseksi.
Mikäli annetussa kansiossa ei ollut yhtään dataa, ilmoitetaan tästä käyttäjälle.
"""
kohdekansio = ikkunasto.avaa_hakemistoikkuna("Valitse datakansio...")
if kohdekansio:
avausilmoitus = "Luetaan {} sisältö...".format(kohdekansio)
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
avausilmoitus)
lue_data(kohdekansio)
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
"Sisältö luettu.")
for i in LISTAT["virheelliset"]:
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
"Viallinen tiedosto: " + i)
latausilmoitus = "Ladattiin {} tiedostoa.".format(LISTAT["ladatut"])
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
latausilmoitus)
ei_dataa_viesti = "Kohdekansiosta ei löytynyt yhtään kelvollista dataa."
if len(LISTAT["energiat"]) < 1 or len(LISTAT["intensiteetit"]) < 1:
ikkunasto.avaa_viesti_ikkuna("Kelvollista dataa ei löytynyt",
ei_dataa_viesti, True)
else:
piirra_data()
def piikin_intensiteetti(alku, loppu):
"""
Laskee integroimalla piikin intensiteetin käyttäen
puolisuunnikassääntöä annetulla energiavälillä.
Tämä toteutetaan käyttäen numpy-kirjaston trapz-funktiota.
Luo lopuksi piikkien suhteen laskemisnapin, jos sitä ei vielä ole.
:param int alku: indeksi, jonka perusteella löydetään piikin alkupiste
:param int loppu: indeksi, jonka perusteella löydetään piikin loppupiste
"""
otsikko = "Lasketaan piikin intensiteetti"
ilmoitus = "Lasketaan piikin intensiteetti käyttäen energiaväliä\n"
energiavali = "{:.3f} eV - {:.3f} eV".format(LISTAT["energiat"][alku],
LISTAT["energiat"][loppu])
ikkunasto.avaa_viesti_ikkuna(otsikko, ilmoitus + energiavali + ".")
intensiteetti = numpy.trapz(LISTAT["intensiteetit"][alku:loppu],
LISTAT["energiat"][alku:loppu])
if len(LISTAT["piikkien_I"]) >= 2:
LISTAT["piikkien_I"].remove(LISTAT["piikkien_I"][0])
LISTAT["piikkien_I"].append(intensiteetti)
intensiteetti_ilmoitus = (
"Intensiteetti energiavälillä {} on {:.3f}.".format(
energiavali, intensiteetti))
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
intensiteetti_ilmoitus)
LISTAT["pisteet"] = []
if len(LISTAT["piikkien_I"]) >= 2 and not ELEMENTIT["suhdenappi"]:
ELEMENTIT["suhdenappi"] = ikkunasto.luo_nappi(
ELEMENTIT["vasen_yla_kehys"], "Suhde", piikkien_suhde)
def aseta_jannite():
""" Pyytää käyttäjältä tarvittavat tiedot piirin virran laskemiseksi.
Kyselyä toistetaan kunnes tarvittavat tiedot on annettu. Jännite annettama ilman merkintää V,
mutta voidaan antaa kerrannaisyksikön kanssa, kuten 1p"""
tila["jannite"] = ik.lue_kentan_sisalto(jannite_kentta)
jannite = tila["jannite"][0:-1]
yksikko = tila["jannite"][-1]
while True:
try:
if tila["jannite"] == "0":
raise(ValueError)
else:
pass
jannite == int(jannite)
except ValueError:
ik.avaa_viesti_ikkuna("Virhe", "Et antanut kelvollista jännitettä!", virhe=False)
return aseta_jannite
for yksikko in SI_kerrannaisyksikot:
U = jannite * SI_kerrannaisyksikot.get("yksikko") #U = jannite
if False:
ik.avaa_viesti_ikkuna("Virhe", "Et antanut kelvollista jännitettä!\nVinkki: Anna jännite ilman yksikköä, esim. muodossa 12.0k", virhe=False)
else:
pass
arvot["U"] = U
pi.piirra_jannitelahde(piirin_piirto_tila, arvot["U"], arvot["f"], v_asetteluvali=2)
ik.tyhjaa_kentan_sisalto(jannite_kentta)
def valmistele_intensiteetti():
"""
Napinkäsittelijä, joka suorittaa tarvittavat valmistelut intensiteettilaskentaa varten.
Luo valittujen pisteiden perusteella aloitus- ja lopetusindeksin piikin rajaamiseksi.
Indeksit välitetään piikin_intensiteetti-funktiolle.
"""
virhe_otsikko = "Intensiteetin laskeminen epäonnistui"
valintaohje = "Valitse energiaväli klikkaamalla."
minimivali = (numpy.abs(LISTAT["energiat"][-1] - LISTAT["energiat"][0]) /
len(LISTAT["energiat"]))
x1, y1, x2, y2 = tarkista_pisteet(virhe_otsikko, valintaohje, minimivali)
if x1 == None and y1 == None and x2 == None and y2 == None:
pass
else:
alkuindeksi = -1
loppuindeksi = -1
for i, E in enumerate(LISTAT["energiat"]):
if E >= x1:
alkuindeksi = i
break
for i, E in enumerate(LISTAT["energiat"]):
if E > x2:
loppuindeksi = i - 1
break
if alkuindeksi == -1 or loppuindeksi == -1:
virheviesti = "Energiavälin määritys epäonnistui."
ikkunasto.avaa_viesti_ikkuna(virhe_otsikko, virheviesti, True)
else:
piikin_intensiteetti(alkuindeksi, loppuindeksi)
def tarkistaID(id):
"""
Tekee tarkistuksen komponentin haaran ID:stä. Jos tyhjä tai negatiivinen, palauttaa 0.
"""
try:
if id == "":
return 0
luku = int(id)
except ValueError:
luku = len(KLIITTYMÄ["komponentit"])
# Jos ensimmäinen lista (haara) on tyhjä, palautetaan ensimmäinen haaran ID
if not KLIITTYMÄ["komponentit"][0]:
return 0
# Palautetaan komponenttien haarojen ID. Negatiivinen palauttaa 0.
if luku < 0:
ikn.avaa_viesti_ikkuna(
"Huom!",
"Antamasi ID oli negatiivinen luku. Komponentti lisätty haaraan ID: 0"
)
return 0
elif luku <= len(KLIITTYMÄ["komponentit"]) - 1:
return luku
elif luku == len(KLIITTYMÄ["komponentit"]):
KLIITTYMÄ["komponentit"].append([])
return luku
ikn.avaa_viesti_ikkuna(
"Huom!",
"Antamasi ID ei ollut kelvollinen. Komponentti lisätään uuteen haaraan. Uuden haaran ID: {}"
.format(luku))
KLIITTYMÄ["komponentit"].append([])
return len(KLIITTYMÄ["komponentit"])
def tilastoi_tappio():
try:
with open("tilasto.txt") as tilasto:
sisalto = tilasto.readlines()
pelit, voitot, tappiot = sisalto[0].split(",")
tappiot = tappiot.strip()
tappiot = int(tappiot)
tappiot += 1
pelit = int(pelit)
pelit += 1
aika1, pvm1 = sisalto[1].split("p")
aika2, pvm2 = sisalto[2].split("p")
aika3, pvm3 = sisalto[3].split("p")
aika1 = float(aika1)
aika2 = float(aika2)
aika3 = float(aika3)
pvm1 = pvm1.strip()
pvm2 = pvm2.strip()
with open("tilasto.txt", "w") as tilasto:
tilasto.write("{},{},{}\n".format(pelit, voitot, tappiot))
tilasto.write("{:.2f}p{}\n".format(aika1, pvm1))
tilasto.write("{:.2f}p{}\n".format(aika2, pvm2))
tilasto.write("{:.2f}p{}".format(aika3, pvm3))
except IOError:
ik.avaa_viesti_ikkuna("Virhe",
"Ole hyvä ja nollaa tilastot",
virhe=True)
def voitto():
tila["aika"] = round(time.time(), 2) - tila["aika"]
min = int(tila["aika"] // 60)
sek = tila["aika"] % 60
voittoviesti = "Voitit pelin :) \nAikaa kului {} minuuttia ja {:.2f} sekuntia. \nKlikkasit {} kertaa.".format(
min, sek, tila["klikkaukset"])
ik.avaa_viesti_ikkuna("Voitto", voittoviesti)
tilastoi_voitto()
def havio():
tila["aika"] = round(time.time(), 2) - tila["aika"]
tila["kentta"] = tila["kentta_nakymaton"]
piirra_kentta()
min = int(tila["aika"] // 60)
sek = tila["aika"] % 60
tappioviesti = "Hävisit pelin :( \nAikaa kului {} minuuttia ja {:.2f} sekuntia. \nKlikkasit {} kertaa.".format(
min, sek, tila["klikkaukset"])
ik.avaa_viesti_ikkuna("Tappio", tappioviesti)
tilastoi_tappio()
def ikkunasto_napin_kasittelija():
sisaltox = ikkunasto.lue_kentan_sisalto(kysyja.kenttax)
sisaltoy = ikkunasto.lue_kentan_sisalto(kysyja.kenttay)
try:
xy.append(int(sisaltox))
xy.append(int(sisaltoy))
ikkunasto.lopeta()
except ValueError:
ikkunasto.avaa_viesti_ikkuna("Virhe!",
"positiivisia kokonaislukuja, kiitos.",
True)
def ok():
try:
parametrit["korkeus"] = int(
ik.lue_kentan_sisalto(palikat["korkeuskentta"]))
parametrit["leveys"] = int(
ik.lue_kentan_sisalto(palikat["leveyskentta"]))
parametrit["miinalkm"] = int(
ik.lue_kentan_sisalto(palikat["miinatkentta"]))
ik.piilota_ali_ikkuna(palikat["valinnat"])
except ValueError:
ik.avaa_viesti_ikkuna("Virhe", "Syötä kolme kokonaislukua", virhe=True)
def valitse_tyyppi():
"""
Tarkastaa syötteestä, mitä tyyppiä komponentti on
"""
tyyppi = ik.lue_kentan_sisalto(tila["syote"])
ik.tyhjaa_kentan_sisalto(tila["syote"])
if tyyppi.isdigit():
ik.avaa_viesti_ikkuna(
"VIRHE",
"Komponentti voi olla vastus(r), kela(l) tai kondensaattori(c)!",
True)
elif len(tyyppi) > 1:
if tyyppi == 'aasisvengaa':
ik.avaa_viesti_ikkuna("Vanha vitsi!", "Aasi ei svengaa.", True)
ik.avaa_viesti_ikkuna(
"VIRHE",
"Komponentti voi olla vastus(r), kela(l) tai kondensaattori(c)!",
True)
elif tyyppi == 'r' or 'l' or 'c':
tallenna_tyyppi(tyyppi)
else:
ik.avaa_viesti_ikkuna(
"VIRHE",
"Komponentti voi olla vastus(r), kela(l) tai kondensaattori(c)!",
True)
def peli_loppu():
'''Funktio joka suorittaa kaiken pelin loppumisen jälkeen tapahtuvan'''
ikkuna = iku.luo_ikkuna('')
ali = iku.luo_kehys(ikkuna)
if liput['voitto'] == 1:
iku.avaa_viesti_ikkuna('', 'VOITIT PELIN')
elif liput['voitto'] == 2:
iku.avaa_viesti_ikkuna('', 'HÄVISIT PELIN')
iku.luo_tekstirivi(
ali, 'Liputit {} miinaa, kun miinoja oli {} kpl'.format(
peli['liputetut'], peli['miinat']))
iku.luo_tekstirivi(ali, 'Aikaa kului {} sekuntia'.format(stats['aika']))
iku.luo_nappi(ali, 'Pelaa uudelleen', uusiksi)
iku.luo_nappi(ali, 'Tallenna tulokset', save)
iku.luo_nappi(ali, 'Palaa päävalikkoon', back)
iku.kaynnista()
def tarkista_syotteet():
"""
Tarkistaa syötteet. Jos syötteet kelpaa, käynnistää pelin.
"""
try:
kentan_tiedot["korkeus"] = abs(int(ikkunasto.lue_kentan_sisalto(syotteet["korkeus"])))
kentan_tiedot["leveys"] = abs(int(ikkunasto.lue_kentan_sisalto(syotteet["leveys"])))
kentan_tiedot["miinojen_lkm"] = abs(int(ikkunasto.lue_kentan_sisalto(syotteet["miinojen_lkm"])))
except ValueError:
ikkunasto.avaa_viesti_ikkuna(
"Virhe",
"Anna kentän leveydeksi ja korkeudeksi sekä miinojen lukumääräksi jokin positiivinen \
kokonaisluku.",
True
)
else:
main()
def aseta_taajuus():
"""
Lukee liukulukuarvon syötekentästä ja asettaa sen piirin jännitelähteen taajuudeksi.
"""
try:
tila["taajuus"] = ik.lue_kentan_sisalto(tila["syote"])
if tila["taajuus"][-1].isdigit():
ik.kirjoita_tekstilaatikkoon(
tila["laatikko"],
"Taajuus: {} Hz".format(float(tila["taajuus"])))
else:
tila["taajuus"] = muuta_kerrannaisyksikko(tila["taajuus"])
ik.kirjoita_tekstilaatikkoon(
tila["laatikko"],
"Taajuus: {} Hz".format(float(tila["taajuus"])))
except TypeError:
ik.avaa_viesti_ikkuna("VIRHE", "Syöte ei ollut kelvollinen", True)
ik.tyhjaa_kentan_sisalto(tila["syote"])
def lisaa_vastus():
"""Pyytää annettavan vastuksen tiedot"""
tila["vastukset"] = ik.lue_kentan_sisalto(vastus_kentta)
while True:
try:
arvo_vastus = tila["vastukset"][0:-1]
except ValueError:
ik.avaa_viesti_ikkuna("Virhe", "Et antanut kelvollista arvoa!\nVinkki: Anna arvo ilman yksikköä, esim. muodossa 12.0n", virhe=False)
return lisaa_vastus
else:
if tila["vastukset"] == "0":
raise(ValueError)
elif not SI_kerrannaisyksikot.get("yksikko"):
ik.avaa_viesti_ikkuna("Virhe", "Et antanut kelvollista arvoa!\nVinkki: Anna arvo ilman yksikköä, esim. muodossa 12.0n", virhe=False)
return lisaa_vastus
yksikko = tila["vastukset"][-1]
R = arvo_vastus * SI_kerrannaisyksikot.get("yksikko")
arvot["R"] = R
def lisaa_kela():
"""Pyytää annettavan kelan tiedot"""
tila["kelat"] = ik.lue_kentan_sisalto(kela_kentta)
while True:
try:
arvo_kela = tila["kelat"][0:-1]
except ValueError:
ik.avaa_viesti_ikkuna("Virhe", "Et antanut kelvollista arvoa!\nVinkki: Anna arvo ilman yksikköä, esim. muodossa 12.0k", virhe=False)
return lisaa_kela
else:
if tila["kelat"] == "0":
raise(ValueError)
elif not SI_kerrannaisyksikot.get("yksikko"):
ik.avaa_viesti_ikkuna("Virhe", "Et antanut kelvollista arvoa!\nVinkki: Anna arvo ilman yksikköä, esim. muodossa 12.0k", virhe=False)
return lisaa_kela
yksikko = tila["kelat"][-1]
L = arvo_kela * SI_kerrannaisyksikot.get("yksikko")
arvot["L"] = L
def asetaTaajuus():
"""
Lukee syötekenttää ja koettaa asettaa taajuuden.
"""
taajuusTulokas = ikn.lue_kentan_sisalto(KLIITTYMÄ["syote"[1]]).strip()
# Muunnos SI yksikköön. Tarkistaa myös syötteen kelvollisuuden. Jos ei kelvollinen,
# palauttaa "None" arvon.
taajuusTulokas = sim.muunnaSi(taajuusTulokas)
if taajuusTulokas:
KLIITTYMÄ["taajuus"] = taajuusTulokas
tulostus = sim.Si_ksi(taajuusTulokas)
ikn.kirjoita_tekstilaatikkoon(
KLIITTYMÄ["logi"],
"Taajuus: {}{} Hz".format(tulostus[0], tulostus[1]))
else:
ikn.avaa_viesti_ikkuna("Virhe!", "Syöte ei ollut kelvollinen.", True)
ikn.tyhjaa_kentan_sisalto(KLIITTYMÄ["syote"[1]])
def tilastoi_voitto():
try:
with open("tilasto.txt") as luku:
sisalto = luku.readlines()
pelit, voitot, tappiot = sisalto[0].split(",")
voitot = int(voitot)
voitot += 1
pelit = int(pelit)
pelit += 1
tappiot = tappiot.strip()
aika1, pvm1 = sisalto[1].split("p")
aika2, pvm2 = sisalto[2].split("p")
aika3, pvm3 = sisalto[3].split("p")
aika1 = float(aika1)
aika2 = float(aika2)
aika3 = float(aika3)
pvm1 = pvm1.strip()
pvm2 = pvm2.strip()
if parametrit["korkeus"] == 10 and parametrit[
"leveys"] == 10 and parametrit["miinalkm"] == 10:
if tila["aika"] < aika1:
aika1 = tila["aika"]
pvm1 = datetime.datetime.today()
elif parametrit["korkeus"] == 20 and parametrit[
"leveys"] == 20 and parametrit["miinalkm"] == 50:
if tila["aika"] < aika2:
aika2 = tila["aika"]
pvm2 = datetime.datetime.today()
elif parametrit["korkeus"] == 25 and parametrit[
"leveys"] == 25 and parametrit["miinalkm"] == 100:
if tila["aika"] < aika3:
aika3 = tila["aika"]
pvm3 = datetime.datetime.today()
with open("tilasto.txt", "w") as kohde:
kohde.write("{},{},{}\n".format(pelit, voitot, tappiot))
kohde.write("{:.2f}p{}\n".format(aika1, pvm1))
kohde.write("{:.2f}p{}\n".format(aika2, pvm2))
kohde.write("{:.2f}p{}".format(aika3, pvm3))
except IOError:
ik.avaa_viesti_ikkuna("Virhe",
"Ole hyvä ja nollaa tilastot",
virhe=True)
def muuta_osoitinmuotoon():
"""Lukee kompleksiluvun syötekentästä ja muuttaa sen osoitinmuotoon, jossa osoittimen kulma on esitetty asteina.
Kompleksiluku sekä sen osoitinmuoto tulostetaan käyttöliittymässä olevaan tekstilaatikkoon."""
elementit["tekstikentta"] = ik.lue_kentan_sisalto(tekstikentta)
luku = elementit["tekstikentta"]
luku = complex(" ".join(luku.split()))
try:
isinstance(luku, complex)
except ValueError:
ik.avaa_viesti_ikkuna("Virhe",
"Et antanut kelvollista kompleksilukua!",
virhe=False)
return muuta_osoitinmuotoon
else:
napakoordinaatti = cmath.polar(luku)
kulma = math.degrees(napakoordinaatti[1])
return napakoordinaatti[0], kulma
tulosta_muutettu_kompleksiluku(
napakoordinaatti, kulma
) #returnin jälkeen ei suoriteta enää mitään. Tänne on turha laittaa mitään
def poista_tausta():
"""
Napinkäsittelijä, joka poistaa spektristä mittauslaitteistosta johtuvan lineaarisen taustan.
Käyttäjälle ilmoitetaan, mitä pisteitä tullaan käyttämään.
Luo lopuksi intensiteetin laskemisnapin, jos sitä ei vielä ole.
:param float x1, y1, x2, y2: pisteet, joiden välille sovitetaan suora
"""
virhe_otsikko = "Lineaarisen taustan poistaminen epäonnistui"
valintaohje = "Valitse kuvaajan alku- ja loppupäästä kaksi pistettä klikkaamalla."
minimivali = numpy.abs(LISTAT["energiat"][-1] - LISTAT["energiat"][0]) / 4
x1, y1, x2, y2 = tarkista_pisteet(virhe_otsikko, valintaohje, minimivali)
if x1 == None and y1 == None and x2 == None and y2 == None:
# Tässähän voisi tarkistaa vain yhden näistä Noneksi, mutta perfektionismi.
pass
else:
poisto_otsikko = "Poistetaan lineaarinen tausta"
poistoilmoitus = "Poistetaan lineaarinen tausta käyttäen pisteitä\n"
pisteet = ("({x1:.3f}, {y1:.3f}) ja ({x2:.3f}, {y2:.3f}).".format(
x1=x1, y1=y1, x2=x2, y2=y2))
ikkunasto.avaa_viesti_ikkuna(poisto_otsikko, poistoilmoitus + pisteet)
k, b = laske_parametrit(x1, y1, x2, y2)
if k == None:
# Tämä ilmoitus tulee ainoastaan tekstilaatikkoon,
# koska siitä avataan viesti-ikkuna jo laske_parametrit-funktion sisällä.
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
virhe_otsikko)
else:
suoran_arvot = laske_pisteet_suoralla(k, b, LISTAT["energiat"])
for i, y in enumerate(suoran_arvot):
LISTAT["intensiteetit"][i] = LISTAT["intensiteetit"][i] - y
kuittaus = "Lineaarinen tausta poistettu käyttäen pisteitä:\n"
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
kuittaus + pisteet)
piirra_data()
LISTAT["pisteet"] = []
if not ELEMENTIT["intensiteettinappi"]:
ELEMENTIT["intensiteettinappi"] = ikkunasto.luo_nappi(
ELEMENTIT["vasen_yla_kehys"], "Intensiteetti",
valmistele_intensiteetti)
def aseta_taajuus():
"""Pyytää käyttäjältä taajuuden. Oltava nollaa suurempi. """
tila["taajuus"] = ik.lue_kentan_sisalto(taajuus_kentta)
taajuus = tila["taajuus"][0:-1]
yksikko = tila["taajuus"][-1]
while True:
try:
if tila["taajuus"] == "0":
raise(ValueError)
else:
pass
except ValueError:
ik.avaa_viesti_ikkuna("Virhe", "Et antanut kelvollista taajuutta!\nVinkki: Anna taajuus ilman yksikköä, esim. muodossa 12.0k", virhe=False)
return aseta_taajuus
for yksikko in SI_kerrannaisyksikot:
f = taajuus * SI_kerrannaisyksikot.get("yksikko") #f = taajuus
if False:
ik.avaa_viesti_ikkuna("Virhe", "Et antanut kelvollista taajuutta!\nVinkki: Anna taajuus ilman yksikköä, esim. muodossa 12.0k", virhe=False)
else:
pass
arvot["f"] = f
def arvo_kasittelija():
'''Funktio hakee ja tarkistaa pelaajan antaman arvon. Kentta on
tekstikenttä johon käyttäjä kirjoittaa, teksti alue johon kirjoitetaan
tekstiä.'''
try:
peli["korkeus"] = int(iku.lue_kentan_sisalto(elementit["korkeus"]))
peli["leveys"] = int(iku.lue_kentan_sisalto(elementit["leveys"]))
peli["miinat"] = int(iku.lue_kentan_sisalto(elementit["miinat"]))
if peli["korkeus"] <= 0 or peli["leveys"] <= 0 or peli["miinat"] <= 0:
iku.avaa_viesti_ikkuna("Virhe",
"Arvojen täytyy olla suurempia kuin nolla",
True)
else:
iku.tyhjaa_kentan_sisalto(elementit["leveys"])
iku.tyhjaa_kentan_sisalto(elementit["korkeus"])
iku.tyhjaa_kentan_sisalto(elementit["miinat"])
liput["peli"] = True
iku.lopeta()
except ValueError:
iku.avaa_viesti_ikkuna("Virhe", "Arvojen täytyy olla kokonaislukuja",
True)
def tarkista_pisteet(virhe_otsikko, virheviesti, minimivali=0):
"""
Tarkistaa, onko piirretystä kuvaajasta valittu kaksi kelvollista pistettä.
Huono tai puuttuva piste palauttaa neljä Nonea ja tulostaa asianmukaisen virheikkunan
käyttäen annettua otsikkoa ja puuttuvien pisteiden tapauksessa viestiä.
Valinnainen argumentti minimivali määrittää pienimmän sallitun etäisyyden pisteiden
välillä x-akselilla.
:param str virhe_otsikko: virheikkunan otsikko
:param str virheviesti: virheikkunan teksti
:param float minimivali: pienin sallittu pisteiden etäisyys x-akselilla
:return: kaksi koordinaattipistettä, virheestä neljä Nonea
"""
pisteet = LISTAT["pisteet"][:]
pisteet.sort()
try:
x1, y1 = pisteet[0]
x2, y2 = pisteet[1]
except IndexError:
ikkunasto.avaa_viesti_ikkuna(virhe_otsikko, virheviesti, True)
return None, None, None, None
except TypeError:
ikkunasto.avaa_viesti_ikkuna(virhe_otsikko, virheviesti, True)
return None, None, None, None
else:
if numpy.abs(x2 - x1) < minimivali:
etaisyysohje = ("Valitse toisistaan kauempana olevat pisteet.")
ikkunasto.avaa_viesti_ikkuna(virhe_otsikko, etaisyysohje, True)
return None, None, None, None
else:
return x1, y1, x2, y2
def muuta_osoitinmuotoon(impedanssi):
"""
Lukee kompleksiluvun syötekentästä ja muuttaa sen osoitinmuotoon,
jossa osoittimen kulma on esitetty asteina.
Kompleksiluku sekä sen osoitinmuoto tulostetaan käyttöliittymässä olevaan tekstilaatikkoon.
"""
try:
if isinstance(impedanssi, complex):
osoitinmuoto = cmath.polar(impedanssi)
r, phi = osoitinmuoto
asteet = math.degrees(phi)
osoitinmuoto = "{eka:.3f} > {toka:.3f}".format(eka=r, toka=asteet)
tuloste = "Piirin kokonaisimpedanssi on: {}".format(osoitinmuoto)
ik.kirjoita_tekstilaatikkoon(tila["laatikko"], tuloste)
else:
ik.avaa_viesti_ikkuna("VIRHE",
"Syöte ei ollut kelvollinen kompleksiluku",
True)
except ValueError:
ik.avaa_viesti_ikkuna("VIRHE",
"Syöte ei ollut kelvollinen kompleksiluku", True)
def piikkien_suhde():
"""
Napinkäsittelijä, joka selvittää kahden viimeksi lasketun intensiteettipiikin suhteen.
Tulostaa lopuksi montako kertaa suurempi suurempi piikki on.
"""
piikit = LISTAT["piikkien_I"][:]
piikit.sort()
pieni_piikki = piikit[0]
suuri_piikki = piikit[1]
if pieni_piikki == suuri_piikki:
suhdeviesti = "Intensiteetit ovat yhtä suuret. Mielenkiintoista..."
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
suhdeviesti)
elif pieni_piikki == 0:
virhe_otsikko = "Virhe suhteen määrittämisessä"
virheviesti = "Toinen intensiteetti ei voi olla nolla!"
ikkunasto.avaa_viesti_ikkuna(virhe_otsikko, virheviesti, True)
else:
suhde = suuri_piikki / pieni_piikki
suhdeviesti = "Suurempi piikki on {:.3f} kertaa pienempää suurempi.".format(
suhde)
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
suhdeviesti)
def laske_parametrit(x1, y1, x2, y2):
"""
Laskee annettujen pisteiden välisen suoran kulmakertoimen ja vakiotermin.
Jos kulmakerrointa ei ole, palauttaa kaksi Nonea.
:param float x1, y1, x2, y2: käytettävät pisteet
:return: kulmakerroin k, vakiotermi b
"""
try:
k = (y2 - y1) / (x2 - x1)
except ZeroDivisionError:
#Tätähän ei olemassa olevilla ehdoilla pitäisi saada aikaan, mutta varmistetaan.
ilmoitus = ("Pisteiden ({x1:.3f}, {y1:.3f}) ja ({x2:.3f}, {y2:.3f}) "
"kautta kulkeva suora on pystysuora, ei kulmakerrointa. "
"Valitse toiset pisteet.".format(x1=x1,
y1=y1,
x2=x2,
y2=y2))
ikkunasto.avaa_viesti_ikkuna("Ei kulmakerrointa", ilmoitus, True)
return None, None
else:
b = (x2 * y1 - x1 * y2) / (x2 - x1)
return k, b
def laske_arvo():
"""
Laskee impedanssin eri komponenttityypeille, tallentaa ne sanakirjan komponentit-listaan
ja kutsuu piirtämisfunktiota
"""
try:
arvo = float(ik.lue_kentan_sisalto(tila["syote"]))
tyyppi = tila["tyyppi"]
ik.tyhjaa_kentan_sisalto(tila["syote"])
if tyyppi == 'r':
ik.kirjoita_tekstilaatikkoon(
tila["laatikko"],
"Vastuksen impedanssi on {ohmi:.2f} ohmia.".format(ohmi=arvo))
tila["komponentit"].append((tyyppi, arvo))
tila["impedanssit"].append(arvo)
piirra_piiri()
elif tila["tyyppi"] == 'l':
impedanssi = 2 * PI * tila["taajuus"] * arvo
ik.kirjoita_tekstilaatikkoon(
tila["laatikko"],
"Kelan induktanssi taajuudella {hertsi:.2f} Hz on {ohmi:.3f} ohmia."
.format(hertsi=tila["taajuus"], ohmi=impedanssi))
tila["komponentit"].append((tyyppi, impedanssi))
tila["reaktanssit"].append(impedanssi)
piirra_piiri()
elif tila["tyyppi"] == 'c':
impedanssi = 1 / (2 * PI * float(tila["taajuus"]) * arvo)
ik.kirjoita_tekstilaatikkoon(
tila["laatikko"],
"Kondensaattorin kapasitanssi taajuudella {hertsi:.2f} Hz on {ohmi:.3f} ohmia."
.format(hertsi=tila["taajuus"], ohmi=impedanssi))
tila["komponentit"].append((tyyppi, impedanssi))
tila["reaktanssit"].append(impedanssi)
piirra_piiri()
except ValueError:
ik.avaa_viesti_ikkuna("VIRHE", "Syötä liukuluku!", True)
