Contur Plot

thenewone · Dienstag 9. Dezember 2014, 15:59

Hallo,

ich bin neu einsteiger in python. nun habe ich ein Problem, dass mich nun schon 2 Tage lang ärgert.
Ich habe eine Funktion Q, die am Ende von d und D abhängig sein soll. Dazu habe ich ein Programm geschrieben, mit diversen Formeln.
Das Programm funktioniert, habe es auch per Hand ausgerechnet.
Im Quellcode unten habe ich es einach weggelassen und euch nur die wichtigen teile reinkopiert.
ich würde nun gerne einen Konturplot zeichnen, mit d und D als Achsen und Q soll die Konturen bilden.
Es sollte so aussehen, dass Q einigermaßen ellipsen bildet.
jedoch bekomme ich mit meinem Code nur müll als Plot.

Da ich mir nun leider absolut nicht mehr zu helfen weiß, frage ich euch um rat.
Ich freue mich über jede Hilfe

Lg

Code: Alles auswählen

import matplotlib.pyplot as plt
import numpy as np

global d
d= np.arange(0.0, 1.0, 0.01)
global D
D= np.arange(0.0, 1.0, 0.01)

_d, _D= np.meshgrid(d,D)

.......................................

def Q(_X_L_c, _R_ESR):
    return (_X_L_c/_R_ESR)
_Q=Q(_X_L_c, _R_ESR)

......................................

plt.contour([_D],[_d],[_Q]) <- hier habe ich es auch schon mit (_D, _d,_Q) versucht
plt.axis([0.0, 1.0, 0.0, 2.0])
plt.ylabel('D')
plt.xlabel('d')
plt.show()

MagBen · Dienstag 9. Dezember 2014, 20:47

Dein Code is nicht Lauffähig:
Kommentare sind ohne das Kommentarzeichen #,
_X_L_c, _R_ESR in Zeile 15 sind nicht definiert.

Die Zeilen 4 und 6 sind überflüssig (aber syntaktisch korrekt).

Poste hier ein lauffähiges Beispiel, dann kann ich Dir helfen den Plot hübsch zu machen.

Sirius3 · Mittwoch 10. Dezember 2014, 08:19

@thenewone: Variablennamen sind dafür da, dass man weiß, was sie enthalten. Deine Namen sind alle nicht dafür da. Was sollen denn die vielen Unterstriche und vor allem, warum fangen Namen mit einem Unterstreich an ?!

thenewone · Mittwoch 10. Dezember 2014, 09:10

Hey

danke schonmal für die antworten

Die unterstriche, sollen inizes darstellen. da diese auch in der originalgleich so aussehen.
Die gleichungen dienen im allgemeinen dazu, einen helical resonator zu optimieren, und das von d und D abhängig zu machen.
Q ist dabei ein Maß dafür.

hier mein Kompletter code:

Code: Alles auswählen

# -*- coding: utf-8 -*-
"""
Created on Mon Dec 08 15:09:55 2014

@author: sigusc01
"""
import matplotlib.pyplot as plt
import numpy as np

global d
d= np.arange(0.0, 1.0, 0.01)
global D
D= np.arange(0.0, 1.0, 0.01)

_d, _D= np.meshgrid(d,D)
global C_sigma
C_sigma=2e-11#F
global roh
roh=1.68*(10**(-8)) #Ohm @ 20°C
global d_0
d_0=0.005#m
global delta
delta=0.00003#m @ 30MHz
global pi
pi=3.141#???
global K_cb
K_cb=(11.26*10**(-12))
global w0
w0=25000000#Hz
global R_j
R_j=0.1#Ohm
global R_t
R_t=0#Vernachlässigbar
global alpha
alpha=0#da R_t=0, nicht mehr relevant für die Rechnung
global tau
tau=0.008#m

#K_cd aus Text
def K_cd(_d):
    return 35.0*_d*(10.0**(-12.0))
_K_cd=K_cd(_d)

#K_cs aus Gl.26    
def K_cs(_d,_D):
    return 39.37*((0.75)/(log10(_D/_d)))*(10.0**(-12.0))
_K_cs=np.array(K_cs(_d,_D)) #weil sonst typen Fehler

#K_lc aus Gl.27   
def K_lc(_d,_D,tau):
    return 39.37*((0.025*(_d**2)*(1-(_d/_D)**2))/(tau**2))*(10**(-6))
_K_lc=K_lc(_d,_D,tau)

#b aus Gl.28    
def b(C_sigma, _K_cd , K_cb, _K_cs,_K_lc, w0):
    return ((C_sigma)+(_K_cd))/((_K_cs)+(K_cb))*(sqrt((_K_cs+(K_cb))/((C_sigma+(_K_cd))**2.0*(_K_lc)*w0**2)+0.25)-0.5)
_b=b(C_sigma, _K_cd, K_cb, _K_cs, _K_lc, w0)


#L_c aus Gl.27
def L_c(_b, _d,_D,tau):
    return 39.37*_b*((0.025*(_d**2)*(1-((_d/_D)**2)))/(tau**2))*(10**(-6))
