def laske_intensiteetit():
"""
Laskee spektrin piikin intensiteetin (pinta-ala) käyttäjän valitsemien pisteiden perusteella.
Ensin ohjataan käyttäjää valitsemaan pisteet ja tarvittaessa suorittamaan edelleen muitakin
"esitehtäviä".
"""
if (onko_data_ladattu() and onko_kuvaaja_piirretty(True)
and onko_tausta_poistettu(True) and onko_pisteet_valittu(True)):
# Tarkistetaan, täyttyvätkö edellytykset:
# data on ladattu, käyttäjä on valinnut pisteet, kuvaaja on piirretty
a, b = etsi_indeksit(data["energiat"], data["piste_a"][0],
data["piste_b"][0])
# Etsitään, mille indeksivälille käyttäjän valitsema energiaväli osuu.
intensiteetti = np.trapz(data["summaintensiteetit_taustaton"][a:b],
x=data["energiat"][a:b])
lukuarvo = locale.format_string("%.2f", intensiteetti, True)
# Lasketaan puolisuunnikassäännön avulla energiaväliä vastaava intensiteetti...
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
PIIKIN_INTENSITEETTI.format(lukuarvo))
# ...ja ilmoitetaan se käyttäjälle.
# Hyödynnetään localea, jotta desimaalierottimeksi saadaan pilkku.
data["tila"] = Odottaa.LEPO
nollaa_pisteet()
elif (onko_kuvaaja_piirretty(False) and onko_tausta_poistettu(False)
and not onko_pisteet_valittu(False)):
# Jos vain pisteet ovat valitsematta, jäädään odottamaan sitä.
data["tila"] = Odottaa.LASKE
def piirtaja():
"""
Komponenttien piirtäjä piirtoalueille
"""
piiristo.tyhjaa_piiri(KLIITTYMÄ["piirikuva"])
h_asettelu = natistaja()
piiristo.piirra_jannitelahde(KLIITTYMÄ["piirikuva"], KLIITTYMÄ["jannite"],
KLIITTYMÄ["taajuus"])
for i in range(len(KLIITTYMÄ["komponentit"])):
if i < len(KLIITTYMÄ["komponentit"]) - 1:
piiristo.piirra_haara(KLIITTYMÄ["piirikuva"],
KLIITTYMÄ["komponentit"][i],
h_asetteluvali=h_asettelu)
else:
piiristo.piirra_haara(KLIITTYMÄ["piirikuva"],
KLIITTYMÄ["komponentit"][i],
h_asetteluvali=h_asettelu,
viimeinen=True)
piiristo.piirra_piiri(KLIITTYMÄ["piirikuva"])
# Laitetaan laskuri pyörimään samalla
ikn.kirjoita_tekstilaatikkoon(KLIITTYMÄ["laskentatulokset"],
"",
tyhjaa=True)
laskuri()
def tyhjenna_tilastot():
"""
Tyhjentää tilasto-tiedoston.
"""
open("tilastot.txt", "w").close()
ikkunasto.kirjoita_tekstilaatikkoon(tilastolaatikko, "Tilastoja ei ole.",
True)
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 peli_paattyi():
"""
Näyttää pelin tiedot, kysyy nimimerkkiä ja tallentaa ne tiedostoon.
Palaa päävalikkoon kun nappia on painettu.
"""
haravasto.lopeta()
if tila["voitto"]:
viesti = "Voitit"
else:
viesti = "Hävisit"
pvm = datetime.datetime.now()
aloitusaika = tila["aloitusaika"]
aika_s = (pvm - aloitusaika).total_seconds()
aika = ("{}min {:.1f}s".format(int(aika_s / 60), aika_s % 60))
aikaleima = aloitusaika.strftime("%d.%m.%Y klo:%H.%M")
tila["aloitusaika"] = aikaleima
tila["peliaika"] = aika
tallennus_ikkuna = ikkunasto.luo_ikkuna("{} pelin!".format(viesti))
ylakehys = ikkunasto.luo_kehys(tallennus_ikkuna, ikkunasto.YLA)
alakehys = ikkunasto.luo_kehys(tallennus_ikkuna, ikkunasto.YLA)
nimiohje = ikkunasto.luo_tekstirivi(ylakehys, "Nimimerkki:")
global nimikentta
nimikentta = ikkunasto.luo_tekstikentta(ylakehys)
tallenna_nappi = ikkunasto.luo_nappi(ylakehys, "Tallenna peli",
tallenna_tilastot)
ohita_nappi = ikkunasto.luo_nappi(ylakehys, "Ohita",
takaisin_nappi_kasittelija)
global tallennus_ikkuna_laatikko
tallennus_ikkuna_laatikko = ikkunasto.luo_tekstilaatikko(alakehys, 40, 30)
ikkunasto.kirjoita_tekstilaatikkoon(
tallennus_ikkuna_laatikko,
"{} pelin.\nAika: {}\nVuorot: {}\nKentän koko: {}x{}\nMiinoja: {}\nPäivämäärä: {}."
.format(viesti, aika, tila["vuorot"], len(tila["kentta"][0]),
len(tila["kentta"]), tila["miinat"], aikaleima))
ikkunasto.kaynnista()
def tyhjaa_muisti():
"""
Napinkäsittelijä, joka tyhjentää ohjelman muistissa olevan datan
ja palauttaa ohjelman alkutilaan.
Tämän tekeminen erillisellä napilla mahdollistaa useamman datakansion käsittelyn yhtä aikaa.
"""
LISTAT["energiat"] = []
LISTAT["intensiteetit"] = []
LISTAT["ladatut"] = 0
LISTAT["piikkien_I"] = []
LISTAT["pisteet"] = []
LISTAT["virheelliset"] = []
for avain in ELEMENTIT:
if avain.endswith("nappi"):
try:
ikkunasto.poista_elementti(ELEMENTIT[avain])
except AttributeError:
pass
else:
ELEMENTIT[avain] = False
ELEMENTIT["akselit"].cla()
ELEMENTIT["akselit"].grid(True)
ELEMENTIT["piirtoalue"].draw()
ikkunasto.paivita_tekstirivi(ELEMENTIT["tekstirivi"], "")
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
"Muisti tyhjennetty.", True)
def tilastot():
palikat["tilasto"] = ik.luo_ali_ikkuna("Tilastot")
ylakehys = ik.luo_kehys(palikat["tilasto"], ik.YLA)
alakehys = ik.luo_kehys(palikat["tilasto"], ik.ALA)
nollaa = ik.luo_nappi(alakehys, "Nollaa tilastot", nollaus)
palikat["tilastolaatikko"] = ik.luo_tekstilaatikko(ylakehys, 55, 25)
ik.kirjoita_tekstilaatikkoon(palikat["tilastolaatikko"], tilasto())
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 tulosta_muutettu_kompleksiluku(napakoordinaatti, kulma):
"""Tulostaa testirivin annettuun tekstilaatikkoon."""
ik.kirjoita_tekstilaatikkoon(
elementit["tekstilaatikko"],
"{luku:.3f} on osoitinmuodossa {napakoordinaatti:.3f} < {kulma:.3f}°".
format(luku=elementit["tekstikentta"],
napakoordinaatti=napakoordinaatti,
kulma=kulma))
def lue_tilastot():
"""
Tulostaa pelattujen pelien tilastot.
"""
tilastoikkuna = ikkunasto.luo_ali_ikkuna("Tilastot")
tilastolaatikko = ikkunasto.luo_tekstilaatikko(tilastoikkuna)
for peli in tilastot:
ikkunasto.kirjoita_tekstilaatikkoon(tilastolaatikko, peli)
def laske_reaktanssi():
"""
Laskee piiriin sarjaankytkettyjen kelojen ja kondensaattoreiden kokonaisreaktanssin
"""
tila["reaktanssi"] = sum(float(i) for i in tila["reaktanssit"])
ik.kirjoita_tekstilaatikkoon(
tila["laatikko"],
"Sarjaankytkennän reaktanssi on {} ohmia.".format(tila["reaktanssi"]))
def laske_sarja():
"""
Laskee piirin komponenttien sarjaankytkennän kok.resistanssin
"""
tila["sarja"] = sum(float(i) for i in tila["impedanssit"])
ik.kirjoita_tekstilaatikkoon(
tila["laatikko"],
"Sarjaankytkennän resistanssi on {} ohmia.".format(tila["sarja"]))
def poista_tausta():
"""
Poistaa spektristä lineaarisen taustan käyttäjän valitsemien pisteiden perusteella.
Ensin ohjataan käyttäjää valitsemaan pisteet ja tarvittaessa suorittamaan muitakin
"esitehtäviä".
"""
if onko_data_ladattu() and onko_kuvaaja_piirretty(
True) and onko_pisteet_valittu(True):
# Tarkistetaan, täyttyvätkö edellytykset:
# data on ladattu, käyttäjä on valinnut pisteet ja kuvaaja on piirretty.
# Ei tulosteta pisteohjetta useaan kertaan (False).
kulmakerroin, vakiotermi = laske_parametrit(data["piste_a"][0],
data["piste_a"][1],
data["piste_b"][0],
data["piste_b"][1])
# Lasketaan pisteitä vastaavan suoran parametrit.
pisteet = laske_pisteet_suoralla(kulmakerroin, vakiotermi,
data["energiat"])
intensiteetit_erotus = np.array(
data["summaintensiteetit"]) - np.array(pisteet)
# Vähennetään summaintensiteeteistä suoran pisteet...
data["summaintensiteetit_taustaton"] = intensiteetit_erotus.tolist()
# ...ja sijoitetaan listaksi muutettu tulos datasanakirjaan.
elementit["graafi"].remove() # Poistetaan alkuperäinen kuvaaja.
elementit["piirto"].clear(
) # Palautetaan akselit, jotta niiden skaalaus toimii oikein.
nollaa_pisteet() # Nollataan käyttäjän valitsemat pisteet.
elementit["piirto"].set_xlabel(X_AKSELI)
elementit["piirto"].set_ylabel(
Y_AKSELI) # Asetetaan akseleiden nimet uudelleen.
elementit["graafi"], = elementit["piirto"].plot(
data["energiat"],
data["summaintensiteetit_taustaton"],
picker=TOLERANSSI)
# Uusi kuvaaja paikalleen.
elementit["alue"].draw()
napit["POISTA"].config(state="disabled") # Poistetaan nappi käytöstä.
data[
"tila"] = Odottaa.LEPO # Toiminnon suorituksen jälkeen voidaan levätä.
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
TAUSTA_POISTETTU)
# Ilmoitetaan onnistuneesta poistosta käyttäjälle.
elif onko_kuvaaja_piirretty(False) and not onko_pisteet_valittu(False):
# Jos kuvaaja on piirretty (tällöin datakin on ladattu) mutta pisteitä ei ole vielä valittu,
# tulostetaan ilmoitus ja asetetaan tilamuuttujalle sopiva arvo
# (jäädään "odottamaan" pisteiden valintaa).
data["tila"] = Odottaa.POISTA
def nollaus():
pelit = 0
voitot = 0
tappiot = 0
aika = 999999
pvm = 0
with open("tilasto.txt", "w") as kohde:
kohde.write("{},{},{}\n".format(pelit, voitot, tappiot))
kohde.write("{:.2f}p{}\n".format(aika, pvm))
kohde.write("{:.2f}p{}\n".format(aika, pvm))
kohde.write("{:.2f}p{}".format(aika, pvm))
ik.kirjoita_tekstilaatikkoon(palikat["tilastolaatikko"], tilasto(), True)
def mainmenu():
'''Valikon mainfunktio joka luo käyttöikkunan käyttäen ikkunastoa'''
ikkuna = iku.luo_ikkuna('Miinaharava')
kehys1 = iku.luo_kehys(ikkuna)
elementit["kehys1"] = iku.luo_kehys(ikkuna, iku.YLA)
elementit["kehys2"] = iku.luo_kehys(ikkuna, iku.ALA)
iku.luo_nappi(kehys1, "Aloita peli", aloita_peli)
iku.luo_nappi(kehys1, "Katsele tuloksia", tulokset)
iku.luo_nappi(kehys1, "Lopeta", lopeta)
elementit["teksti1"] = iku.luo_tekstilaatikko(elementit["kehys1"], 20, 3)
elementit["teksti2"] = iku.luo_tekstilaatikko(elementit["kehys2"], 20, 1)
iku.kirjoita_tekstilaatikkoon(elementit["teksti1"], "MIINAHARAVA")
iku.kirjoita_tekstilaatikkoon(elementit["teksti2"], "A game by Aleksi")
iku.kaynnista()
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 jannitelaskuri(haara, kompZ, kokZ):
"""
Komponenttien jännitteiden ja virran laskeminen.
"""
ikn.kirjoita_tekstilaatikkoon(
KLIITTYMÄ["laskentatulokset"],
"\nhaaran {} komponenttien jännitteet:".format(haara))
for i, Z in enumerate(kompZ):
jannite = Z * (KLIITTYMÄ["jannite"] / kokZ)
tulostus = sim.Si_ksi(jannite)
ikn.kirjoita_tekstilaatikkoon(
KLIITTYMÄ["laskentatulokset"],
"Komponentti: {}, Jännite: {:.3f}{}V".format(
KLIITTYMÄ["komponentit"][haara][i][0], tulostus[0],
tulostus[1]))
def onko_tausta_poistettu(tulosta_virhe):
"""
Tarkistaa, onko käyttäjä poistanut mittausdatasta lineaarisen taustan.
Parametri määrää, tulostetaanko käyttäjälle ohje taustan poistamisesta.
Palauttaa totuusarvon.
"""
if data["summaintensiteetit_taustaton"]: # Jos tausta on poistettu...
return True
if tulosta_virhe:
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
TAUSTA_EI_POISTETTU)
# Muuten tulostetaan virhe, jos niin on pyydetty.
return False
def tallenna_tilastot():
"""
Tallentaa tilastot tiedostoon
"""
nimi = ikkunasto.lue_kentan_sisalto(nimikentta)
if not nimi:
ikkunasto.kirjoita_tekstilaatikkoon(tallennus_ikkuna_laatikko,
"Anna jokin nimimerkki")
else:
with open("tilastot.txt", "a+") as tiedosto:
tiedosto.write("{},{},{},{},{},{},{},{}\n".format(
nimi, tila["aloitusaika"], tila["peliaika"],
tila["voitto"], tila["vuorot"], len(tila["kentta"][0]),
len(tila["kentta"]), tila["miinat"]))
ikkunasto.lopeta()
main()
def onko_kuvaaja_piirretty(tulosta_virhe):
"""
Tarkistaa, onko käyttäjä piirtänyt datasta kuvaajan.
Parametri määrää, tulostetaanko käyttäjälle ohje kuvaajan piirtämisestä.
Palauttaa totuusarvon.
"""
if elementit["graafi"]: # Jos kuvaaja on piirretty...
return True
if tulosta_virhe:
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
KUVAAJA_EI_PIIRRETTY)
# Muuten tulostetaan virhe, jos niin on pyydetty.
return False
def onko_pisteet_valittu(tulosta_virhe):
"""
Tarkistaa, onko käyttäjä valinnut kaksi pistettä.
Parametri määrää, tulostetaanko käyttäjälle ohje pisteiden valitsemisesta.
Palauttaa totuusarvon.
"""
if data["piste_a"] and data[
"piste_b"]: # Jos molemmat pisteet on valittu...
return True
if tulosta_virhe:
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
VALITSE_PISTEET)
# Muuten tulostetaan virhe, jos niin on pyydetty.
return False
def kasittele_pistevalinta(tapahtuma):
"""
Funktiota kutsutaan pick-eventissä, kun käyttäjä klikkaa hiirtä
kuvaajan kohdalla. Pisteiden valinta aloitetaan, jos ja vain jos ohjelma
odottaa käyttäjän syötettä (=pisteiden valintaa) taustan poistoa tai
intensiteetin laskemista varten.
Käyttäjä valitsee kaksi pistettä ja niiden kohdalle piirretään markkerit.
Tallettaa valitut pisteet ohjelman muistiin.
Onnistuneen pistevalinnan jälkeen kutsuu pisteiden käsittelystä vastaavia
funktioita tilamuuttujan arvon mukaan.
"""
artisti = tapahtuma.artist # Artist on nyt kuvaaja.
x_lista = artisti.get_xdata()
y_lista = artisti.get_ydata() # Hankitaan x- ja y-tiedot listoiksi.
indeksi = tapahtuma.ind
# Talletetaan indeksi, jotta tiedot osataan lukea oikeasta kohdasta x- ja y-arvojen listasta.
x = x_lista[indeksi][0]
y = y_lista[indeksi][0]
if data["tila"] == Odottaa.POISTA or data["tila"] == Odottaa.LASKE:
# Ei sallita pisteiden valintaa huvin vuoksi...
elementit["merkit"].extend(elementit["piirto"].plot(
x, y, "kx")) # Lisätään merkki.
elementit["alue"].draw()
if data["piste_a"] and not data[
"piste_b"]: # Onko piste A jo valittu ja B valitsematta?
data["piste_b"] = (x, y)
if data["piste_a"] == data[
"piste_b"]: # Pisteet eivät saa olla samat.
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
VALITSE_ERI_PISTEET)
# Jos näin kuitenkin on, kehotetaan käyttäjää valitsemaan eri pisteet...
nollaa_pisteet() # ...ja nollataan valinnat.
else: # Jos pisteet ovat OK, suoritetaan valittu toiminto.
if data["tila"] == Odottaa.POISTA:
poista_tausta()
elif data["tila"] == Odottaa.LASKE:
laske_intensiteetit()
else: # Jos A on kuitenkin vielä valitsematta...
data["piste_a"] = (x, y)
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 onko_data_ladattu():
"""
Tarkistaa, onko käyttäjä ladannut mittausdatan ja ilmoittaa siitä käyttäjälle.
Palauttaa totuusarvon.
Muista onko_... -funktioista poiketen tämä ei sisällä tulosta_virhe -parametria, sillä
ohje on tarpeen tulostaa aina.
"""
if (not data["energiat"]
or all(summaintensiteetti == 0
for summaintensiteetti in data["summaintensiteetit"])):
# Jos energialista on tyhjä tai kaikki summaintensiteetit ovat nollia, dataa ei ole ladattu.
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
DATAA_EI_LADATTU)
# Ilmoitetaan tästä käyttäjälle.
return False
return True
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 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 kysyja():
ikkuna = ikkunasto.luo_ikkuna("Koko")
kehys = ikkunasto.luo_kehys(ikkuna)
laatikko = ikkunasto.luo_tekstilaatikko(kehys)
teksti = ikkunasto.kirjoita_tekstilaatikkoon(
laatikko,
"Syötä kentän koko (x ruutua kertaa y ruutua)\nYlempään x ja alempaan y"
)
kysyja.kenttax = ikkunasto.luo_tekstikentta(kehys)
kysyja.kenttay = ikkunasto.luo_tekstikentta(kehys)
nappi = ikkunasto.luo_nappi(kehys, "Paina tästä aloittaaksesi",
ikkunasto_napin_kasittelija)
ikkunasto.kaynnista()
def tallenna_kuvaaja():
"""
Tallentaa kuvaajan png-tiedostona käyttäjän valitsemaan paikkaan (tallennusikkunassa).
Tallennus suoritetaan vain, jos data on ladattu ja kuvaaja piirretty.
Tarvittaessa käyttäjää pyydetään suorittamaan "esitehtävät".
Mahdollisesta virheestä ilmoitetaan.
"""
if onko_data_ladattu() and onko_kuvaaja_piirretty(True):
# Tarkistetaan, täyttyvätkö edellytykset: data on ladattu ja kuvaaja on piirretty.
try:
elementit["kuvaaja"].savefig(ik.avaa_tallennusikkuna(
"Tallenna kuvaaja", paate=".png"),
format="png")
# Yritetään tallennusta.
except (FileNotFoundError, IOError):
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
TALLENNUS_EI)
# Tallennus ei onnistunut.
else:
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
TALLENNUS_OK)
def piirinVirta(imp):
"""
Laskee piirin virran.
"""
I = 0
if len(imp) == 1 and imp[0] != 0:
I = KLIITTYMÄ["jannite"] / imp[0]
elif imp[0] == 0:
I = "ääretön"
else:
for Z in imp:
I = I + 1 / Z
I = I**-1
try:
tulostus = sim.Si_ksi(I)
ikn.kirjoita_tekstilaatikkoon(
KLIITTYMÄ["laskentatulokset"],
"\nVirtapiirin virta: {:.3f}{}A".format(tulostus[0], tulostus[1]))
except:
ikn.kirjoita_tekstilaatikkoon(KLIITTYMÄ["laskentatulokset"],
"\nVirtaa ei voida laskea")
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)
