def impl_fit(self):
par = self.par
pixel = par.pixel
# TODO Multi-Prozessierung
def neu():
return np.ones((pixel, pixel))
erg_resfreq = neu()
fhlr_resfreq = neu()
erg_amp = neu()
fhlr_amp = neu()
erg_q = neu()
fhlr_q = neu()
erg_phase = neu() # single phase point off resonance
fhlr_phase = neu()
offset = neu()
if Fit.debug_schnell:
pixel = 0
"""Pool().map(
lambda y: Pool().map(
lambda x: self.fit(amplituden[x], phasen[x]),
range(pixel)
),
range(pixel)
)"""
for y in range(pixel):
amplituden = self.messwerte.amplituden(y)
phasen = self.messwerte.phasen(y)
for x in range(pixel):
amp, ph = self.fit(amplituden[x], phasen[x])
erg_resfreq[y, x] = amp.best_values['resfreq']
fhlr_resfreq[y, x] = amp.params['resfreq'].stderr
erg_amp[y, x] = amp.best_values['amp']
fhlr_amp[y, x] = amp.params['amp'].stderr
erg_q[y, x] = amp.best_values['guete']
fhlr_q[y, x] = amp.params['guete'].stderr
offset[y, x] = amp.params['off']
erg_phase[y, x] = ph.mit_versatz
fhlr_phase[y, x] = ph.chisqr # TODO
self.signal_weiter()
# Fitprozess abschließen ##########
self.erg = Ergebnis(
FitWerte(erg_resfreq, fhlr_resfreq),
FitWerte(erg_amp, fhlr_amp),
FitWerte(erg_q, fhlr_q),
FitWerte(erg_phase, fhlr_phase)
)
def _fit_punkt(n):
"""
:type n: int
:return: Gefittete Amplitude und gefittete oder geglättete Phase im Bereich um Resonanzfrequenz +/- Versatz
:rtype: list
"""
if not _weiter:
return None
# ----------------------------------------
# ----------- AMPLITUDE fitten -----------
# ----------------------------------------
amplitude = savgol_filter(_bereich(_amplitude_voll[n]), _par.filter_breite,
_par.filter_ordnung)
index_max = numpy.argmax(amplitude)
start_freq = _frequenz[index_max]
start_amp = amplitude[index_max]
start_off = amplitude[
0] # Erster betrachteter Wert ist bereits eine gute Näherung für den Untergrund
# Fitparameter für die Fitfunktion
par_amp = Parameters()
par_amp.add('resfreq', value=start_freq, min=_par.fmin, max=_par.fmax)
par_amp.add('amp', value=start_amp, min=_par.amp_min, max=_par.amp_max)
par_amp.add('guete',
value=0.5 * (_par.amp.guete_max + _par.amp.guete_min),
min=_par.amp.guete_min,
max=_par.amp.guete_max)
par_amp.add('untergrund',
value=start_off,
min=_par.amp.off_min,
max=_par.amp.off_max)
amp = _mod_amp.fit(data=amplitude,
freq=_frequenz,
params=par_amp,
fit_kws=_fit_genauigkeit)
# TODO puls()
# Wenn keine Phase gefittet werden soll:
if _mod_ph is KEIN_FIT:
return Ergebnis(amp=amp.params['amp'].value,
amp_fhlr=amp.params['amp'].stderr,
resfreq=amp.params['resfreq'].value,
resfreq_fhlr=amp.params['resfreq'].stderr,
guete_amp=amp.params['guete'].value,
guete_amp_fhlr=amp.params['guete'].stderr,
untergrund=amp.best_values['untergrund'])
# Resonanzfrequenz
resfreq = amp.best_values['resfreq']
# ----------------------------------------
# ------------- PHASE fitten -------------
# ----------------------------------------
halb = abs(_par.phase_versatz
) + 10 * _par.df # Halbe Frequenzbreite des Phasenversatzes
# +df, weil der Fit auch bei Versatz = 0 funktionieren muss
von = resfreq - halb # Untere Versatzgrenze
bis = resfreq + halb # Obere Versatzgrenze
if von < _par.fmin: # Die Resonanzfrequenz liegt zu weit links:
# Auswahlbereich nach rechts verschieben, aber nicht über den Frequenzbereich hinaus
bis = min(bis - von + _par.fmin, _par.fmax)
von = _par.fmin
elif bis > _par.fmax: # Die Resonanz lieg zu weit rechts:
von = max(von - bis + _par.fmax,
_par.fmin) # Verschieben, aber nicht über linken Rand hinaus
bis = _par.fmax
# Phase beschneiden
index_von = index_freq(_par, von)
index_bis = index_freq(_par, bis)
wahl_phase = _bereich(_phase_voll[n])[index_von:index_bis]
if _mod_ph is GLAETTEN: # Nur glätten:
phase = savgol_filter(wahl_phase, _par.filter_breite,
_par.filter_ordnung)
return Ergebnis(amp=amp.params['amp'].value,
amp_fhlr=amp.params['amp'].stderr,
resfreq=amp.params['resfreq'].value,
resfreq_fhlr=amp.params['resfreq'].stderr,
guete_amp=amp.params['guete'].value,
guete_amp_fhlr=amp.params['guete'].stderr,
untergrund=amp.best_values['untergrund'],
phase=randwert(phase, _par.phase_versatz))
else:
# Fitparameter für die Fitfunktion
par_ph = Parameters()
par_ph.add('resfreq', value=resfreq, min=von, max=bis)
par_ph.add('guete',
value=3,
min=_par.phase.guete_min,
max=_par.phase.guete_max)
par_ph.add('rel',
value=200,
min=_par.phase.off_min,
max=_par.phase.off_max)
ph = _mod_ph.fit(
data=wahl_phase,
freq=_frequenz[index_von:index_bis],
params=par_ph,
method='cg' # 'differential_evolution' passt auch gut
# TODO fit_kws=self.fit_genauigkeit
)
return Ergebnis(amp=amp.params['amp'].value,
amp_fhlr=amp.params['amp'].stderr,
resfreq=amp.params['resfreq'].value,
resfreq_fhlr=amp.params['resfreq'].stderr,
guete_amp=amp.params['guete'].value,
guete_amp_fhlr=amp.params['guete'].stderr,
untergrund=amp.best_values['untergrund'],
phase=randwert(ph.best_fit, _par.phase_versatz),
guete_ph=ph.best_values['guete'],
phase_rel=ph.best_values['rel'],
phase_fhlr=ph.params['resfreq'].stderr)
class Fit(AbstraktFit):
def __init__(self, laden, par):
"""
:type laden: Module.Raster.Laden.GuiRasterLaden
:type par: Module.Raster.Parameter.Parameter
"""
AbstraktFit.__init__(self, laden, par)
self.messwerte = None
""" :type: Messwerte """
self.erg = None
""" :type: Ergebnis """
def impl_fit(self):
par = self.par
pixel = par.pixel
# TODO Multi-Prozessierung
def neu():
return np.ones((pixel, pixel))
erg_resfreq = neu()
fhlr_resfreq = neu()
erg_amp = neu()
fhlr_amp = neu()
erg_q = neu()
fhlr_q = neu()
erg_phase = neu() # single phase point off resonance
fhlr_phase = neu()
offset = neu()
if Fit.debug_schnell:
pixel = 0
"""Pool().map(
lambda y: Pool().map(
lambda x: self.fit(amplituden[x], phasen[x]),
range(pixel)
),
range(pixel)
)"""
for y in range(pixel):
amplituden = self.messwerte.amplituden(y)
phasen = self.messwerte.phasen(y)
for x in range(pixel):
amp, ph = self.fit(amplituden[x], phasen[x])
erg_resfreq[y, x] = amp.best_values['resfreq']
fhlr_resfreq[y, x] = amp.params['resfreq'].stderr
erg_amp[y, x] = amp.best_values['amp']
fhlr_amp[y, x] = amp.params['amp'].stderr
erg_q[y, x] = amp.best_values['guete']
fhlr_q[y, x] = amp.params['guete'].stderr
offset[y, x] = amp.params['off']
erg_phase[y, x] = ph.mit_versatz
fhlr_phase[y, x] = ph.chisqr # TODO
self.signal_weiter()
# Fitprozess abschließen ##########
self.erg = Ergebnis(
FitWerte(erg_resfreq, fhlr_resfreq),
FitWerte(erg_amp, fhlr_amp),
FitWerte(erg_q, fhlr_q),
FitWerte(erg_phase, fhlr_phase)
)
def lade_messwerte(self):
self.messwerte = Messwerte(self.par)
def speichern(self, wohin):
"""
:type wohin: str
"""
self.erg.speichern(wohin)
if anzahlZuerueckgelegt == 0 or (
wurfIndex == Config.MAX_ANZAHL_WUERFE - 1 and aktuellerSpieler == aktiveSpieler[0]):
""" Spieler will nicht mehr würfeln und lässt stehen """
if Config.LOG_WUERFE: print("{0} lässt stehen.".format(aktuellerSpieler))
break
else:
""" Spieler will weiterwürfeln """
aktuellerSpieler.wuerfeln()
aufgedeckteWuerfel = aktuellerSpieler.aufdecken()
wurfErgebnis = Ergebnis([w.augenzahl for w in aufgedeckteWuerfel])
if Config.LOG_WUERFE: print("Wurf: {0}".format(wurfErgebnis))
gesamtErgebnis = Ergebnis(tischErgebnis.augen + wurfErgebnis.augen)
aktuellerWurf.set_ergebnis(gesamtErgebnis)
aktuellerZug.add_wurf(aktuellerWurf)
# Würfe von Spieler X sind vorbei
if Config.LOG_ZUEGE: print("{0} beendet seinen Zug".format(aktuellerSpieler))
aktuellerZug.endergebnis = gesamtErgebnis
if Config.LOG_ZUEGE: print("Zugergebnis: {0}".format(gesamtErgebnis))
aktuelleRunde.add_zug(aktuellerZug)
if gesamtErgebnis.is_schock_aus():
break
