-1
내가 어떤 압력을 플롯이 코드를 사용하여 강조하고 있습니다 :Matplotlib 라인 플롯이 가능하지 않습니까?
대신 점, 삼각형 내가 간단한 라인 (예를 들어,plt.plot(i,P1[i,px,py], "b-"))를 사용할 평방 플롯의
from mpl_toolkits.mplot3d import * # für Druckplots benötigt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from math import * # für pi und exp benötigt
from scipy.special import * # für expn benötigt
import matplotlib.pyplot as plt # für Plotting in 2D/3D benötigt
import numpy as np # für für Arrays benötigt
import csv # optional zum Export von Daten
#from maintest1 import CT
#import os
#clear = lambda: os.system('cls')
#clear()
#==============================================================================
# Globale Parameter
#==============================================================================
rhog = 2700.0 # Dichte überlagerndes Gestein [kg/m³]
z = 3500.0 # Reservoirtiefe [m]
g = 9.81 # Erdbeschleunigung [m/s²]
rhof = 1000.0 # Dichte Flüssigkeit [kg/m³]
lameu = 11.2e9 # Lamé-Parameter, undrained [GPa]
lame = 8.4e9 # Lamé-Parameter, drained [GPa]
pi # durch Pythonmodul "math" gegeben
alpha = 0.65 # Biot-Willis-Koeffizient
G = 8.4e9 # Schermodul [GPa]
k = 1.0e-15 # Permeabilität [m²] bzw. [Darcy]
eta = 0.001 # Viskosität des Fluids [Pa*s]
# q wird bei well festgelegt [m³/s]
# Berechnung der Permeabilität nach Rudnicki (1986), [m³*s/kg]
kappa = k/eta
# Berechnung der Diffusivität
c = ((kappa*(lameu-lame)*(lame+2*G))/((alpha**2)*(lameu+2*G)))
#==============================================================================
# Variablen (max 3 Faults + 3 Bohrungen)
#==============================================================================
# Zeiträume
t = 100*24*3600 # betrachteter Zeitraum [s]
nt = 100 # Anzahl an Zeitschritten
tsteps = t/nt # Zeitschritt [s]
t1start = 0*24*3600 # Startzeitpunkt Bohrung 1 (B1)
t2start = 0*24*3600 # Startzeitpunkt Bohrung 2 (B2)
t3start = 0*24*3600 # Startzeitpunkt Bohrung 3 (B3)
# Förder-oder Injektionsmenge
q1 = 20.0/1000 # Fluidmenge B1
q2 = 0.0/1000 # Fluidmenge B2
q3 = 0.0/1000 # Fluidmenge B3
# Lage der Bohrungen
x1lage, y1lage = 0.0, 0.0 # Lage und Koordinaten von B1 [m]
x2lage, y2lage = 0.0, 0.0 # Lage und Koordinaten von B2 [m]
x3lage, y3lage = 0.0, 0.0 # Lage und Koordinaten von B3 [m]
# Faults
f1x1, f1y1 = 40.0, 40.0 # Startpunkt Fault 1
f1x2, f1y2 = 25.0, 60.0 # Endpunkt Fault 1
f2x1, f2y1 = 40.0, 20.0 # Startpunkt Fault 2
f2x2, f2y2 = 80.0, 40.0 # Endpunktpunkt Fault 2
f3x1, f3y1 = 60.0, 80.0 # Startpunkt Fault 3
f3x2, f3y2 = 80.0, 95.0 # Endpunktpunkt Fault 3
f1nstrike = 50.0 # Streichen gegenüber Nord
f2nstrike = 70.0 # Streichen gegenüber Nord
f3nstrike = 80.0 # Streichen gegenüber Nord
f1length = 500.0 # Länge Fault 1
f2length = 800.0 # Länge Fault 2
f1dip = 30.0 # Fallen Fault 1
f2dip = 45.0 # Fallen Fault 2
f3dip = 60.0 # Fallen Fault 3
#==============================================================================
# Wertebereich
#==============================================================================
# betrachtete Achsenbereiche in NS- und EW-Richtung
# für eine gute Auflösung und Rechengeschwindigkeit bietet es sich an, ein Ver-
# hältnis von 50-100 für (xmax-xmin)/xsteps zu erhalten
xmin = 0.0
xmax = 100.0
nx = 10 # Anzahl Schritte im Bereich xmax-xmin
xsteps = float((xmax-xmin)/nx) # Schrittlänge entlang x-Achse [m]
ymin = 0.0
ymax = 100.0
ny = 10 # Anzahl Schritte im Bereich xmax-xmin
ysteps = float((ymax-ymin)/ny) # Schrittlänge entlang y-Achse [m]
#nx = int((xmax-xmin)/xsteps) # Berechnung der x-Schritte
#ny = int((ymax-ymin)/ysteps) # Berechnung der y-Schritte
# Bildung von Arrays aus den Achsenbereichen
x = np.arange(xmin, xmax, xsteps)
y = np.arange(ymin, ymax, ysteps)
X, Y = np.meshgrid (x, y) # meshgrid bildet alle möglichen Kombinat-
# ionen zwischen x und y
#==============================================================================
# Lage der Störungen + Bohrungen
#==============================================================================
# Variante 1: Anfangs- + Endpunkt
#plt.figure()
#plt.grid(True) # Gitteranzeige einblenden
#plt.title ('Lage der Bohrungen und Stoerungen') # Überschrift des Schaubildes
#plt.xlabel('x-Richtung [m]') # Beschriftung x-Achse
#plt.ylabel('y-Richtung [m]') # Beschriftung y-Achse
#plt.axis([xmin, xmax, ymin, ymax]) # Skalierung der Achsen in [m]
#plt.plot(x1lage, y1lage, "ro", label="Bohrloch 1")
#plt.plot(x2lage, y2lage, "go", label="Bohrloch 2")
#plt.plot(x3lage, y3lage, "bo", label="Bohrloch 3")
#plt.plot([f1x1,f1x2],[f1y1,f1y2],'c-', label = "Fault 1")
#plt.plot([f2x1,f2x2],[f2y1,f2y2],'m-', label = "Fault 2")
#plt.plot([f3x1,f3x2],[f3y1,f3y2],'y-', label = "Fault 3")
#plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., numpoints = 1)
#plt.show()
# Variante 2: mit Länge, Mittelpunkt, Streichen und Dip
#==============================================================================
# Koordinatentransformation von Spannungsfernfeld
#==============================================================================
def CT (sx, sy, sz, sxy, syz, sxz, azimut, rw):
# Winkel
lamda = (90-azimut)*pi/180 # Berechnung von lamda in Bogenmaß
theta = rw*pi/180 # Berechnung von theta in Bogenmaß
# Richtungscosinus
l11 = cos(theta)*cos(lamda)
l12 = cos(theta)*sin(lamda)
l13 = -sin(theta)
l21 = -sin(lamda)
l22 = cos(lamda)
l23 = 0
l31 = cos(lamda)*sin(theta)
l32 = sin(theta)*sin(lamda)
l33 = cos(theta)
# Transformationsgleichungen nach Jaeger et al., 2007
sxneu = l11**2*sx + l12**2*sy + l13**2*sz + 2*l11*l12*sxy + 2*l11*l13*sxz + 2*l12*l13*syz
syneu = l21**2*sx + l22**2*sy + l23**2*sz + 2*l21*l22*sxy + 2*l21*l23*sxz + 2*l22*l23*syz
szneu = l31**2*sx + l32**2*sy + l33**2*sz + 2*l31*l32*sxy + 2*l31*l33*sxz + 2*l32*l33*syz
sxyneu = l11*l21*sx + l12*l22*sy + l13*l23*sz + (l11*l22+l12*l21)*sxy + (l12*l23+l13*l22)*syz + (l11*l23+l13*l21)*sxz
syzneu = l21*l31*sx + l22*l32*sy + l23*l33*sz + (l21*l32+l22*l31)*sxy + (l22*l33+l23*l32)*syz + (l21*l33+l23*l31)*sxz
sxzneu = l11*l31*sx + l12*l32*sy + l13*l33*sz + (l11*l32+l12*l31)*sxy + (l12*l33+l13*l32)*syz + (l11*l33+l13*l31)*sxz
# Ausgabe neuer Spannungen
return sxneu, syneu, szneu, sxyneu, syzneu, sxzneu
# Fernfeldspannungen regional
sv = 0.0 # alternativ: rhog*z*g # Vertikalspannung [MPa]
sH = 0.0 # maximale Horizontalspannung [MPa]
sh = 0.0 # minimale Horizontalspannung [MPa]
azimut = 0.0 # Azimut des Fernfeldes [°]
rw = 0.0 # Rotationswinkel Theta [°]
# Zuweisung Koordinatenachsen für Transformation
#sx = sH
#sy = sh
#sz = sv
sxy = 0.0 # initiale Scherspannung in Ebene xy
syz = 0.0 # initiale Scherspannung in Ebene yz
sxz = 0.0 # initiale Scherspannung in Ebene xz
# Aufruf der Funktion CT und Ausgabe von regionalen, transformierten Spannungen
sxr, syr, szr, sxyr, syzr, sxzr = CT(sH, sh, sv, sxy, syz, sxz, azimut, rw)
#print sxr, syr, szr, sxyr
#print sxr, syr, sxyr
#print azimut
#==============================================================================
# Bohrlöcher
#==============================================================================
def calc (q,tstart,xlage,ylage):
P = np.zeros((nt,nx,ny)) # initiales, leeres Array (Feld) für P
sx = np.zeros((nt,nx,ny)) # initiales, leeres Array (Feld) für sx1
sy = np.zeros((nt,nx,ny)) # initiales, leeres Array (Feld) für sy1
sxy = np.zeros((nt,nx,ny)) # initiales, leeres Array (Feld) für sxy1
fk = (q*alpha*G)/(rhof*4*pi*kappa*(lame+2*G)) # Abkürzung des Vorfaktors
for i in range (nt): # absolute Zeit steckt in i; absolute Zeit = i*tstep
t = i*tsteps-tstart # Zeit ab Produktionsbeginn - t1start berücksichtigt
if t >= 0:
for j in range (nx):
x = xmin+j*xsteps
for k in range (ny):
y = ymin + k*ysteps
r = sqrt((x-xlage)**2+(y-ylage)**2)
if r == 0: # für r = 0 wird r = 0.5 gesetzt, damit nicht durch
r = 0.5 # 0 geteilt wird
if (4*c*(t)) == 0: # wenn der Nenner expn = 0 ist, wird die
# Berechnung ungültig
P[i,j,k] = 0
sx[i,j,k] = 0
sy[i,j,k] = 0
sxy[i,j,k] = 0
else:
# Berechnung des Drucks nach Rudnicki (1986) Eq. 51
P[i,j,k] = ((q/(rhof*4*pi*kappa))*(expn(1,(r**2)\
/(4*c*(t)))))/1e6
# Einführen von fr zwecks Übersicht
fr = (r**2)/(4*c*t)
# Berechnung der Spannungen nach Rudnicki (1986) Eq. 52
sx[i,j,k] = (-1.0)*(fk*((1-(2*(x-xlage)**2/r**2)*(4*c*(t)\
/(r**2)*(1-exp(-fr)))-expn(1,fr))))/1e6
sy[i,j,k] = (-1.0)*(fk*((1-(2*(y-ylage)**2/r**2)*(4*c*(t)\
/(r**2)*(1-exp(-fr)))-expn(1,fr))))/1e6
sxy[i,j,k] = (-1.0)*(fk*((-2*((x-xlage)*(y-ylage))/(r**2))\
*(4*c*(t)/(r**2))*(1-np.exp(-fr))))/1e6
if P[i,j,k] == np.inf:
print i,j,k,r
return P,sx,sy,sxy
P1, sx1, sy1, sxy1 = calc (q1,t1start,x1lage,y1lage)
P2, sx2, sy2, sxy2 = calc (q2,t2start,x2lage,y2lage)
P3, sx3, sy3, sxy3 = calc (q3,t3start,x3lage,y3lage)
#==============================================================================
# Werteberechnung für globales Feld
#==============================================================================
# Erstellen von leeren Arrays für die Addition der...
P = np.zeros((nt,nx,ny)) # ...Drücke B1+B2+B3
sx = np.zeros((nt,nx,ny)) # ...sx-Komponenten B1+B2+B3
sy = np.zeros((nt,nx,ny)) # ...sy-Komponenten B1+B2+B3
sxy = np.zeros((nt,nx,ny)) # ...sxy-Komponenten B1+B2+B3
sxg = np.zeros((nt,nx,ny)) # ...sx-Komponenten B1+B2+B3 und Fernfeld
syg = np.zeros((nt,nx,ny)) # ...sy-Komponenten B1+B2+B3 und Fernfeld
sxyg = np.zeros((nt,nx,ny)) # ...sxy-Komponenten B1+B2+B3 und Fernfeld
# Addition von Druck und Spannungskomponenten der Bohrungen und des Fernfeldes
for i in range (nt):
for j in range (nx):
for k in range (ny):
P[i,j,k] = P1[i,j,k]+P2[i,j,k]+P3[i,j,k] # Druck
sx[i,j,k] = sx1[i,j,k]+sx2[i,j,k]+sx3[i,j,k] # sx-Komponenten
sy[i,j,k] = sy1[i,j,k]+sy2[i,j,k]+sy3[i,j,k] # sy-Komponenten
sxy[i,j,k] = sxy1[i,j,k]+sxy2[i,j,k]+sxy3[i,j,k] # sxy-Komponenten
sxg[i,j,k] = sxr+sx[i,j,k] # sx-Komponenten von globalem Feld
syg[i,j,k] = syr+sy[i,j,k] # sy-Komponenten von globalem Feld
sxyg[i,j,k] = sxyr+sxy[i,j,k] # sxy-Komponenten von globalem Feld
#print sxg[i,j,k], " ", sx[i,j,k], " ", syg[i,j,k], " ", sy[i,j,k]
# Erstellen von leeren Arrays für das Spannungsfeld an jedem Punkt
angle = np.zeros((nt,nx,ny))
sHg = np.zeros((nt,nx,ny))
shg = np.zeros((nt,nx,ny))
for i in range (nt):
for j in range (nx):
x = xmin+j*xsteps
for k in range (ny):
y = ymin + k*ysteps
angle[i,j,k] =(np.arctan2(2*sxyg[i,j,k],(sxg[i,j,k]-syg[i,j,k])))/2 # berechnet Hauptspannungswinkel
sHg[i,j,k] = sxg[i,j,k]*(cos(angle[i,j,k]))**2 + syg[i,j,k]*(sin(angle[i,j,k]))**2 + 2*(sxyg[i,j,k]*sin(angle[i,j,k])*cos(angle[i,j,k]))
shg[i,j,k] = sxg[i,j,k]*(sin(angle[i,j,k]))**2 + syg[i,j,k]*(cos(angle[i,j,k]))**2 - 2*(sxyg[i,j,k]*sin(angle[i,j,k])*cos(angle[i,j,k]))
hel = np.degrees(angle[i,j,k])
#print hel
#print sHg[i,j,k], " ", shg[i,j,k]
#==============================================================================
# Plotting
#==============================================================================
xPosition = 60.0
yPosition = 0.0
px = float((xmin+xPosition)/xsteps)
py = float((ymin+yPosition)/ysteps)
fig=plt.figure()
ax=fig.add_subplot(1,1,1)
Zeit = nt-1 # Zeitschritte-1, sonst Fehlermeldung
Tage = float((Zeit*tsteps)/(24*3600))
Jahre = float(Zeit*tsteps)/(24*3600*365)
print "Zeit:", Tage , "Tage", "oder", "%.3f" % Jahre, "Jahre"
print "nt =", tsteps/86400, "Tag(e)"
plt.title("zeitliche Entwicklung von P")
for i in range (nt):
plt.plot(i, sx1[i,px,py], "r^")
plt.plot(i, sy1[i,px,py], "go")
plt.plot(i, P1[i,px,py], "bo")
plt.grid(True)
plt.xlabel("Zeitschritte nt")
plt.ylabel("Druck [MPa]")
plt.show()
. 만약 내가 코드를 실행하려고, 내가 어떤 음모를 참조하십시오. 이유가 있니? 모든 솔루션 지금까지 ...
A.
for 루프에있는 것처럼 각 포인트를 플로팅하는 대신 한 번의 호출로 각 라인을 플롯하지 않는 이유는 무엇입니까? 'plt.plot (sx1, "r ^")'예를 들면. –
_way_ _way_ 코드가 너무 많습니다. 이걸 10 줄로 줄 수 있니? – tacaswell