_L_c=L_c(_b, _d,_D,tau)

#von Stephan ausgerechnet    
def lc(_b, _d, tau, pi):
    return((_b)/(tau))*_d*pi
_lc=(lc(_b, _d, tau, pi))

#N_s aus Gl.31    
def N_s(_b, _lc, pi, _D, _d):
    return (_b*_lc)/(4.0*3.0*(_D-_d)**2.0)
_N_s=N_s(_b, _lc, pi, _D, _d)

#l_s aus Gl.32    
def l_s(_N_s, pi, _D, _b):
    return (_N_s*sqrt(((pi**2.0)*(_D**2.0))+((_b/_N_s)**2.0)))
_l_s=l_s(_N_s, pi, _D, _b)

#R_s aus Gl.35     
def R_s(_N_s, roh, _l_s, _b, delta):
    return ((_N_s*roh*_l_s)/(_b*delta))
_R_s=R_s(_N_s, roh, _l_s, _b, delta)
    
#R_c aus Gl.34
def R_c(roh, _lc, d_0, pi, delta):
    return ((roh*_lc)/(d_0*pi*delta))
_R_c=R_c(roh, _lc, d_0, pi, delta)

#R_ESR aus Gl.24   
def R_ESR(R_j, _R_c, _R_s, R_t, alpha):
    return (R_j+_R_c+_R_s+R_t*(alpha**2.0))
_R_ESR=R_ESR(R_j, _R_c, _R_s, R_t, alpha)
    
def X_L_c(_L_c, w0):
    return _L_c*w0
_X_L_c=X_L_c(_L_c, w0)
    
#Q aus Gl. 22    
def Q(_X_L_c, _R_ESR):
    return (_X_L_c/_R_ESR)
_Q=Q(_X_L_c, _R_ESR)

plt.contour(_D,_d, _Q)
plt.axis([0.0, 1.0, 0.0, 2.0])
plt.ylabel('D')
plt.xlabel('d')
plt.show()

thenewone · Mittwoch 10. Dezember 2014, 10:25

was ich eben noch herrausgefunden habe, dass meine arrays am schluss nan enthalten.
ich schätze mal, dass da der Fehler drin liegenkönnte, habe bis jetzt aber noch keine Lösung gefunden

BlackJack · Mittwoch 10. Dezember 2014, 11:36

@thenewone: Vergiss bitte gleich wieder das es die ``global``-Anweisung überhaupt gibt. Verstanden hast Du sie sowieso nicht, denn auf Modulebene hat diese Anweisung überhaupt gar keinen Effekt. Du kannst die alle weglassen ohne das sich am Verhalten des Programms etwas ändert.

Pi gibt es bereits vordefiniert im Numpy-Modul, das muss man nicht selber angeben.

Ich verstehe nicht so ganz was die Funktionen sollen. Du hast da ja immer das Muster: Funktionsdefinition die lokale Namen verwendet die den globalen Namen entsprechen direkt gefolgt von einem einzigen Aufruf der Funktion mit eben diesen globalen Namen und das Ergebnis an einen Namen gebunden der dem Funktionsnamen mit einem führenden Unterstrich entspricht. Warum so umständlich? Da hätte man auch gleich die Rechnung direkt hinschreiben können.

MagBen · Mittwoch 10. Dezember 2014, 11:44

Du siehst deshalb nichts im Contourplot, weil Deine Daten eine ziemlich flache Ebene bilden mit einem sehr schmalen und hohem Maximum (Polstelle?). Deshalb musst Du Matplotlib ein bisschen auf die Sprünge helfen, willst Du die Ebene oder die Spitze detailliert mit Höhenlinien aufgelöst haben oder beides?

Mach zum Test erstmal ein paar 1D-Schnitte durch die Ebene:

Code: Alles auswählen

plt.figure()
plt.plot(_D, _Q[50])
plt.show()

Hier noch ein paar Tips um den Code zu verbessern:
Streich alle Zeilen mit "global", das Skript braucht das wirklich nicht.
Streich Zeile 25, pi gibt's schon: np.pi

Mach nicht aus jeder Gleichung eine Funktion die Du nur einmal benutzt, also statt

Code: Alles auswählen

#K_cd aus Text
def K_cd(_d):
    return 35.0*_d*(10.0**(-12.0))
_K_cd=K_cd(_d)

besser

Code: Alles auswählen

#K_cd aus Text
_K_cd=35.0e-12*_d

dann kannst Du auch alle _ am Anfang der Namen weglassen.

Anstatt

Code: Alles auswählen

10.0**(-12.0)

besser

Code: Alles auswählen

1.e-12

Code: Alles auswählen

d=np.arange(0.0, 1.0, 0.01)

erzeugt nicht Werte von 0 bis 1, sondern nur 100 Werte von 0 bis .99, nimm lieber

Code: Alles auswählen

d= np.linspace(0.0, 1.0, 101)

das macht 101 Werte von 0 bis 1 im Abstand von 0.01