# Twoj kod .... for i in range(4 * N): Rhs[bcnodesAll[i]] = bvals[i] # Time loop Results = list() Results.append(np.array(Rhs.reshape((N, N)))) for iter in range(NTimeSteps): print 'time iteration:', iter + 1 sol = solve(EqMat, Rhs) if sol[1] != 0: print "solution is not converged" T = np.array(sol[0]) # Zaktualizuj wektor prawych stron Rhs = T # Zapisz rozwiazania w liscie, na skonwertuj wyniki z wektora na tablice 2D # T = ... twoj kod .. T = np.reshape(T, (N, N)) Results.append(T) print("\n--- %s seconds ---" % (time.time() - start_time)) # Animate results: animate_contour_plot(Results, skip=20, repeat=True)
# Zadaj warunki brzegowe i poczatkowe w wektorze prawych stron (skorzystaj z tablic bvals i bcnodes) # Twoj kod .... for i in range(4 * N): Rhs[bcnodesAll[i]] = bvals[i] #Tworzymy zbior rozwiazan Results = list() #Dodajemy pierwsze rozwiazanie Results.append(np.array(Rhs.reshape((N, N)))) # Petla czasowa for iter in range(NTimeSteps): print 'time iteration:', iter + 1 #T = ... rozwiaz rownanie T = np.linalg.solve(EqMatrix, Rhs) # Zaktualizuj wektor prawych stron #Rhs = .... Rhs = T #Zapisz rozwiazania w liscie, na skonwertuj wyniki z wektora na tablice 2D # T = ... twoj kod .. T = np.reshape(T, (N, N)) Results.append(T) print("\n--- %s seconds ---" % (time.time() - start_time)) # Wyswietl wyniki: animate_contour_plot(Results, skip=5, repeat=True)
K[d_id(K,1)]=1 # Diagonala odnoszaca sie do wezlow T[i,j+1] K[d_id(K,N)]=1 print(K) # Zmodyfikuj rownania w macierzy tak, aby jawnie wprowadzic rozwiazania dla wezlow brzegowych (odwolaj sie do # indeksow za pomoca tablicy bcnodesAll) for i in bcnodes: K[bcnodesAll,:]=0 K[bcnodesAll,bcnodesAll]=1 print(K) # Utworz wektor prawych stron rownania Rhs = np.zeros(N**2) # Zadaj warunki brzegowe w wektorze prawych stron (skorzystaj z tablic bvals i bcnodes) for wartosc_na_brzegu, ind_wezl_brzegu in zip(bvals,bcnodes): Rhs[ind_wezl_brzegu] = wartosc_na_brzegu print(Rhs) # Rozwiaz rownanie T = np.array( solve(K, Rhs) ) # Rebuild T to 2D array T = T.reshape((N,N)) print("\n"+"T") print(T) # Plot result animate_contour_plot([T])
K[d_id(K, 1)] = 1 # Diagonala odnoszaca sie do wezlow T[i,j+1] K[d_id(K, N)] = 1 print(K) # Zmodyfikuj rownania w macierzy tak, aby jawnie wprowadzic rozwiazania dla wezlow brzegowych (odwolaj sie do # indeksow za pomoca tablicy bcnodesAll) for i in bcnodes: K[bcnodesAll, :] = 0 K[bcnodesAll, bcnodesAll] = 1 print(K) # Utworz wektor prawych stron rownania Rhs = np.zeros(N**2) # Zadaj warunki brzegowe w wektorze prawych stron (skorzystaj z tablic bvals i bcnodes) for wartosc_na_brzegu, ind_wezl_brzegu in zip(bvals, bcnodes): Rhs[ind_wezl_brzegu] = wartosc_na_brzegu print(Rhs) # Rozwiaz rownanie T = np.array(solve(K, Rhs)) # Rebuild T to 2D array T = T.reshape((N, N)) print("\n" + "T") print(T) # Plot result animate_contour_plot([T])
time = np.linspace(0, 1, int(1./dt + 1)) forward = range(2,N) backward = range(0,N-2) c = a*dt/delta**2 #time loop for t in time: print "time:",t #Equation for new time solution - explicite euler sheme: # (Tn - T0)/dt -a*laplacian(T0)=0 # Tn = T0 + a*dt*laplacian(T0) # Tn = T0 + (a*dt/dx**2)*(T0(i,j+1) + T0(i+1,j) - 4*T0(i,j) + T0(i-1,j) + T0(i,j-1) ) #Loop form # for j in range(1, N-1): # for i in range(1,N-1): # T[i,j] += c * ( T[i,j+1] + T[i+1,j] - 4*T[i,j] + T[i-1,j] + T[i,j-1]) #Vecotrized code T[1:-1,1:-1] = T[1:-1,1:-1] + c*(T[1:-1,forward] + T[forward,1:-1] - 4*T[1:-1,1:-1] + T[backward,1:-1] + T[1:-1,backward]) Results.append(np.copy(T)) # Animate results: animate_contour_plot(Results, skip=100)
print "calculating time :",t # (T - T0)/dt -a*laplacian(T0)=0 # T = T0 + a*dt*laplacian(T0) # T = T0 + (a*dt/dx**2)*(T0(i,j+1) + T0(i+1,j) - 4*T0(i,j) + T0(i-1,j) + T0(i,j-1) ) # Pamietaj, ze na brzegach jest zadany waruenek typu Dirichleta, zatem w tych wezlach # wartosci nie powinny sie zmieniac # Twoj kod .... # for j in range(1,N-1): # for i in range(1,N-1): # T[i][j] = T0[i][j] + (a*dt/delta**2)*(T0[i][j+1] + T0[i+1][j] - 4*T0[i][j] + T0[i-1][j] + T0[i][j-1]) backward = range(0,N-2) forward = range(2,N) T[1:-1,1:-1] = T0[1:-1,1:-1] + c*(T0[backward,1:-1] + T0[1:-1,backward] - 4*T0[1:-1,1:-1] + T0[1:-1,forward] + T0[forward,1:-1]) T0 = np.copy(T) Results.append(T0) # Animate results: # Wywolaj funkcje z zadania 1, tak aby wyswietlic animacje rozkladu temperatury animate_contour_plot(Results, skip=20, nLevels= 20)
time = np.linspace(0, endTime, int(endTime / dt + 1)) #time loop T0 = np.copy(T) for t in time: print "calculating time :", t #Zaimplementuj funkcje obliczajaca jeden krok czasowy zgodnie z poniższym wzorem: # (T - T0)/dt -a*laplacian(T0)=0 # T = T0 + a*dt*laplacian(T0) # T = T0 + (a*dt/dx**2)*(T0(i,j+1) + T0(i+1,j) - 4*T0(i,j) + T0(i-1,j) + T0(i,j-1) ) # Pamietaj, ze na brzegach jest zadany waruenek typu Dirichleta, zatem w tych wezlach # wartosci nie powinny sie zmieniac c = a * dt / delta**2 for j in range(1, N - 1): for i in range(1, N - 1): T[i, j] = T0[i, j] + c * (T0[i + 1, j] + T0[i, j + 1] - 4 * T[i, j] + T0[i - 1, j] + T0[i, j - 1]) T0 = np.copy(T) Results.append(T0) # Animate results: # Wywolaj funkcje z zadania 1, tak aby wyswietlic animacje rozkladu temperatury animate_contour_plot(Results, skip=20)