1582 lines
61 KiB
Python
1582 lines
61 KiB
Python
import h5py
|
|
from dolfin import *
|
|
import numpy as np
|
|
from matplotlib import pyplot as plt
|
|
import scipy as sc
|
|
import scipy.io as sio
|
|
from mpl_toolkits.mplot3d import Axes3D
|
|
from mpl_toolkits.mplot3d import proj3d
|
|
import os, sys
|
|
import csv
|
|
from common import inout
|
|
import time
|
|
|
|
from matplotlib import rc
|
|
#rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})
|
|
rc('text', usetex=True)
|
|
|
|
|
|
def MATmedical(path):
|
|
|
|
|
|
datatype = None
|
|
|
|
if 'ODV' in path:
|
|
datatype = 'odv'
|
|
print('The DATA file has the next structure: [x,y,z,coil,CardiacPhase,gradient,NSA] where x \
|
|
and y are the spatial dimensions for the image. z is one because is only one slice. Coil is \
|
|
the number of coils (5), CardiacPhase is the time dimension. Gradient is the number of gradients used in the \
|
|
adquisition (2). NSA is the number of signal average.')
|
|
|
|
if 'Phantom' in path:
|
|
datatype = 'cib_phantom'
|
|
#print('CIB phantom data which contains magnitude and velocity measurements.')
|
|
|
|
|
|
if not datatype=='cib_phantom':
|
|
STRUC = sio.loadmat(path)
|
|
DAT0 = STRUC['data']
|
|
if datatype=='odv':
|
|
KDAT0 = STRUC['kdata']
|
|
[row,col,coil,numt2,p4,p5] = DAT0.shape
|
|
else:
|
|
KDAT0 = STRUC['k_data']
|
|
[row,col,slicesel,coil,numt2,p4,p5] = DAT0.shape
|
|
|
|
|
|
z0 = 0
|
|
NSA = 0
|
|
coilnum = 3
|
|
|
|
DAT1 = np.zeros([row,col,numt2],dtype=complex)
|
|
DAT2 = np.zeros([row,col,numt2],dtype=complex)
|
|
KDAT1 = np.zeros([row,col,numt2],dtype=complex)
|
|
KDAT2 = np.zeros([row,col,numt2],dtype=complex)
|
|
|
|
if datatype=='odv':
|
|
for k in range(numt2):
|
|
DAT1[:,:,k] = DAT0[:,:,coilnum,k,0,NSA]
|
|
DAT2[:,:,k] = DAT0[:,:,coilnum,k,1,NSA]
|
|
KDAT1[:,:,k] = KDAT0[:,:,coilnum,k,0,NSA]
|
|
KDAT2[:,:,k] = KDAT0[:,:,coilnum,k,1,NSA]
|
|
|
|
return [DAT1,DAT2,KDAT1,KDAT2]
|
|
else:
|
|
|
|
UK1 = np.zeros([row,col,numt2],dtype=complex)
|
|
UK2 = np.zeros([row,col,numt2],dtype=complex)
|
|
|
|
for k in range(numt2):
|
|
DAT1[:,:,k] = DAT0[:,:,z0,coilnum,k,0,NSA]
|
|
DAT2[:,:,k] = DAT0[:,:,z0,coilnum,k,1,NSA]
|
|
KDAT1[:,:,k] = KDAT0[:,:,z0,coilnum,k,0,NSA]
|
|
KDAT2[:,:,k] = KDAT0[:,:,z0,coilnum,k,1,NSA]
|
|
UK1[:,:,k] = np.fft.fftshift(np.fft.fft2(DAT1[:,:,k]))
|
|
UK2[:,:,k] = np.fft.fftshift(np.fft.fft2(DAT2[:,:,k]))
|
|
|
|
return [DAT1,DAT2,KDAT1,KDAT2]
|
|
|
|
elif datatype=='cib_phantom':
|
|
|
|
lp = len(path)
|
|
for k in range(lp):
|
|
if path[lp-1-k]=='/':
|
|
name_var = path[lp-k:lp]
|
|
break
|
|
|
|
name_var = name_var.replace('.mat','')
|
|
|
|
if name_var in ['VENC','Segmented_Aorta','voxel_MR']:
|
|
STRUC = sio.loadmat(path)
|
|
return STRUC[name_var]
|
|
else:
|
|
#import h5py
|
|
arrays = {}
|
|
f = h5py.File(path)
|
|
for k, v in f.items():
|
|
arrays[k] = np.array(v)
|
|
|
|
return arrays[name_var].transpose((1,2,3,0))
|
|
|
|
def Plot_Inlet():
|
|
''' To Show the flow given at the inlet in the FEM simulation '''
|
|
|
|
Tf = 0.9
|
|
dt = 0.0005
|
|
t = np.linspace(0,Tf,Tf/dt)
|
|
U = 60
|
|
Th = 0.37
|
|
DOLFIN_PI = 3.1416
|
|
y = U*np.sin(DOLFIN_PI*t/Th)*(t<=Th) + (Th<t)*(3.67949466208*U*np.sin(9*DOLFIN_PI*t/Th)*np.exp(-t*10))
|
|
|
|
|
|
Delta = 5
|
|
ts = 0.33
|
|
beta = DOLFIN_PI/Th*(Delta/np.tan(Delta*DOLFIN_PI*ts/Th) - 1/np.tan(DOLFIN_PI*ts/Th))
|
|
alpha = np.exp(ts*beta)*np.sin(DOLFIN_PI*ts/Th)/np.sin(Delta*DOLFIN_PI*ts/Th)
|
|
|
|
y2 = U*np.sin(DOLFIN_PI*t/Th)*(t<=ts) + (ts<t)*(alpha*U*np.sin(Delta*DOLFIN_PI*t/Th)*np.exp(-t*beta) )
|
|
|
|
|
|
print('alpha',alpha)
|
|
print('beta',beta)
|
|
|
|
plt.plot(t,y2)
|
|
plt.show()
|
|
|
|
def Plot_Histogram(meshnames,paths,colors,outpath):
|
|
|
|
alphas = [0.72, 1]
|
|
|
|
plt.figure(figsize=(8, 6), dpi=100)
|
|
ind = 0
|
|
|
|
for nm in range(len(meshnames)):
|
|
|
|
if 'box' in meshnames[nm]:
|
|
# VOXEL SEQUENCE SIZE
|
|
Lx = 64
|
|
Ly = 64
|
|
Lz = 90
|
|
# The BOX where undersampling take place
|
|
x0 = 10
|
|
y0 = 12
|
|
z0 = 0
|
|
x1 = 21
|
|
y1 = 20
|
|
z1 = 12
|
|
ddx = (x1-x0)/(Lx-1)
|
|
ddy = (y1-y0)/(Ly-1)
|
|
ddz = (z1-z0)/(Lz-1)
|
|
# LAGRANGE
|
|
plt.axvline(x=10*np.sqrt(ddx**2+ddy**2+ddz**2),
|
|
linewidth=2, color=colors[nm])
|
|
break
|
|
|
|
mesh = Mesh()
|
|
hdf = HDF5File(mesh.mpi_comm(), paths[nm] + meshnames[nm] + '.h5', 'r')
|
|
hdf.read(mesh, '/mesh', False)
|
|
hdf.close()
|
|
|
|
Cells = mesh.cells()
|
|
Points = mesh.coordinates()
|
|
Hi = np.zeros([mesh.num_cells()])
|
|
|
|
inradius_method = False
|
|
circumradius_method = True
|
|
heights_method = False
|
|
|
|
for k in range(mesh.num_cells()):
|
|
|
|
# Coordinates of each cell (A,B,C,D)
|
|
A = Points[Cells[k]][0]
|
|
B = Points[Cells[k]][1]
|
|
C = Points[Cells[k]][2]
|
|
D = Points[Cells[k]][3]
|
|
|
|
if heights_method:
|
|
hs = np.zeros([4])
|
|
for l in range(4):
|
|
if l == 0:
|
|
[P1, P2, P3, P4] = [A, B, C, D]
|
|
if l == 1:
|
|
[P1, P2, P3, P4] = [D, A, B, C]
|
|
if l == 2:
|
|
[P1, P2, P3, P4] = [C, D, A, B]
|
|
if l == 3:
|
|
[P1, P2, P3, P4] = [B, C, D, A]
|
|
|
|
n = np.cross(P2-P1, P3-P1)
|
|
n = n/np.linalg.norm(n)
|
|
d = -np.inner(n, P1)
|
|
hs[l] = np.abs(np.inner(n, P4) + d)
|
|
|
|
h_meas = np.max(hs)
|
|
|
|
if inradius_method:
|
|
Vi = 1/6*np.abs(np.inner(A-D, np.cross(B-D, C-D))) # Volume
|
|
a1 = 0.5*np.linalg.norm(np.cross(B-A, C-A))
|
|
a2 = 0.5*np.linalg.norm(np.cross(B-A, D-A))
|
|
a3 = 0.5*np.linalg.norm(np.cross(C-B, D-B))
|
|
a4 = 0.5*np.linalg.norm(np.cross(C-A, D-A))
|
|
inradius = 3*Vi/(a1+a2+a3+a4)
|
|
h_meas = inradius
|
|
|
|
if circumradius_method:
|
|
# From: 'http://mathworld.wolfram.com/Circumsphere.html'
|
|
Ma = np.zeros([4, 4])
|
|
Mc = np.zeros([4, 4])
|
|
Mx = np.zeros([4, 4])
|
|
My = np.zeros([4, 4])
|
|
Mz = np.zeros([4, 4])
|
|
sa2 = A[0]**2 + A[1]**2 + A[2]**2
|
|
sb2 = B[0]**2 + B[1]**2 + B[2]**2
|
|
sc2 = C[0]**2 + C[1]**2 + C[2]**2
|
|
sd2 = D[0]**2 + D[1]**2 + D[2]**2
|
|
e1 = np.concatenate((A, [1]), axis=0)
|
|
e2 = np.concatenate((B, [1]), axis=0)
|
|
e3 = np.concatenate((C, [1]), axis=0)
|
|
e4 = np.concatenate((D, [1]), axis=0)
|
|
c1 = np.concatenate(([sa2], A), axis=0)
|
|
c2 = np.concatenate(([sb2], B), axis=0)
|
|
c3 = np.concatenate(([sc2], C), axis=0)
|
|
c4 = np.concatenate(([sd2], D), axis=0)
|
|
|
|
mx1 = np.concatenate(([sa2], [A[1]], [A[2]], [1]), axis=0)
|
|
mx2 = np.concatenate(([sb2], [B[1]], [B[2]], [1]), axis=0)
|
|
mx3 = np.concatenate(([sc2], [C[1]], [C[2]], [1]), axis=0)
|
|
mx4 = np.concatenate(([sd2], [D[1]], [D[2]], [1]), axis=0)
|
|
|
|
my1 = np.concatenate(([sa2], [A[0]], [A[2]], [1]), axis=0)
|
|
my2 = np.concatenate(([sb2], [B[0]], [B[2]], [1]), axis=0)
|
|
my3 = np.concatenate(([sc2], [C[0]], [C[2]], [1]), axis=0)
|
|
my4 = np.concatenate(([sd2], [D[0]], [D[2]], [1]), axis=0)
|
|
|
|
mz1 = np.concatenate(([sa2], [A[0]], [A[1]], [1]), axis=0)
|
|
mz2 = np.concatenate(([sb2], [B[0]], [B[1]], [1]), axis=0)
|
|
mz3 = np.concatenate(([sc2], [C[0]], [C[1]], [1]), axis=0)
|
|
mz4 = np.concatenate(([sd2], [D[0]], [D[1]], [1]), axis=0)
|
|
|
|
Ma[0, :] = e1
|
|
Ma[1, :] = e2
|
|
Ma[2, :] = e3
|
|
Ma[3, :] = e4
|
|
Mc[0, :] = c1
|
|
Mc[1, :] = c2
|
|
Mc[2, :] = c3
|
|
Mc[3, :] = c4
|
|
Mx[0, :] = mx1
|
|
Mx[1, :] = mx2
|
|
Mx[2, :] = mx3
|
|
Mx[3, :] = mx4
|
|
My[0, :] = my1
|
|
My[1, :] = my2
|
|
My[2, :] = my3
|
|
My[3, :] = my4
|
|
Mz[0, :] = mz1
|
|
Mz[1, :] = mz2
|
|
Mz[2, :] = mz3
|
|
Mz[3, :] = mz4
|
|
|
|
a = np.linalg.det(Ma)
|
|
c = np.linalg.det(Mc)
|
|
Dx = np.linalg.det(Mx)
|
|
Dy = -np.linalg.det(My)
|
|
Dz = np.linalg.det(Mz)
|
|
|
|
circumradius = np.sqrt(
|
|
Dx**2 + Dy**2 + Dz**2-4*a*c)/(2*np.abs(a))
|
|
h_meas = 2*circumradius
|
|
|
|
# mean of Inradius and Circumraidius in milimiters
|
|
Hi[k] = 10*(h_meas)
|
|
|
|
print('Size of ' + meshnames[nm] + ' :', np.min(Hi), np.max(Hi))
|
|
plt.hist(Hi, bins=60, range=[0, 10], density=True, edgecolor='black',
|
|
color=colors[nm], alpha=alphas[0], label= '$' + meshnames[nm] + '$')
|
|
|
|
ind = ind+1
|
|
|
|
plt.ylim([0,1.3])
|
|
plt.xlabel('$h \ (mm)$',fontsize=18)
|
|
plt.ylabel('$n^o \ of \ elements$',fontsize=18)
|
|
plt.legend(fontsize=16)
|
|
plt.savefig(outpath + 'Histograms.png',dpi=500)
|
|
plt.show()
|
|
|
|
def PlotTest(D0,D1,D2,D3):
|
|
fig = plt.figure(figsize=(10, 6), dpi=100)
|
|
|
|
vvmin = 0
|
|
vvmax = 60
|
|
|
|
|
|
title1 = 'Reference'
|
|
title2 = 'Aliased'
|
|
title3 = 'Dealiased'
|
|
title4 = 'Full sampled'
|
|
ax0 = fig.add_subplot(1,4,1)
|
|
plt.imshow(D0, cmap='magma', interpolation='nearest')
|
|
#plt.imshow(D0, cmap='magma', interpolation='nearest',vmin=vvmin,vmax=vvmax)
|
|
plt.title(title1)
|
|
ax0.set_aspect('auto')
|
|
plt.xticks([])
|
|
plt.yticks([])
|
|
ax1 = fig.add_subplot(1,4,2)
|
|
plt.imshow(D1, cmap='magma', interpolation='nearest')
|
|
#plt.imshow(D1, cmap='magma', interpolation='nearest',vmin=vvmin,vmax=vvmax)
|
|
plt.title(title2)
|
|
ax1.set_aspect('auto')
|
|
plt.xticks([])
|
|
plt.yticks([])
|
|
ax2 = fig.add_subplot(1,4,3)
|
|
plt.imshow(D2, cmap='magma', interpolation='nearest')
|
|
#plt.imshow(D2, cmap='magma', interpolation='nearest',vmin=vvmin,vmax=vvmax)
|
|
plt.title(title3)
|
|
ax2.set_aspect('auto')
|
|
plt.xticks([])
|
|
plt.yticks([])
|
|
ax3 = fig.add_subplot(1,4,4)
|
|
plt.imshow(D3, cmap='magma', interpolation='nearest')
|
|
#plt.imshow(D3, cmap='magma', interpolation='nearest',vmin=vvmin,vmax=vvmax)
|
|
plt.title(title4)
|
|
ax3.set_aspect('auto')
|
|
plt.xticks([])
|
|
plt.yticks([])
|
|
plt.show()
|
|
|
|
def TakePhoto(M1,scale_mode='auto'):
|
|
|
|
fig = plt.figure(figsize=(10, 6), dpi=100)
|
|
|
|
title1 = '$M(x_0,y,f)$'
|
|
|
|
if scale_mode=='auto':
|
|
plt.imshow(M1, cmap='viridis', interpolation='nearest')
|
|
else:
|
|
plt.imshow(M1, cmap='viridis', interpolation='nearest',vmin=scale_mode[0],vmax=scale_mode[1])
|
|
|
|
#plt.axes().set_aspect('auto')
|
|
#plt.tight_layout()
|
|
#plt.title(title1,fontsize=20)
|
|
plt.xticks([])
|
|
plt.yticks([])
|
|
#plt.xlabel('$f$',fontsize=20)
|
|
#plt.ylabel('$y$',fontsize=20)
|
|
|
|
|
|
plt.show()
|
|
|
|
def PrintSequence(A,scale_mode='auto',window=0,repeat=0,recorder=False):
|
|
|
|
plt.ion()
|
|
fig = plt.figure(figsize=(8, 6), dpi=100)
|
|
ax = fig.add_subplot(1,1,1)
|
|
[row,col,numt2] = A.shape
|
|
maxA = np.max(A)
|
|
minA = np.min(A)
|
|
|
|
|
|
from matplotlib.colors import LinearSegmentedColormap
|
|
basic_cols = ['#ff4e2b', '#000000', '#1893db']
|
|
my_cmap = LinearSegmentedColormap.from_list('mycmap', basic_cols)
|
|
|
|
if window==1:
|
|
ywin = [row*0.50+10,row*0.50-12]
|
|
xwin = [col*0.5-12,col*0.5+11]
|
|
|
|
if window==4:
|
|
ywin = [190,140]
|
|
xwin = [35,90]
|
|
|
|
|
|
|
|
for rp in range(-1,repeat):
|
|
for k in range(numt2):
|
|
|
|
|
|
if scale_mode=='auto':
|
|
plt.imshow(A[:,:,k],cmap='magma', interpolation='nearest',vmin=minA,vmax=maxA*1.1)
|
|
if scale_mode=='none':
|
|
plt.imshow(A[:,:,k],cmap='magma', interpolation='nearest')
|
|
#elif scale_mode.shape==1:
|
|
# plt.imshow(A[:,:,k],cmap=my_cmap, interpolation='nearest',vmin=scale_mode[0],vmax=scale_mode[1])
|
|
|
|
if window>0:
|
|
plt.ylim(ywin)
|
|
plt.xlim(xwin)
|
|
ax.set_aspect('auto')
|
|
|
|
plt.xticks([])
|
|
plt.yticks([])
|
|
#plt.xlabel('$x$',Fontsize=20)
|
|
#plt.ylabel('$y$',Fontsize=20)
|
|
plt.title('phase ' + str(k))
|
|
plt.show()
|
|
|
|
if recorder:
|
|
plt.savefig('results/pictures/frame'+str(k),bbox_inches='tight')
|
|
|
|
plt.pause(0.101)
|
|
plt.clf()
|
|
|
|
def PrintSequence2(A,X,Y,Z,x,y,z):
|
|
|
|
plt.ion()
|
|
fig = plt.figure(figsize=(7, 7), dpi=100)
|
|
ax = fig.add_subplot(1,1,1)
|
|
[row,col,dep] = A.shape
|
|
|
|
|
|
xi = np.linspace(np.min(x),np.max(x),row)
|
|
yi = np.linspace(np.min(y),np.max(y),col)
|
|
yi2 = np.min(yi) + np.max(yi) - yi
|
|
|
|
from matplotlib.colors import LinearSegmentedColormap
|
|
basic_cols = ['#ff4e2b', '#000000', '#1893db']
|
|
my_cmap = LinearSegmentedColormap.from_list('mycmap', basic_cols)
|
|
ccmap = mpl.cm.Spectral
|
|
|
|
xt = x
|
|
yt = y
|
|
zt = z
|
|
yt2 = (np.min(y) + np.max(y)) - y
|
|
Dz = (np.max(z) - np.min(z))/dep
|
|
|
|
def shiftedColorMap(cmap, start=0, midpoint=0.5, stop=1.0, name='shifted'):
|
|
'''
|
|
Function to offset the "center" of a colormap. Useful for
|
|
data with a negative min and positive max and you want the
|
|
middle of the colormap's dynamic range to be at zero.
|
|
|
|
Input
|
|
-----
|
|
cmap : The matplotlib colormap to be altered
|
|
start : Offset from lowest point in the colormap's range.
|
|
Defaults to 0.0 (no lower offset). Should be between
|
|
0.0 and `midpoint`.
|
|
midpoint : The new center of the colormap. Defaults to
|
|
0.5 (no shift). Should be between 0.0 and 1.0. In
|
|
general, this should be 1 - vmax / (vmax + abs(vmin))
|
|
For example if your data range from -15.0 to +5.0 and
|
|
you want the center of the colormap at 0.0, `midpoint`
|
|
should be set to 1 - 5/(5 + 15)) or 0.75
|
|
stop : Offset from highest point in the colormap's range.
|
|
Defaults to 1.0 (no upper offset). Should be between
|
|
`midpoint` and 1.0.
|
|
'''
|
|
|
|
cdict = {
|
|
'red': [],
|
|
'green': [],
|
|
'blue': [],
|
|
'alpha': []
|
|
}
|
|
|
|
# regular index to compute the colors
|
|
reg_index = np.linspace(start, stop, 257)
|
|
|
|
# shifted index to match the data
|
|
shift_index = np.hstack([
|
|
np.linspace(0.0, midpoint, 128, endpoint=False),
|
|
np.linspace(midpoint, 1.0, 129, endpoint=True)
|
|
])
|
|
|
|
for ri, si in zip(reg_index, shift_index):
|
|
r, g, b, a = cmap(ri)
|
|
|
|
cdict['red'].append((si, r, r))
|
|
cdict['green'].append((si, g, g))
|
|
cdict['blue'].append((si, b, b))
|
|
cdict['alpha'].append((si, a, a))
|
|
|
|
newcmap = mpl.colors.LinearSegmentedColormap(name, cdict)
|
|
plt.register_cmap(cmap=newcmap)
|
|
|
|
return newcmap
|
|
|
|
ccmap = mpl.cm.Spectral
|
|
shifted_ccmap = shiftedColorMap(ccmap, midpoint=0.75, name='shifted')
|
|
|
|
for k in range(dep):
|
|
|
|
zmin = np.min(z) + k*Dz
|
|
zmax = zmin + Dz
|
|
xs = np.array([])
|
|
ys = np.array([])
|
|
zs = np.array([])
|
|
|
|
for j in range(z.size):
|
|
if z[j]>= zmin and z[j]<zmax:
|
|
xs = np.concatenate((xs,[xt[j]]))
|
|
ys = np.concatenate((ys,[yt[j]]))
|
|
zs = np.concatenate((zs,[zt[j]]))
|
|
|
|
|
|
|
|
[xs2,ys2] = ToolsF.getpixel(xs,ys,xi,yi)
|
|
|
|
Afil = ToolsF.FilterWithPoints(A[:,:,k],X,Y,Z,xs,ys,xi,yi,k,0.1)
|
|
|
|
|
|
plt.plot(xi[xs2],yi2[ys2],'.w')
|
|
plt.imshow(Afil,cmap=my_cmap, extent=(np.min(xt),np.max(xt),np.min(yt),np.max(yt)),interpolation='nearest',vmin=-80,vmax=80)
|
|
plt.xticks([])
|
|
plt.yticks([])
|
|
plt.title('phase ' + str(k))
|
|
plt.show()
|
|
plt.pause(0.101)
|
|
plt.clf()
|
|
|
|
def ComparePoint(A,B,norma,center):
|
|
|
|
Anorm = A
|
|
Bnorm = B
|
|
|
|
if norma==1:
|
|
Anorm = np.abs(A)*100/np.amax(A)
|
|
Bnorm = np.abs(B)*100/np.amax(B)
|
|
|
|
|
|
|
|
fig = plt.figure()
|
|
[row,col,numt2] = A.shape
|
|
tvec = np.linspace(0,numt2,numt2)
|
|
CA = np.zeros(tvec.shape)
|
|
CB = np.zeros(tvec.shape)
|
|
|
|
|
|
if center==2:
|
|
yc = int(col*0.5)
|
|
xc = int(row*0.5)
|
|
if center==1:
|
|
yc = int((col-1)*0.5)
|
|
xc = int((row-1)*0.4)
|
|
if center==0:
|
|
yc = 76
|
|
xc = 162
|
|
|
|
|
|
for k in range(numt2):
|
|
CA[k] = Anorm[xc,yc,k]
|
|
CB[k] = Bnorm[xc,yc,k]
|
|
|
|
|
|
plt.plot(tvec,CA,'-r',label='$Rec$')
|
|
plt.plot(tvec,CB,'-b',label='$Orig$')
|
|
plt.xlabel('$time \ \ frame$',fontsize=20)
|
|
plt.ylabel('$ velocity $',fontsize=20)
|
|
plt.legend(fontsize=15)
|
|
plt.show()
|
|
|
|
def CenterComparison(A,B,C,R,center):
|
|
|
|
|
|
title1 = '$Orig$'
|
|
title2 = '$KTB-$'+ str(R)
|
|
title3 = '$CS-$' + str(R)
|
|
|
|
fig = plt.figure()
|
|
[row,col,numt2] = A.shape
|
|
tvec = np.linspace(0,numt2,numt2)
|
|
CA = np.zeros(tvec.shape)
|
|
CB = np.zeros(tvec.shape)
|
|
CC = np.zeros(tvec.shape)
|
|
|
|
if center==2:
|
|
yc = int(col*0.5)
|
|
xc = int(row*0.5)
|
|
if center==1:
|
|
yc = int((col-1)*0.5)
|
|
xc = int((row-1)*0.4)
|
|
if center==0:
|
|
yc = 76
|
|
xc = 162
|
|
|
|
|
|
for k in range(numt2):
|
|
CA[k] = A[xc,yc,k]
|
|
CB[k] = B[xc,yc,k]
|
|
CC[k] = C[xc,yc,k]
|
|
|
|
plt.plot(tvec,CA,'-k',label=title1)
|
|
plt.plot(tvec,CB,'-b',label=title2)
|
|
plt.plot(tvec,CC,'-r',label=title3)
|
|
plt.xlabel('$time \ \ frame$',fontsize=20)
|
|
plt.ylabel('$ velocity $',fontsize=20)
|
|
plt.legend(fontsize=12)
|
|
plt.show()
|
|
|
|
def VelocityChannel(M,repeat,recorder):
|
|
[row,col,numt2] = M.shape
|
|
|
|
|
|
[X,Y] = np.meshgrid(np.linspace(0,col,col),np.linspace(0,row,row))
|
|
|
|
plt.ion()
|
|
|
|
rown = row*6/row
|
|
coln = col*6/row
|
|
|
|
fig = plt.figure()#figsize=(4, 6) , dpi=200)
|
|
ax = fig.add_subplot(111, projection='3d')
|
|
|
|
|
|
for rr in range(-1,repeat):
|
|
|
|
for t in range(numt2):
|
|
|
|
V = M[:,:,t]
|
|
|
|
#ax.plot_surface(X, Y, V, cmap=plt.cm.magma, vmin=-30, vmax=50, linewidth=0, antialiased=False)
|
|
#ax.plot_wireframe(X, Y, V,rcount=20,ccount=20,linewidth=0.5)
|
|
ax.plot_surface(X, Y, V,cmap='magma',vmin=-30, vmax=100, linewidth=0, antialiased=False)
|
|
|
|
ax.set_zlim(-120, 150)
|
|
#ax.set_xlim( 40, 80)
|
|
#ax.set_ylim( 100, 180)
|
|
ax.set_xlabel('$x$')
|
|
ax.set_ylabel('$y$')
|
|
ax.set_zlabel('$v(r)$')
|
|
|
|
ax.set_title('phase ' + str(t))
|
|
plt.pause(0.001)
|
|
plt.draw()
|
|
|
|
if recorder==1:
|
|
plt.savefig('Pictures/frame'+str(t))
|
|
|
|
if t<numt2-1:
|
|
plt.cla()
|
|
|
|
def PlotTri(tri,pos,p):
|
|
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1, projection='3d')
|
|
#ax.plot_trisurf(pos[:,0], pos[:,1], pos[:,2], triangles=tri.simplices, cmap=plt.cm.Spectral,linewidth=0.1,edgecolors='k')
|
|
#ax.tripcolor(pos[:,0], pos[:,1], pos[:,2], triangles=tri.simplices, facecolors=p2.T, edgecolor='black')
|
|
plt.show()
|
|
|
|
def PlotPressureDrop(mode):
|
|
|
|
barye2mmHg = 1/1333.22387415
|
|
|
|
CT = np.loadtxt('Pressure/DROPS/pd_NS_coarse.txt')
|
|
CT2 = np.loadtxt('Pressure/DROPS/pd_NS_coarse2.txt')
|
|
|
|
ref_ao = np.loadtxt('Pressure/DROPS2/refPPE1_coarse.txt')
|
|
ref = np.loadtxt('Pressure/DROPS2/refPPE1_coarse_leo1.txt')
|
|
CS2 = np.loadtxt('Pressure/DROPS2/CSPPE2_coarse_leo1.txt')
|
|
|
|
|
|
PPE_CT = np.loadtxt('Pressure/DROPS/pd_PPE_NS_coarse.txt')
|
|
PPE_CT_leo = np.loadtxt('Pressure/DROPS/pd_PPE_NS_coarse_leo1.txt')
|
|
|
|
|
|
STE_CT = np.loadtxt('Pressure/DROPS/test_STE_R1_coarse.txt')
|
|
test_STE_CT = np.loadtxt('Pressure/DROPS/test2_STE_R1_coarse_leo1.txt')
|
|
|
|
STEint_CT = np.loadtxt('Pressure/DROPS/test_STEint_R1_coarse.txt')
|
|
test_STEint_CT = np.loadtxt('Pressure/DROPS/test2_STEint_R1_coarse_leo1.txt')
|
|
|
|
|
|
# UNDERSAMPLING
|
|
PPE_R1_leo1 = np.loadtxt('Pressure/DROPS/test_PPE_R1_coarse_leo1.txt')
|
|
|
|
PPE_KT_R2_leo1 = np.loadtxt('Pressure/DROPS/KT_PPE_R2_coarse_leo1.txt')
|
|
PPE_KT_R4_leo1 = np.loadtxt('Pressure/DROPS/KT_PPE_R4_coarse_leo1.txt')
|
|
PPE_KT_R8_leo1 = np.loadtxt('Pressure/DROPS/KT_PPE_R8_coarse_leo1.txt')
|
|
PPE_KT_R12_leo1 = np.loadtxt('Pressure/DROPS/KT_PPE_R12_coarse_leo1.txt')
|
|
PPE_KT_R20_leo1 = np.loadtxt('Pressure/DROPS/KT_PPE_R20_coarse_leo1.txt')
|
|
|
|
PPE_CS_R2_leo1 = np.loadtxt('Pressure/DROPS/CS_PPE_R2_coarse_leo1.txt')
|
|
PPE_CS_R4_leo1 = np.loadtxt('Pressure/DROPS/CS_PPE_R4_coarse_leo1.txt')
|
|
PPE_CS_R8_leo1 = np.loadtxt('Pressure/DROPS/CS_PPE_R8_coarse_leo1.txt')
|
|
PPE_CS_R12_leo1 = np.loadtxt('Pressure/DROPS/CS_PPE_R12_coarse_leo1.txt')
|
|
PPE_CS_R20_leo1 = np.loadtxt('Pressure/DROPS/CS_PPE_R20_coarse_leo1.txt')
|
|
|
|
#CT_fine = np.loadtxt('Pressure/DROPS/pd_NS_fine.txt')
|
|
#CT_fine_T = np.loadtxt('Pressure/DROPS/pd_NS_fine_T.txt')
|
|
#PPE_CT_fine = np.loadtxt('Pressure/DROPS/pd_PPE_NS_fine.txt')
|
|
#PPE_CT_fine_leo3 = np.loadtxt('Pressure/DROPS/pd_PPE_NS_fine_leo3.txt')
|
|
|
|
|
|
tvec2 = np.linspace(0, 2.5 ,PPE_CT_leo.size)
|
|
tvec = np.linspace(tvec2[1]*0.5 ,2.5+tvec2[1]*0.5 , CT.size)
|
|
#tvec_T = np.linspace(0,2.5,CT_fine_T.size)
|
|
|
|
fig = plt.figure()
|
|
|
|
if mode=='KT':
|
|
plt.plot(tvec,CT,'-k',linewidth=2,label='$ref$')
|
|
plt.plot(tvec2,PPE_R1_leo1,'xkcd:red',linewidth=2,linestyle='-' , label='$R = 1$')
|
|
plt.plot(tvec2,PPE_KT_R2_leo1,'xkcd:blue',linewidth=2,linestyle='-' ,label='$R = 2$')
|
|
plt.plot(tvec2,PPE_KT_R4_leo1,'xkcd:green',linewidth=2,linestyle='-',label='$R = 4$')
|
|
plt.plot(tvec2,PPE_KT_R8_leo1,'xkcd:orange',linewidth=2,linestyle='-',label='$R = 8$')
|
|
plt.plot(tvec2,PPE_KT_R20_leo1,'xkcd:magenta',linewidth=2,linestyle='-', label='$R = 20$')
|
|
plt.title('$kt-BLAST$',fontsize=20)
|
|
|
|
if mode=='CS':
|
|
plt.plot(tvec,CT,'-k',linewidth=2,label='$ref$')
|
|
plt.plot(tvec2,ref_ao,'xkcd:red',linewidth=2,linestyle='--' , label='$aorta$')
|
|
plt.plot(tvec2,ref,'xkcd:red',linewidth=2,linestyle='-' , label='$leo$')
|
|
plt.plot(tvec2,CS2,'xkcd:blue',linewidth=2,linestyle='-' ,label='$R = 2$')
|
|
|
|
#plt.plot(tvec2,PPE_R1_leo1,'xkcd:red',linewidth=2,linestyle='-' , label='$R = 1$')
|
|
#plt.plot(tvec2,PPE_CS_R2_leo1,'xkcd:blue',linewidth=2,linestyle='-' ,label='$R = 2$')
|
|
#plt.plot(tvec2,PPE_CS_R4_leo1,'xkcd:green',linewidth=2,linestyle='-',label='$R = 4$')
|
|
#plt.plot(tvec2,PPE_CS_R8_leo1,'xkcd:orange',linewidth=2,linestyle='-',label='$R = 8$')
|
|
#plt.plot(tvec2,PPE_CS_R20_leo1,'xkcd:magenta',linewidth=2,linestyle='-', label='$R = 20$')
|
|
plt.title('$Compressed \ \ Sensing$',fontsize=20)
|
|
|
|
|
|
|
|
if mode=='STE':
|
|
plt.plot(tvec,CT,'-k',linewidth=2,label='$ref$')
|
|
plt.plot(tvec2,STE_CT , 'xkcd:purple' , label='STE-CT aorta')
|
|
plt.plot(tvec2,test_STE_CT , 'xkcd:purple' , linestyle='--', marker='o', label='STE-CT leo')
|
|
|
|
|
|
if mode=='STEint':
|
|
plt.plot(tvec,CT,'-k',linewidth=2,label='$ref$')
|
|
plt.plot(tvec2,STEint_CT, 'xkcd:aquamarine', label='STEint-CT aorta')
|
|
plt.plot(tvec2,test_STEint_CT, 'xkcd:aquamarine', linestyle='--', marker='o',label='STEint-CT aorta')
|
|
|
|
|
|
plt.ylim([-2,7])
|
|
plt.xlabel(r'$time \ \ \ (s)$',fontsize=20)
|
|
plt.ylabel(r'$\delta p \ \ \ (mmHg) $',fontsize=20)
|
|
plt.legend(fontsize=16)
|
|
##############################################################################################################################
|
|
|
|
|
|
#fig = plt.figure()
|
|
#plt.plot(tvec2,CT_fine,'-ok',label='CT')
|
|
##plt.plot(tvec_T,CT_fine_T,'--k',label='CT T')
|
|
#plt.plot(tvec2 ,PPE_CT_fine ,'-om',label='PPE-CT aorta')
|
|
#plt.plot(tvec2 ,PPE_CT_fine_leo3,'-oc',label='PPE-CT leo3')
|
|
#plt.title('aorta fine')
|
|
#plt.xlabel(r'$time \ \ (s) $',fontsize=20)
|
|
#plt.ylabel(r'$\delta p \ \ \ (mmHg) $',fontsize=20)
|
|
#plt.legend(fontsize=14)
|
|
|
|
|
|
|
|
|
|
|
|
plt.show()
|
|
|
|
def Plot_flux(masterpath,meshpath,options,mode,R):
|
|
|
|
mesh = Mesh()
|
|
hdf1 = HDF5File(mesh.mpi_comm(), meshpath , 'r')
|
|
hdf1.read(mesh, '/mesh', False)
|
|
boundaries = MeshFunction('size_t', mesh , mesh.topology().dim() - 1)
|
|
hdf1.read(boundaries, '/boundaries')
|
|
|
|
Evel = VectorElement('Lagrange',mesh.ufl_cell(),1)
|
|
V = FunctionSpace(mesh,Evel)
|
|
n = FacetNormal(mesh)
|
|
|
|
MESH = {}
|
|
MESH['mesh'] = mesh
|
|
MESH['FEM'] = V
|
|
|
|
|
|
t = float(dt)
|
|
ds = Measure("ds", subdomain_data=boundaries)
|
|
QQ = {}
|
|
veli = {}
|
|
|
|
machine = __import__('4Dflow')
|
|
|
|
checkpoint_path = masterpath + 'R1/checkpoint/'
|
|
veli[1] = machine.READcheckpoint(MESH,'v',1,checkpoint_path,'u')
|
|
|
|
for r in R:
|
|
check_path = masterpath + 'R'+str(r)+'/checkpoint/'
|
|
veli[r] = machine.READcheckpoint(MESH,'v',1,check_path,'u')
|
|
|
|
print('velocities imported')
|
|
|
|
NT = len(veli[1])
|
|
|
|
QQ[1] = np.zeros([NT])
|
|
for k in R:
|
|
QQ[k] = np.zeros([NT])
|
|
|
|
u = Function(V)
|
|
|
|
|
|
ind = 0
|
|
while ind<NT:
|
|
u.assign(veli[1][ind])
|
|
QQ[1][ind] = assemble(dot(u,n)*ds(2))
|
|
ind = ind + 1
|
|
|
|
|
|
for r in R:
|
|
ind = 0
|
|
while ind<NT:
|
|
u.assign(veli[r][ind])
|
|
QQ[r][ind] = assemble(dot(u,n)*ds(2))
|
|
ind = ind + 1
|
|
|
|
|
|
if mode=='pdrop_black2':
|
|
linesize = 4
|
|
dotsize = 5
|
|
plt.style.use('dark_background')
|
|
fig, ax = plt.subplots( figsize=(8, 5), dpi=100)
|
|
ax.axis('off')
|
|
ref = -QQ[1]
|
|
|
|
tvec = np.linspace(1,NT,NT)
|
|
#ax.set_ylim([-np.max(ref)*0.4,np.max(ref)*1.2])
|
|
tend = NT
|
|
|
|
ax.plot(tvec[0:tend],ref[0:tend],'white',linewidth=linesize,linestyle='-',label='$ref$')
|
|
for r in R:
|
|
ax.plot(tvec[0:tend],-QQ[r][0:tend],linewidth=linesize,linestyle='-',marker='o',markersize=dotsize)
|
|
|
|
if options['save_flux']:
|
|
fig.savefig(options['save_path']+options['name'], bbox_inches='tight',dpi=500)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
plt.show()
|
|
|
|
def Plot_dP(masterpath,options,mode,R):
|
|
|
|
import pickle
|
|
######################################################################
|
|
barye2mmHg = 1/1333.22387415
|
|
Dt = 0.03072
|
|
|
|
if options['dP']['mode'] == 'cib':
|
|
barye2mmHg = -0.00750062
|
|
elif options['dP']['mode'] == 'ct':
|
|
ref = np.loadtxt(masterpath + 'ref.txt')
|
|
t = np.linspace(0, Tf, ref.size)
|
|
tm = np.linspace(0.5*t[0]+0.5*t[1], 0.5 *
|
|
t[t.size-2]+0.5*t[t.size-1], ref.size)
|
|
tm = t
|
|
tend = ref.size
|
|
|
|
for estim in options['dP']['estim']:
|
|
if estim == 'PPE':
|
|
ppe_ref = open(masterpath+'pdrop_PPE_impl_stan.dat', 'rb')
|
|
ppe_ref = pickle.load(ppe_ref)['pdrop']*(barye2mmHg)
|
|
tend = ppe_ref.size
|
|
t = np.linspace(0, tend*Dt, ppe_ref.size)
|
|
tm = np.linspace(0.5*t[0]+0.5*t[1], 0.5 *
|
|
t[t.size-2]+0.5*t[t.size-1], ppe_ref.size)
|
|
tm_ppe = t
|
|
if estim == 'STE':
|
|
ste_ref = open(masterpath+'pdrop_STE_impl_stan.dat', 'rb')
|
|
ste_ref = pickle.load(ste_ref)['pdrop']*(barye2mmHg)
|
|
tm_ste = np.linspace(0, ste_ref.size*Dt, ste_ref.size)
|
|
if estim == 'DAE':
|
|
dae_ref = open(masterpath+'pdrop_DAE_impl_stan.dat', 'rb')
|
|
dae_ref = pickle.load(dae_ref)['pdrop']*(barye2mmHg)
|
|
if estim == 'COR':
|
|
cor_ref = open(masterpath+'pdrop_COR_impl_stan.dat', 'rb')
|
|
cor_ref = pickle.load(cor_ref)['pdrop']*(barye2mmHg)
|
|
tm_cor = np.linspace(0, cor_ref.size*Dt, cor_ref.size)
|
|
|
|
|
|
######################################################################
|
|
|
|
if mode=='pdrop':
|
|
#plt.style.use('dark_background')
|
|
fig, ax = plt.subplots( figsize=(8, 5), dpi=100)
|
|
linesize = 3
|
|
dotsize = 6
|
|
|
|
if options['dP']['mode']=='cib':
|
|
|
|
if not options['dP']['catheter']=='None':
|
|
tend = ppe_ref.size
|
|
Dt = 0.019
|
|
if 'GM' in masterpath:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/Patients/Study_14_GM/catheter/catheter_stats.csv'
|
|
shift_t = 0
|
|
Dt = 0.03831417624521074
|
|
cstar = [0,0]
|
|
if 'RT' in masterpath:
|
|
if '/mnt/D/jeremias' in masterpath:
|
|
c_path = '/mnt/D/jeremias/Study_David/Patients/Study_12_RT/catheter/catheter_stats.csv'
|
|
else:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/Patients/Study_12_RT/catheter/catheter_stats.csv'
|
|
shift_t = 0.037
|
|
Dt = 0.025817555938037858
|
|
cstar = [0,0]
|
|
if '9' in masterpath and 'Rest' in masterpath:
|
|
if '/mnt/D/jeremias' in masterpath:
|
|
c_path = '/mnt/D/jeremias/MEDICAL_DATA/Study_David/catheter_data/catheter_9mm_rest_stats.csv'
|
|
else:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/catheter_data/catheter_9mm_rest_stats.csv'
|
|
shift_t = -0.10
|
|
cstar = [8,0]
|
|
|
|
if '11' in masterpath and 'Rest' in masterpath:
|
|
if '/mnt/D/jeremias' in masterpath:
|
|
c_path = '/mnt/D/jeremias/MEDICAL_DATA/Study_David/catheter_data/catheter_11mm_rest_stats.csv'
|
|
else:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/catheter_data/catheter_11mm_rest_stats.csv'
|
|
shift_t = 0.05
|
|
cstar = [0,0]
|
|
|
|
|
|
if '13' in masterpath and 'Rest' in masterpath:
|
|
if '/mnt/D/jeremias' in masterpath:
|
|
c_path = '/mnt/D/jeremias/MEDICAL_DATA/Study_David/catheter_data/catheter_13mm_rest_stats.csv'
|
|
else:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/catheter_data/catheter_13mm_rest_stats.csv'
|
|
shift_t = 0.09
|
|
cstar = [0,0]
|
|
|
|
|
|
if 'Normal' in masterpath and 'Rest' in masterpath:
|
|
if '/mnt/D/jeremias' in masterpath:
|
|
c_path = '/mnt/D/jeremias/MEDICAL_DATA/Study_David/catheter_data/catheter_normal_rest_stats.csv'
|
|
else:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/catheter_data/catheter_normal_rest_stats.csv'
|
|
shift_t = 0
|
|
cstar = [0,0]
|
|
|
|
|
|
with open(c_path, 'r') as csvfile:
|
|
mylist = [row[0] for row in csv.reader(csvfile, delimiter=';')]
|
|
|
|
Values = np.array(mylist)
|
|
catheter = np.zeros([len(Values)-2])
|
|
tcat = np.zeros([len(Values)-2])
|
|
for l in range(2,len(Values)):
|
|
row = Values[l].split(',')
|
|
catheter[l-2] = float(row[5])
|
|
tcat[l-2] = float(row[0])
|
|
|
|
tcat = tcat+shift_t
|
|
ax.plot(tcat[cstar[0]:tcat.size-cstar[1]],catheter[cstar[0]:tcat.size-cstar[1]],'black',linewidth=linesize,linestyle='--',label='$catheter$')
|
|
ax.set_xlim([-0.05,0.81])
|
|
ax.set_ylim([np.min(catheter)-np.mean(catheter) ,np.max(catheter)*1.2])
|
|
|
|
elif options['dP']['mode']=='ct':
|
|
ax.plot(tm[0:tend],ref[0:tend],options['REFcol'],linewidth=linesize,linestyle='-',marker='o',label='$ref$')
|
|
|
|
else:
|
|
if 'catheter' in options['dP']:
|
|
if not options['dP']['catheter']=='None':
|
|
CAT = np.load(options['dP']['catheter'])
|
|
[x0,x1,a,b,alpha] = options['dP']['factors']
|
|
t_cat = CAT['t']
|
|
dp_cat = CAT['dp']
|
|
ind1 = x0
|
|
ind2 = dp_cat.size-x1
|
|
t_cat = t_cat[ind1:ind2]
|
|
dp_cat = dp_cat[ind1:ind2]
|
|
t_cat2 = t_cat*a
|
|
t_cat2 = t_cat2*np.cos(alpha*np.pi/180) + dp_cat*np.sin(alpha*np.pi/180)
|
|
dp_cat2 = dp_cat*np.cos(alpha*np.pi/180) - t_cat2*np.sin(alpha*np.pi/180)
|
|
t_cat2 = t_cat2 - t_cat2[0]+ b
|
|
ax.plot(t_cat2,dp_cat2,'black',linewidth=linesize,linestyle='-',marker='o',label='$cat$')
|
|
|
|
|
|
|
|
for r in R:
|
|
for estim in options['dP']['estim']:
|
|
if r==1:
|
|
if estim=='PPE':
|
|
ax.plot(tm_ppe[0:tend],ppe_ref[0:tend],options['ppecol'],linewidth=linesize,linestyle='-',marker='o',label='$ppe: R=1$')
|
|
if estim=='STE':
|
|
ax.plot(tm_ste[0:tend],ste_ref[0:tend],options['stecol'],linewidth=linesize,linestyle='-',marker='o',label='$ste: R=1$')
|
|
if estim=='COR':
|
|
ax.plot(tm_cor[0:tend],cor_ref[0:tend],options['corcol'],linewidth=linesize,linestyle='-',marker='o',label='$cor: R=1$')
|
|
|
|
|
|
else:
|
|
press_raw = open(masterpath+'R'+str(r)+'/pdrop_'+estim+'_impl_stan.dat','rb')
|
|
press = pickle.load(press_raw)['pdrop']*(-barye2mmHg)
|
|
tvec = np.linspace(0,Tf,press.size)
|
|
ax.plot(tvec[1:-1],press[1:-1],options[estim+'col'],linewidth=2,linestyle='-',marker='o',label='$ppe$')
|
|
|
|
|
|
|
|
plt.xlabel(r'$time \ \ \ (s)$',fontsize=20)
|
|
plt.ylabel(r'$ \Delta p \ \ \ (mmHg) $',fontsize=20)
|
|
plt.legend(fontsize=14)
|
|
if options['dP']['save']:
|
|
fig.savefig(options['dP']['name'], bbox_inches='tight',dpi=500)
|
|
|
|
if mode=='error':
|
|
|
|
plt.figure(figsize=(10, 6), dpi=100)
|
|
|
|
ppe = {}
|
|
ste = {}
|
|
tvec = {}
|
|
eps_ppe = np.zeros([len(R)])
|
|
eps_ste = np.zeros([len(R)])
|
|
std_ppe = np.zeros([len(R)])
|
|
std_ste = np.zeros([len(R)])
|
|
k = 0
|
|
|
|
ref2 = ref[1:ref.size]
|
|
|
|
for r in R:
|
|
ppe_raw = open(masterpath+'/R'+str(r)+'/pdrop_PPE_impl_stan.dat','rb')
|
|
ste_raw = open(masterpath+'/R'+str(r)+'/pdrop_STE_impl_stan.dat','rb')
|
|
ppe[r] = pickle.load(ppe_raw)['pdrop']*(-barye2mmHg)
|
|
ste[r] = pickle.load(ste_raw)['pdrop']*(-barye2mmHg)
|
|
tvec[r] = np.linspace(0,Tf,ppe[r].size)
|
|
|
|
if r==0 and mesh_size=='coarse':
|
|
dif_ppe = np.abs(ref2-ppe[r])
|
|
dif_ste = np.abs(ref2-ste[r])
|
|
else:
|
|
dif_ppe = np.abs(ref-ppe[r])
|
|
dif_ste = np.abs(ref-ste[r])
|
|
|
|
#eps_ppe[k] = np.sqrt(1/ref.size)*np.sqrt( np.sum(dif_ppe**2) )
|
|
#eps_ste[k] = np.sqrt(1/ref.size)*np.sqrt( np.sum(dif_ste**2) )
|
|
|
|
eps_ppe[k] = np.mean(dif_ppe)
|
|
eps_ste[k] = np.mean(dif_ste)
|
|
std_ppe[k] = np.std(dif_ppe)
|
|
std_ste[k] = np.std(dif_ste)
|
|
k += 1
|
|
|
|
plt.errorbar(R,eps_ppe, yerr=std_ppe, ecolor=options['ppecol'] ,color=options['ppecol'] , uplims=True, lolims=True,marker='o',label='$PPE$')
|
|
plt.errorbar(R,eps_ste, yerr=std_ste, ecolor=options['stecol'] ,color=options['stecol'] ,uplims=True, lolims=True, marker='o',label='$STE$')
|
|
plt.xlabel(r'$R$',fontsize=20)
|
|
plt.ylabel(r'$ \overline{\delta P(R)- \delta P_{ref}} \ \ mmHg$',fontsize=18)
|
|
plt.legend(fontsize=14)
|
|
plt.title( '$ size : ' + mesh_size + ' \ \ dt = ' + str(1000*dt) + ' \ ms $',fontsize=16)
|
|
plt.xlim([-2,25])
|
|
plt.ylim([-3,7])
|
|
|
|
if 'pdrop_black' in mode:
|
|
|
|
plt.style.use('dark_background')
|
|
fig, ax = plt.subplots( figsize=(8, 5), dpi=100)
|
|
linesize = 3
|
|
dotsize = 6
|
|
if 'all' in mode:
|
|
ax.axis('off')
|
|
|
|
|
|
if options['dP']['mode']=='cib':
|
|
#ax.set_ylim([np.min(ref),np.max(ref)])
|
|
#ax.set_ylim([111,112])
|
|
tend = ref.size
|
|
Dt = 0.019
|
|
|
|
|
|
if 'GM' in masterpath:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/Patients/Study_14_GM/catheter/catheter_stats.csv'
|
|
shift_t = 0
|
|
Dt = 0.03831417624521074
|
|
cstar = [0,0]
|
|
if 'RT' in masterpath:
|
|
if '/mnt/D/jeremias' in masterpath:
|
|
c_path = '/mnt/D/jeremias/Study_David/Patients/Study_12_RT/catheter/catheter_stats.csv'
|
|
else:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/Patients/Study_12_RT/catheter/catheter_stats.csv'
|
|
shift_t = 0.037
|
|
Dt = 0.025817555938037858
|
|
cstar = [0,0]
|
|
if '9' in masterpath and 'Rest' in masterpath:
|
|
if '/mnt/D/jeremias' in masterpath:
|
|
c_path = '/mnt/D/jeremias/Study_David/catheter_data/catheter_9mm_rest_stats.csv'
|
|
else:
|
|
c_path = '/home/yeye/Desktop/PhD/MEDICAL_DATA/Study_David/catheter_data/catheter_9mm_rest_stats.csv'
|
|
shift_t = -0.10
|
|
Dt = 0.03072
|
|
cstar = [8,0]
|
|
|
|
|
|
|
|
with open(c_path, 'r') as csvfile:
|
|
mylist = [row[0] for row in csv.reader(csvfile, delimiter=';')]
|
|
|
|
Values = np.array(mylist)
|
|
catheter = np.zeros([len(Values)-2])
|
|
tcat = np.zeros([len(Values)-2])
|
|
for l in range(2,len(Values)):
|
|
row = Values[l].split(',')
|
|
catheter[l-2] = float(row[5])
|
|
tcat[l-2] = float(row[0])
|
|
tcat = tcat+shift_t
|
|
ax.plot(tcat[cstar[0]:tcat.size-cstar[1]],catheter[cstar[0]:tcat.size-cstar[1]],'white',linewidth=linesize,linestyle='--',label='$catheter$')
|
|
|
|
|
|
tm = np.linspace(0,Dt*tend,tend)
|
|
ax.set_xlim([-0.05,0.81])
|
|
|
|
else:
|
|
ax.set_xlabel(r'$time \ \ (s)$',fontsize=22)
|
|
ax.set_ylabel(r'$ \delta p \ \ (mmHg) $',fontsize=22)
|
|
#ax.set_ylim([-13,16])
|
|
tend = ref.size-3
|
|
tvec = np.linspace(0,Tf,ref.size)
|
|
|
|
|
|
#ax.plot(tm,ref,'white',linewidth=3,linestyle='--',label='$catheter$')
|
|
ax.plot(tm[0:tend],ref[0:tend],'white',linewidth=linesize,linestyle='-',label='$R=1$')
|
|
for r in R:
|
|
ppe_raw = open(masterpath+'/R'+str(r)+'/pdrop_PPE_impl_stan.dat','rb')
|
|
ste_raw = open(masterpath+'/R'+str(r)+'/pdrop_STE_impl_stan.dat','rb')
|
|
ppe = pickle.load(ppe_raw)['pdrop']*(barye2mmHg)
|
|
ste = pickle.load(ste_raw)['pdrop']*(barye2mmHg)
|
|
|
|
if options['estim']=='PPE':
|
|
ax.plot(tm[0:tend],ppe[0:tend],linewidth=linesize,linestyle='-',marker='o',markersize=dotsize , label='$R='+str(r)+'$')
|
|
elif options['estim']=='STE':
|
|
ax.plot(tm[0:tend],ste[0:tend],linewidth=linesize,linestyle='-',marker='o',markersize=dotsize,label='$R='+str(r)+'$')
|
|
|
|
if 'all' not in mode:
|
|
plt.xlabel('$time \ (s)$',fontsize=18)
|
|
plt.ylabel('$\delta p \ (mmHg)$',fontsize=18)
|
|
ax.legend(fontsize=12,loc=1)
|
|
if options['save_ppe']:
|
|
if options['estim']=='PPE':
|
|
fig.savefig(options['save_path']+options['name'], bbox_inches='tight',dpi=500)
|
|
if options['save_ste']:
|
|
if options['estim']=='STE':
|
|
fig.savefig(options['save_path']+options['name'], bbox_inches='tight',dpi=500)
|
|
|
|
|
|
|
|
|
|
plt.show()
|
|
|
|
def Plot_peaksystole(datapath,options,meshes,dt,R):
|
|
import pickle
|
|
barye2mmHg = 1/1333.22387415
|
|
|
|
|
|
for mesh_size in meshes:
|
|
t_star = 6
|
|
|
|
|
|
PPE_MEAN = np.zeros([len(R)])
|
|
PPE_STD = np.zeros([len(R)])
|
|
STE_MEAN = np.zeros([len(R)])
|
|
STE_STD = np.zeros([len(R)])
|
|
V_MEAN = np.zeros([len(R)])
|
|
V_STD = np.zeros([len(R)])
|
|
|
|
ref_P = 0
|
|
ref_V = 0
|
|
|
|
|
|
|
|
|
|
if mesh_size=='Ucoarse':
|
|
ref_V = 326.95828118309191
|
|
if mesh_size=='Ufine':
|
|
ref_V = 232.95021682714497
|
|
if mesh_size=='Uffine':
|
|
ref_V = 234.66445211879045
|
|
|
|
|
|
|
|
|
|
for l in range(len(R)):
|
|
if R[l]==0:
|
|
ref = np.loadtxt('/home/yeye/N_MRI/codes/pressure_drop/'+mesh_size+'/dt' + str(dt) + '/ref_'+mesh_size+'.txt')
|
|
PPE0_raw = open('/home/yeye/N_MRI/codes/pressure_drop/'+mesh_size+'/dt' + str(dt) + '/R0/pdrop_PPE_impl_stan.dat','rb')
|
|
STE0_raw = open('/home/yeye/N_MRI/codes/pressure_drop/'+mesh_size+'/dt' + str(dt) + '/R0/pdrop_STE_impl_stan.dat','rb')
|
|
PPE0 = pickle.load(PPE0_raw)['pdrop']*(-barye2mmHg)
|
|
STE0 = pickle.load(STE0_raw)['pdrop']*(-barye2mmHg)
|
|
|
|
curpath = datapath + 'sequences/aorta_'+mesh_size+'.npz'
|
|
p = np.load(curpath)
|
|
px = p['x']
|
|
py = p['y']
|
|
pz = p['z']
|
|
v = np.sqrt(px[:,:,:,t_star]**2 + py[:,:,:,t_star]**2 + pz[:,:,:,t_star]**2)
|
|
max0 = np.where(v==np.max(v))
|
|
|
|
ref_P = ref[6]
|
|
V_MEAN[l] = ref_V
|
|
V_STD[l] = 0
|
|
PPE_MEAN[l] = PPE0[6]
|
|
PPE_STD[l] = 0
|
|
STE_MEAN[l] = STE0[6]
|
|
STE_STD[l] = 0
|
|
else:
|
|
PPE_MEAN[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/ppemean_R'+ str(R[l]) +'.txt')
|
|
PPE_STD[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/ppestd_R'+ str(R[l]) +'.txt')
|
|
STE_MEAN[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/stemean_R'+ str(R[l]) +'.txt')
|
|
STE_STD[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/stestd_R'+ str(R[l]) +'.txt')
|
|
V_MEAN[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/vmean_R'+ str(R[l]) +'.txt')
|
|
V_STD[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/vstd_R'+ str(R[l]) +'.txt')
|
|
|
|
|
|
|
|
plt.figure(figsize=(10, 6), dpi=100)
|
|
Rvec = np.linspace(-10,R[-1]+5,100)
|
|
hline = Rvec*0+ref_P
|
|
plt.subplot(1,2,1)
|
|
plt.plot([0],[ref_P],color='k',marker='o',label= '$ref$')
|
|
plt.plot(Rvec,hline,color='k',linestyle='--')
|
|
plt.errorbar(R,PPE_MEAN, yerr=PPE_STD,color=options['ppecol'],marker='o',label= '$PPE$')
|
|
plt.errorbar(R,STE_MEAN, yerr=STE_STD,color=options['stecol'],marker='o',label= '$STE$')
|
|
plt.xlim([-2,R[-1]+5])
|
|
plt.ylim([-7,18])
|
|
plt.xlabel(r'$R$',fontsize=20)
|
|
plt.title('$Peak \ Systole \ pressure$',fontsize=18)
|
|
plt.ylabel(r'$ max \ \big ( \delta P \big ) \ \ mmHg$',fontsize=16)
|
|
|
|
|
|
plt.subplot(1,2,2)
|
|
#plt.plot([0],[ref_V],color='k',marker='o',label= '$ref$')
|
|
Rvec = np.linspace(-10,R[-1]+5,100)
|
|
hline = Rvec*0+ref_V
|
|
plt.plot(Rvec,hline,color='k',linestyle='--')
|
|
plt.errorbar(R,V_MEAN, yerr=V_STD,color='royalblue',marker='o',label= '$' + mesh_size + '$')
|
|
plt.xlim([-2,R[-1]+5])
|
|
plt.ylim([0,350])
|
|
plt.xlabel(r'$R$',fontsize=20)
|
|
plt.ylabel(r'$ max \ \big ( v \big ) \ \ cm/s$',fontsize=16)
|
|
plt.title('$Peak \ Systole \ velocity$',fontsize=18)
|
|
#plt.legend(fontsize=15)
|
|
|
|
plt.annotate('$'+mesh_size+'$', xy=(-0.2, 1.1), xycoords='axes fraction',fontsize=15)
|
|
|
|
|
|
plt.show()
|
|
|
|
def Plot_peaksystole_flux(datapath,options,meshes,dt,R):
|
|
import pickle
|
|
barye2mmHg = 1/1333.22387415
|
|
|
|
|
|
for mesh_size in meshes:
|
|
t_star = 6
|
|
PPE_MEAN = np.zeros([len(R)])
|
|
PPE_STD = np.zeros([len(R)])
|
|
STE_MEAN = np.zeros([len(R)])
|
|
STE_STD = np.zeros([len(R)])
|
|
V_MEAN = np.zeros([len(R)])
|
|
V_STD = np.zeros([len(R)])
|
|
Q_MEAN = np.zeros([len(R)])
|
|
Q_STD = np.zeros([len(R)])
|
|
|
|
ref_V = 0
|
|
|
|
if mesh_size=='Ucoarse':
|
|
ref_V = 326.95828118309191
|
|
if mesh_size=='Ufine':
|
|
ref_V = 232.95021682714497
|
|
if 'Uffine' in mesh_size:
|
|
ref_V = 226.93523675462458
|
|
maxv1 = 184.05091675316763
|
|
ref_Q = 454.77517472437495
|
|
maxq1 = 429.01393994253556
|
|
|
|
|
|
for l in range(len(R)):
|
|
if R[l]==0:
|
|
ref = np.loadtxt('/home/yeye/N_MRI/codes/pressure_drop/'+mesh_size+'/dt' + str(dt) + '/ref_'+mesh_size+'.txt')
|
|
PPE0_raw = open('/home/yeye/N_MRI/codes/pressure_drop/'+mesh_size+'/dt' + str(dt) + '/R0/pdrop_PPE_impl_stan.dat','rb')
|
|
STE0_raw = open('/home/yeye/N_MRI/codes/pressure_drop/'+mesh_size+'/dt' + str(dt) + '/R0/pdrop_STE_impl_stan.dat','rb')
|
|
PPE0 = pickle.load(PPE0_raw)['pdrop']*(-barye2mmHg)
|
|
STE0 = pickle.load(STE0_raw)['pdrop']*(-barye2mmHg)
|
|
|
|
curpath = datapath + 'sequences/aorta_'+mesh_size+'.npz'
|
|
p = np.load(curpath)
|
|
px = p['x']
|
|
py = p['y']
|
|
pz = p['z']
|
|
v = np.sqrt(px[:,:,:,t_star]**2 + py[:,:,:,t_star]**2 + pz[:,:,:,t_star]**2)
|
|
max0 = np.where(v==np.max(v))
|
|
V_MEAN[l] = ref_V
|
|
V_STD[l] = 0
|
|
PPE_MEAN[l] = PPE0[6]
|
|
PPE_STD[l] = 0
|
|
STE_MEAN[l] = STE0[6]
|
|
STE_STD[l] = 0
|
|
elif R[l]==1:
|
|
PPE_MEAN[l] = 0
|
|
PPE_STD[l] = 0
|
|
STE_MEAN[l] = 0
|
|
STE_STD[l] = 0
|
|
V_MEAN[l] = maxv1
|
|
V_STD[l] = 0
|
|
Q_MEAN[l] = maxq1
|
|
Q_STD[l] = 0
|
|
|
|
else:
|
|
PPE_MEAN[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/ppemean_R'+ str(R[l]) +'.txt')
|
|
PPE_STD[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/ppestd_R'+ str(R[l]) +'.txt')
|
|
STE_MEAN[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/stemean_R'+ str(R[l]) +'.txt')
|
|
STE_STD[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/stestd_R'+ str(R[l]) +'.txt')
|
|
V_MEAN[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/vmean_R'+ str(R[l]) +'.txt')
|
|
V_STD[l] = np.loadtxt(datapath + 'maxpv/'+mesh_size + '/vstd_R'+ str(R[l]) +'.txt')
|
|
Q_MEAN[l] = -np.loadtxt(datapath + 'maxpv/'+mesh_size + '/Q2_R'+ str(R[l]) +'.txt')
|
|
Q_STD[l] = -np.loadtxt(datapath + 'maxpv/'+mesh_size + '/Qstd2_R'+ str(R[l]) +'.txt')
|
|
|
|
|
|
|
|
plt.figure(figsize=(15, 5), dpi=100)
|
|
plt.annotate('$'+mesh_size+'$', xy=(-0.2, 1.1), xycoords='axes fraction',fontsize=15)
|
|
|
|
|
|
Rvec = np.linspace(-10,R[-1]+5,100)
|
|
plt.subplot(1,3,1)
|
|
#plt.plot(Rvec,hline,color='k',linestyle='--')
|
|
plt.errorbar(R,PPE_MEAN, yerr=PPE_STD,color=options['ppecol'],marker='o',label= '$PPE$')
|
|
plt.errorbar(R,STE_MEAN, yerr=STE_STD,color=options['stecol'],marker='o',label= '$STE$')
|
|
plt.xlim([-2,R[-1]+5])
|
|
plt.ylim([-0.1,2.0])
|
|
plt.xlabel(r'$R$',fontsize=20)
|
|
plt.legend(fontsize=12,loc=2)
|
|
plt.title('$ l_2 \ error \ in \ Peak \ pressure$',fontsize=16)
|
|
plt.xticks(R)
|
|
plt.ylabel(r'$ || p - p^{ref} ||/|| p^{ref} ||_{l2} $',fontsize=16)
|
|
|
|
|
|
plt.subplot(1,3,2)
|
|
#plt.plot([0],[ref_V],color='k',marker='o',label= '$ref$')
|
|
Rvec = np.linspace(-10,R[-1]+7,100)
|
|
hline = Rvec*0+ref_V
|
|
plt.plot(Rvec,hline,color='royalblue',linestyle='--')
|
|
plt.errorbar(R,V_MEAN, yerr=V_STD,color='royalblue',marker='o',label= '$' + mesh_size + '$')
|
|
plt.xlim([-2,R[-1]+5])
|
|
plt.ylim([0,350])
|
|
plt.xlabel(r'$R$',fontsize=20)
|
|
plt.ylabel(r'$ v \ \ cm/s$',fontsize=16)
|
|
plt.xticks(R)
|
|
plt.title('$Peak \ velocity$',fontsize=16)
|
|
#plt.legend(fontsize=15)
|
|
|
|
plt.subplot(1,3,3)
|
|
Rvec = np.linspace(-10,R[-1]+7,100)
|
|
hline = Rvec*0+ref_Q
|
|
plt.plot(Rvec,hline,color='mediumvioletred',linestyle='--')
|
|
plt.errorbar(R,Q_MEAN, yerr=Q_STD,color='mediumvioletred',marker='o',label= '$' + mesh_size + '$')
|
|
plt.xlim([-2,R[-1]+5])
|
|
plt.xlabel(r'$R$',fontsize=20)
|
|
plt.ylabel(r'$ Q \ \ ml/s$',fontsize=16)
|
|
plt.xticks(R)
|
|
plt.ylim([150,550])
|
|
plt.title('$Peak \ Flux $',fontsize=16)
|
|
|
|
|
|
|
|
|
|
plt.show()
|
|
|
|
def CLOCK(t1, t2):
|
|
tot_time = np.round(t2 - t1, 2)
|
|
if tot_time < 60:
|
|
print('Total time: ' + str(tot_time) + ' s')
|
|
elif tot_time < 3600:
|
|
time_min = tot_time//60
|
|
time_sec = tot_time - time_min*60
|
|
print('Total time: ' + str(time_min) +
|
|
' min, ' + str(time_sec) + ' s')
|
|
else:
|
|
time_hour = tot_time//3600
|
|
time_tot2 = tot_time - time_hour*3600
|
|
time_min = time_tot2//60
|
|
time_sec = time_tot2 - time_min*60
|
|
print('Total time: ' + str(time_hour) + ' hrs, ' +
|
|
str(time_min) + ' min, ' + str(time_sec) + ' s')
|
|
|
|
|
|
|
|
def ROUTINE(options):
|
|
|
|
if 'Histograms' in options:
|
|
if options['Histograms']['apply']:
|
|
print('--- Histograms ---')
|
|
meshnames = options['Histograms']['meshnames']
|
|
paths = options['Histograms']['paths']
|
|
colors = options['Histograms']['colors']
|
|
outpath = options['Histograms']['outpath']
|
|
Plot_Histogram(meshnames,paths,colors,outpath)
|
|
|
|
if 'dP' in options:
|
|
if options['dP']['apply']:
|
|
print('--- dP ---')
|
|
Plot_dP(options['dP']['data'],options,'pdrop',options['dP']['R'])
|
|
|
|
if 'HistCorrector' in options:
|
|
if options['HistCorrector']['apply']:
|
|
print('--- Histogram for Corrector ---')
|
|
|
|
import pickle
|
|
errors = open(options['HistCorrector']['errors'],'rb')
|
|
errors = pickle.load(errors)
|
|
Hi = np.zeros(errors[0].size)
|
|
for i in range(len(errors.keys())):
|
|
Hi += errors[i]
|
|
Hi = Hi/(i+1)
|
|
plt.hist(Hi, bins=100, density=True,range=[0.01,4],edgecolor='black',
|
|
color='orangered', alpha=0.75)
|
|
|
|
plt.ylim([0,14])
|
|
plt.xlabel('$|w/u|$',fontsize=18)
|
|
plt.ylabel('$density$',fontsize=18)
|
|
#plt.legend(fontsize=16)
|
|
plt.savefig(options['HistCorrector']['outpath'],dpi=500)
|
|
plt.show()
|
|
|
|
if 'Error-curves' in options:
|
|
if options['Error-curves']['apply']:
|
|
print('--- Error curves ---')
|
|
|
|
meas = {}
|
|
corrs = {}
|
|
times = {}
|
|
norm = options['Error-curves']['norm']
|
|
colorset = options['Error-curves']['colors']
|
|
|
|
for resol in options['Error-curves']['resol']:
|
|
meas[resol] = {}
|
|
corrs[resol] = {}
|
|
times[resol] = {}
|
|
for dts in options['Error-curves']['times']:
|
|
path = options['Error-curves']['folder'] + \
|
|
resol + '/dt' + dts
|
|
try:
|
|
corrs[resol][dts] = np.loadtxt(
|
|
path + '/w_' + str(norm) + 'norm.txt')
|
|
except IOError:
|
|
print('no curve for ' + resol + '/' + dts)
|
|
|
|
try:
|
|
meas[resol][dts] = np.loadtxt(
|
|
path + '/u_' + str(norm) + 'norm.txt')
|
|
times[resol][dts] = np.loadtxt(
|
|
path + '/times_' + str(norm) + 'norm.txt')
|
|
except IOError:
|
|
print('no meas for ' + resol + '/' + dts)
|
|
|
|
|
|
if 'meas' in options['Error-curves']['mode']:
|
|
for resol in options['Error-curves']['resol']:
|
|
for dts in meas[resol].keys():
|
|
if resol == 'H1':
|
|
nc = 0
|
|
elif resol == 'H2':
|
|
nc = 1
|
|
elif resol == 'H3':
|
|
nc = 2
|
|
plt.plot(times[resol][dts], meas[resol]
|
|
[dts], color=colorset[nc], label='$' + resol + '/' + dts + '$')
|
|
|
|
#plt.ylim([0, 1.1])
|
|
plt.ylabel('$||u||_2$', fontsize=18)
|
|
plt.xlabel('$time \ \ (s)$', fontsize=18)
|
|
plt.legend(fontsize=16)
|
|
plt.savefig(options['Error-curves']['outpath'] + 'meas_' +dts + '.png',
|
|
dpi=500, bbox_inches='tight')
|
|
plt.show()
|
|
|
|
if 'corrs' in options['Error-curves']['mode']:
|
|
for resol in options['Error-curves']['resol']:
|
|
for dts in corrs[resol].keys():
|
|
if resol == 'H1':
|
|
nc = 0
|
|
elif resol == 'H2':
|
|
nc = 1
|
|
elif resol == 'H3':
|
|
nc = 2
|
|
plt.plot(times[resol][dts], corrs[resol]
|
|
[dts], color = colorset[nc],label='$' + resol + '/' + dts + '$')
|
|
|
|
plt.ylim([0, 16.2])
|
|
plt.ylabel('$||w||_2$', fontsize=18)
|
|
plt.xlabel('$time \ \ (s)$', fontsize=18)
|
|
plt.legend(fontsize=16)
|
|
plt.savefig(options['Error-curves']['outpath'] + 'corrs_' +dts + '.png',
|
|
dpi=500, bbox_inches='tight')
|
|
plt.show()
|
|
|
|
if 'fracs' in options['Error-curves']['mode']:
|
|
for resol in options['Error-curves']['resol']:
|
|
for dts in corrs[resol].keys():
|
|
if resol == 'H1':
|
|
nc = 0
|
|
elif resol == 'H2':
|
|
nc = 1
|
|
elif resol == 'H3':
|
|
nc = 2
|
|
plt.plot(times[resol][dts], corrs[resol][dts]/meas[resol][dts],
|
|
color=colorset[nc], label='$' + resol + '/' + dts + '$')
|
|
|
|
plt.ylim([0, 1])
|
|
plt.ylabel('$||w||_2/||u||_2$', fontsize=18)
|
|
plt.xlabel('$time \ \ (s)$', fontsize=18)
|
|
plt.legend(fontsize=16)
|
|
plt.savefig(options['Error-curves']['outpath'] + 'fracs_' +dts + '.png',
|
|
dpi=500, bbox_inches='tight')
|
|
plt.show()
|
|
|
|
if 'Components' in options:
|
|
if options['Components']['apply']:
|
|
print('--- Components analysis ---')
|
|
|
|
for types in options['Components']['type']:
|
|
nc = 0
|
|
for subf in options['Components']['subfolders']:
|
|
ucomp = []
|
|
wcomp = []
|
|
colorset = options['Components']['colors']
|
|
path = options['Components']['folder'] + subf + '/'
|
|
try:
|
|
ucomp = np.loadtxt(path + '/u'+types+'.txt')
|
|
wcomp = np.loadtxt(path + '/w'+types+'.txt')
|
|
times = np.loadtxt(path + '/times.txt')
|
|
except IOError:
|
|
print('no components for ' + subf)
|
|
|
|
|
|
plt.plot(
|
|
times, ucomp, color=colorset[nc], linestyle='-', label= '$u'+ subf +'$' )
|
|
|
|
plt.plot(
|
|
times, wcomp, color=colorset[nc], linestyle='--', label='$w'+subf+'$')
|
|
nc +=1
|
|
|
|
#plt.ylim([0, 170])
|
|
plt.ylabel('$velocity \ \ (cm/s)$', fontsize=18)
|
|
plt.xlabel('$time \ \ (s)$', fontsize=18)
|
|
plt.legend(fontsize=16)
|
|
plt.savefig(options['Components']['outpath'] + types + '.png', dpi=500, bbox_inches='tight')
|
|
plt.show()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__=='__main__':
|
|
|
|
if 'Zion' in os.popen('hostname').read():
|
|
user = 'yeye'
|
|
np.set_printoptions(threshold=5)
|
|
if 'fwn-bborg-5-166' in os.popen('hostname').read():
|
|
user = 'p283370'
|
|
|
|
|
|
if len(sys.argv) > 1:
|
|
if os.path.exists(sys.argv[1]):
|
|
inputfile = sys.argv[1]
|
|
print('Found input file ' + inputfile)
|
|
else:
|
|
raise Exception('Command line arg given but input file does not exist:'
|
|
' {}'.format(sys.argv[1]))
|
|
else:
|
|
raise Exception('An input file is required as argument!')
|
|
|
|
|
|
start_time = time.time()
|
|
|
|
|
|
options = inout.read_parameters(inputfile)
|
|
ROUTINE(options)
|
|
end_time = time.time()
|
|
CLOCK(start_time,end_time)
|
|
|
|
|
|
|
|
# END
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|