extent = np.loadtxt(DIRR + "/" + dir +
"/inputs/mesh_extent.dat")
try:
hole1 = np.loadtxt(DIRR + "/" + dir +
"/inputs/mesh_hole1.dat")
hole2 = np.loadtxt(DIRR + "/" + dir +
"/inputs/mesh_hole2.dat")
holes = [hole1, hole2]
except:
holes = []
dirvtu = DIRR + "/" + dir + "/mesh2d/inversion_adjoint/" + dir_inv
if ('ModelT' in DIRM) and not (SSA):
vtufile = elmerreadlib.pvtu_file(
dirvtu + "/adjoint_beta0001.pvtu",
['constant temperature'])
depth_temp = elmerreadlib.depth_averaged_variables(vtufile)
x, y, temp = elmerreadlib.grid3d(depth_temp,
'constant temperature',
holes, extent)
geotifflib.write_from_grid(
x, y, np.flipud(temp), float('nan'),
DIRO + "/" + dir[0:11] + "_depthT.tif")
if n == 0:
files = os.listdir(dirvtu)
for file in files:
if file.startswith('adjoint_beta') and file.endswith(
'vtu'):
int(date[6:]))
# Get files and data
for i in range(0, len(m)):
if m[i] == 1:
slidinglaw = 'linear'
elif m[i] == 3:
slidinglaw = 'weertman'
else:
slidinglaw = 'm' + str(int(m[i]))
beta_file_ave = maindir+dir+'/mesh2d/steady_'+regpar+\
'_'+modelname+'_average_2000_2016_'+temperature_text+'_'+slidinglaw+'0001.pvtu'
beta_file_one = maindir+dir+'/mesh2d/steady_'+regpar+\
'_'+modelname+'_DEM'+beta_date+'_'+temperature_text+'_'+slidinglaw+'0001.pvtu'
data_ave = elmerreadlib.pvtu_file(beta_file_ave,
['vsurfini', vname])
surf_ave = elmerreadlib.values_in_layer(data_ave, 'surf')
data_one = elmerreadlib.pvtu_file(beta_file_one,
['vsurfini', vname])
surf_one = elmerreadlib.values_in_layer(data_one, 'surf')
# Get misfits
misfits_ave_mape[i,n] = np.mean(abs(((surf_ave['vsurfini']-surf_ave[vname])\
/surf_ave['vsurfini'])))*100
misfits_ave_rmse[i, n] = np.sqrt(
np.mean((surf_ave['vsurfini'] - surf_ave[vname])**2))
velocities_ave[i, n] = np.mean(surf_ave[vname][ind_cutoff])
misfits_one_mape[i,n] = np.mean(abs(((surf_one['vsurfini']-surf_one[vname])\
/surf_one['vsurfini'])))*100
misfits_one_rmse[i, n] = np.sqrt(
x_cutoff,y_cutoff,vsurfini_cutoff,ind_cutoff_grid, ind_cutoff = inverselib.get_velocity_cutoff(glacier,\
velocity_cutoff=cutoff,SSA=False)
# Now create plots and get misfit values for velocities > cutoff
n = 0
for dir in np.sort(dirs):
if dir.startswith('DEM') and dir.endswith(temperature_text):
if no_beta_file:
beta_date = dir[3:11]
beta_suffix = regpar + '_' + modelname + '_DEM' + beta_date + '_' + temperature_text + '_' + slidinglaw
elif beta_date == 'average':
beta_suffix = regpar + '_' + modelname + '_average_2000_2016_' + temperature_text + '_' + slidinglaw
else:
beta_suffix = regpar + '_' + modelname + '_DEM' + beta_date + '_' + temperature_text + '_' + slidinglaw
data = elmerreadlib.pvtu_file(maindir+dir+'/mesh2d/steady_'+beta_suffix+\
'0001.pvtu',['vsurfini',vname])
surf = elmerreadlib.values_in_layer(data, 'surf')
if n == 0:
# Mesh boundaries
extent = np.loadtxt(maindir + dir + "/inputs/mesh_extent.dat")
try:
hole1 = np.loadtxt(maindir + dir + "/inputs/mesh_hole1.dat")
hole2 = np.loadtxt(maindir + dir + "/inputs/mesh_hole2.dat")
holes = [hole1, hole2]
except:
holes = []
surf_misfit = np.zeros(surf.shape,
dtype=np.dtype(surf.dtype.descr +
[('misfit', np.float64)]))
for name in surf.dtype.descr:
cmap = 'viridis'
else:
vmin = 1.0e-3
vmax = 2.0
cmap = 'viridis'
n = 0
for dir in np.sort(dirs):
if dir.startswith('DEM') and dir.endswith(temperature):
try:
subdirs = os.listdir(maindir+dir+'/mesh2d/inversion_adjoint')
for subdir in subdirs:
if (regpar in subdir) and not(subdir.endswith('.pdf')):
if os.path.isfile(maindir+dir+'/mesh2d/inversion_adjoint/'+subdir+\
'/adjoint_beta_ssa0001.pvtu'):
data = elmerreadlib.pvtu_file(maindir+dir+'/mesh2d/inversion_adjoint/'+subdir+
'/adjoint_beta_ssa0001.pvtu',['ssavelocity','beta','vsurfini'])
else:
data = elmerreadlib.pvtu_file(maindir+dir+'/mesh2d/inversion_adjoint/'+subdir+
'/adjoint_beta0001.pvtu',['velocity','beta','vsurfini'])
bed = elmerreadlib.values_in_layer(data,'bed')
if n == 0:
# Mesh boundaries
extent = np.loadtxt(maindir+dir+"/inputs/mesh_extent.dat")
try:
hole1 = np.loadtxt(maindir+dir+"/inputs/mesh_hole1.dat")
hole2 = np.loadtxt(maindir+dir+"/inputs/mesh_hole2.dat")
holes=[hole1,hole2]
except:
holes = []
x,y,grid = elmerreadlib.grid3d(bed,output,holes,extent,dx=50)
if file.endswith('.pvtu'):
if ("FS" in file) and ("modelT" in file):
file_fs_mt = DIR+"mesh2d/"+file
elif ("FS" in file) and ("constantT" in file):
file_fs_ct = DIR+"mesh2d/"+file
elif ("SSA" in file) and ("modelT" in file):
file_ssa_mt = DIR+"mesh2d/"+file
elif ("SSA" in file) and ("constantT" in file):
file_ssa_ct = DIR+"mesh2d/"+file
# Get pvtu files
if 'FS' in DIR:
velocityname = 'velocity'
else:
velocityname = 'ssavelocity'
fs_mt = elmerreadlib.pvtu_file(file_fs_mt,[velocityname,'vsurfini'])
fs_ct = elmerreadlib.pvtu_file(file_fs_ct,[velocityname,'vsurfini'])
ssa_mt = elmerreadlib.pvtu_file(file_ssa_mt,[velocityname,'vsurfini'])
ssa_ct = elmerreadlib.pvtu_file(file_ssa_ct,[velocityname,'vsurfini'])
# Get values at the surface
surf_fs_mt = elmerreadlib.values_in_layer(fs_mt,'surface')
surf_fs_ct = elmerreadlib.values_in_layer(fs_ct,'surface')
surf_ssa_mt = elmerreadlib.values_in_layer(ssa_mt,'surface')
surf_ssa_ct = elmerreadlib.values_in_layer(ssa_ct,'surface')
# Get taub for this model
ax = plt.subplot(gs[i,0])
adjoint = elmerreadlib.pvtu_file(adjointfiles[i],[velocityname,'beta'])
bed = elmerreadlib.values_in_layer(adjoint,'bed')
x,y,taub = elmerreadlib.grid3d(bed,'taub',holes,extent)
DIRO = os.path.join(os.getenv("MODEL_HOME"),glacier+"/Results/"+DIRM)
if not(os.path.isdir(DIRO)):
os.mkdir(DIRO)
if SSA:
modelname = '_1e13_SSA_'
vname = 'ssavelocity'
else:
modelname = '_1e12_FS_'
vname = 'velocity'
DIRs = os.listdir(DIRR)
for dir in DIRs:
if not(dir.endswith('Lcurve')) and not(dir.endswith('steady')):
data = elmerreadlib.pvtu_file(DIRR+"/"+dir+"/mesh2d/steady"+modelname+beta_suffix+'0001.pvtu',[vname])
# Mesh boundaries
extent = np.loadtxt(DIRR+"/"+dir+"/inputs/mesh_extent.dat")
try:
hole1 = np.loadtxt(DIRR+"/"+dir+"/inputs/mesh_hole1.dat")
hole2 = np.loadtxt(DIRR+"/"+dir+"/inputs/mesh_hole2.dat")
holes=[hole1,hole2]
except:
holes = []
bed = elmerreadlib.values_in_layer(data,'bed')
surf = elmerreadlib.values_in_layer(data,'surf')
# Get basal velocities
x,y,bed_mod_ub = elmerreadlib.grid3d(bed,vname+' 1',holes,extent)
def get_velocity_cutoff(glacier,
velocity_cutoff=1000,
temperature='model',
model_dir='',
SSA=True,
sign='over'):
'''
x_grid,y_grid,vsurfini_grid,ind_cutoff_grid,ind_cutoff = get_velocity_cutoff(glacier,
velocity_cutoff=1000,temperature='model',model_dir='',SSA=True,sign='over')
Find nodes and grid indices where the velocity remains above a particular cutoff value, since
inversion results seem to be better for higher velocities.
Inputs:
glacier : glacier name
velocity_cutoff : cutoff value for velocity (m/yr)
temperature : model temperature
model_dir : add directory if the model results are NOT located in $MODEL_HOME/glacier/3D/
SSA : if the model is SSA
sign : find indices where values remain "over" or "under" the cutoff
Outputs:
x_grid : x values for vsurfini_grid
y_grid : y values for vsurfini_grid
vsurfini_grid : grid of minimum velocities through time
ind_cutoff_grid : grid indices that are below the velocity cutoff
ind_cutoff : node indices that remain above the velocity cutoff
'''
import os, elmerreadlib
import numpy as np
import scipy.ndimage
import matplotlib.pyplot as plt
# Get model result directories
maindir = os.path.join(os.getenv("MODEL_HOME"),
glacier + "/3D/" + model_dir + '/')
dirs = os.listdir(maindir)
# Set up various parameters for pulling the correct model results
if temperature == 'model':
temperature_text = 'modelT'
else:
temperature_text = 'constantT'
if SSA:
model_text = '1e13_SSA'
else:
model_text = '1e12_FS'
# Check to make sure we have an acceptable value for "sign". If not, exit code.
if not (sign == 'under') and not (sign == 'over'):
sys.exit("Unacceptable value for sign of " + sign)
# Get indices where velocity is always greater than the cutoff value
n = 0
for dir in dirs:
if dir.startswith('DEM') and dir.endswith(temperature_text):
beta_date = dir[3:11]
beta_suffix = model_text + '_DEM' + beta_date + '_' + temperature_text + '_'
data = elmerreadlib.pvtu_file(maindir+dir+'/mesh2d/steady_'+beta_suffix+'linear0001.pvtu',\
['vsurfini'])
surf = elmerreadlib.values_in_layer(data, 'surf')
if n == 0:
surf_min = np.zeros(surf.shape,
dtype=np.dtype(surf.dtype.descr))
for name in surf.dtype.descr:
surf_min[name[0]] = surf[name[0]]
extent = np.loadtxt(maindir + dir + '/inputs/mesh_extent.dat')
if glacier == 'Helheim':
hole1 = np.loadtxt(maindir + dir +
"/inputs/mesh_hole1.dat")
hole2 = np.loadtxt(maindir + dir +
"/inputs/mesh_hole2.dat")
holes = [hole1, hole2]
else:
holes = []
# Save minimum velocity through time
if sign == 'over':
ind = np.where(surf_min['vsurfini'] >= surf['vsurfini'])[0]
elif sign == 'under':
ind = np.where(surf_min['vsurfini'] <= surf['vsurfini'])[0]
if len(ind) > 0:
surf_min['vsurfini'][ind] = surf['vsurfini'][ind]
n = n + 1
# Grid and filter minimum velocity. Filtering removes some of the spurious single grid cells
# that remain above the cutoff value.
x_grid, y_grid, vsurfini_grid = elmerreadlib.grid3d(surf_min,
'vsurfini',
extent=extent,
holes=holes)
vsurfini_grid_smooth = scipy.ndimage.filters.gaussian_filter(vsurfini_grid,
sigma=2.5,
truncate=4)
# Find grid indices that are below the cutoff value
if sign == 'over':
ind_cutoff_grid = np.where((vsurfini_grid_smooth <= velocity_cutoff)
| (np.isnan(vsurfini_grid_smooth)))
elif sign == 'under':
ind_cutoff_grid = np.where((vsurfini_grid_smooth >= velocity_cutoff)
| (np.isnan(vsurfini_grid_smooth)))
# Find nodes that remain above the cutoff value
if sign == 'over':
ind_cutoff = np.where(surf_min['vsurfini'] >= velocity_cutoff)[0]
elif sign == 'under':
ind_cutoff = np.where(surf_min['vsurfini'] <= velocity_cutoff)[0]
return x_grid, y_grid, vsurfini_grid, ind_cutoff_grid, ind_cutoff
cost_sur = cost_sur[ind]
# Get vtu files
dirs = os.listdir(DIRR)
misfit = np.zeros([
len(regpar),
])
cutoffs = np.arange(0, 1001, 250)
MAPE = np.zeros([len(regpar), len(cutoffs)])
for i in range(0, len(regpar)):
for dir in dirs:
if (dir.startswith('lambda_' +
regpar_str[i])) and not (dir.endswith('.pdf')):
try:
vtudata = elmerreadlib.pvtu_file(
DIRR + dir + '/adjoint_beta_ssa0001.pvtu',
['vsurfini', 'ssavelocity'])
surf = elmerreadlib.values_in_layer(vtudata, 'surface')
misfit[i] = np.sqrt(np.mean((surf['vsurfini 1']-surf['ssavelocity 1'])**2+\
(surf['vsurfini 2']-surf['ssavelocity 2'])**2))
APE = abs((surf['vsurfini'] - surf['ssavelocity']) /
surf['vsurfini']) * 100
except:
vtudata = elmerreadlib.pvtu_file(
DIRR + dir + '/adjoint_beta0001.pvtu',
['vsurfini', 'velocity'])
surf = elmerreadlib.values_in_layer(vtudata, 'surface')
misfit[i] = np.sqrt(np.mean((surf['vsurfini 1']-surf['velocity 1'])**2+\
(surf['vsurfini 2']-surf['velocity 2'])**2))
APE = abs((surf['vsurfini'] - surf['velocity']) /
surf['vsurfini']) * 100
s_bins_min = np.zeros([len(bins), 4])
s_bins_max = np.zeros([len(bins), 4])
e_bins[:, :] = np.float('NaN')
s_bins_min[:, :] = np.float('NaN')
s_bins_max[:, :] = np.float('NaN')
for j in range(0, len(DIRs)):
DIRM = DIRs[j] + mesh + '_' + temperature_text[j] + '_Lcurve'
# Get vtu files
dirs = os.listdir(DIRM + '/mesh2d/inversion_adjoint/')
for dir in dirs:
if (dir.startswith('lambda_' +
regpars[j])) and not (dir.endswith('.pdf')):
try:
vtudata = elmerreadlib.pvtu_file(DIRM+'/mesh2d/inversion_adjoint/'+\
dir+'/adjoint_beta_ssa0001.pvtu',['vsurfini','ssavelocity','beta'])
vname = 'ssavelocity'
except:
vtudata = elmerreadlib.pvtu_file(DIRM+'/mesh2d/inversion_adjoint/'+\
dir+'/adjoint_beta0001.pvtu',['vsurfini','velocity','beta'])
vname = 'velocity'
surf = elmerreadlib.values_in_layer(vtudata, 'surface')
surf_misfit = np.zeros(surf.shape,
dtype=np.dtype(surf.dtype.descr +
[('misfit', np.float64)]))
for name in surf.dtype.descr:
surf_misfit[name[0]] = surf[name[0]]
surf_misfit['misfit'] = (surf[vname] -
surf['vsurfini']) / surf['vsurfini'] * 100
# Bin mean absolute residual by velocity, calculate 5 and 95 percentiles
times = []
n = 0
for dir in dirs:
if dir.startswith('DEM') and dir.endswith(temperature_text):
beta_date = dir[3:11]
files = os.listdir(maindir+dir+'/mesh2d/inversion_adjoint')
for file in files:
if file.startswith('lambda') and not(file.endswith('.pdf')):
beta_file_m1 = maindir+dir+'/mesh2d/inversion_adjoint/'+file+'/adjoint_beta_ssa0001.pvtu'
beta_file_m1_ave = maindir+dir+'/mesh2d/steady_'+regpar+\
'_SSA_average_2000_2016_'+temperature_text+'_linear0001.pvtu'
beta_file_m3_ave = maindir+dir+'/mesh2d/steady_'+regpar+\
'_SSA_average_2000_2016_'+temperature_text+'_weertman0001.pvtu'
data_m1 = elmerreadlib.pvtu_file(beta_file_m1,['vsurfini',vname,'beta'])
surf_m1 = elmerreadlib.values_in_layer(data_m1,'surf')
data_m1_ave = elmerreadlib.pvtu_file(beta_file_m1_ave,['vsurfini',vname])
surf_m1_ave = elmerreadlib.values_in_layer(data_m1_ave,'surf')
data_m3_ave = elmerreadlib.pvtu_file(beta_file_m3_ave,['vsurfini',vname])
surf_m3_ave = elmerreadlib.values_in_layer(data_m3_ave,'surf')
# Get variables
times.append(datelib.date_to_fracyear(int(beta_date[0:4]),int(beta_date[4:6]),int(beta_date[6:])))
velocities_obs.append(np.mean(surf_m1['vsurfini'][ind_cutoff]))
taub.append(np.mean(surf_m1['taub'][ind_cutoff]))
# Get driving stress and interpolate to mesh grid
x_taud,y_taud,taud_grid = elmerreadlib.input_file(maindir+dir+'/inputs/taud.xy')
def main():
##########
# inputs #
##########
args = get_arguments()
RES = args.mesh
partitions = str(args.n)
regpar = str(args.regpar)
method = args.method
extrude = str(args.extrude)
frontbc = str(args.frontbc)
sidewallbc = str(args.sidewallbc)
slipcoefficient = args.slipcoefficient
glacier = args.glacier
restartfile = args.restartfile
restartposition = args.restartposition
temperature = args.temperature
itmax = args.itmax
# Directories
DIRS = os.path.join(os.getenv("CODE_HOME"),
"big3/modeling/solverfiles/3D/")
DIRM = os.path.join(os.getenv("MODEL_HOME"), glacier + "/3D/" + RES + "/")
DIRR = os.path.join(DIRM + 'mesh2d/inversion_' + method + '/')
inputs = os.path.join(DIRM + "/inputs/")
extent = np.loadtxt(inputs + "mesh_extent.dat")
try:
hole1 = np.loadtxt(inputs + "mesh_hole1.dat")
hole2 = np.loadtxt(inputs + "mesh_hole2.dat")
holes = [hole1, hole2]
except:
holes = []
if not (os.path.exists(DIRR)):
os.makedirs(DIRR)
# Boundary numbers
bbed = 4
bsurf = 5
runname = method + "_beta"
# Grab boundary condition for front -- it will be different if we are using an actual
# terminus position (neumann, pressure BC) or an outflow boundary (dirichlet, velocity BC)
if method == 'adjoint':
if (frontbc == 'neumann') or (frontbc == 'pressure'):
frontbc_text = """
Adjoint Force BC = Logical True
Flow Force BC = Logical True
External Pressure = Variable Coordinate 3 !we are in MPa units
Real MATC "-1.0*waterpressure(tx)*1.0E-06" """
elif (frontbc == 'dirichlet') or (frontbc == 'velocity'):
frontbc_text = """
Velocity 1 = Variable Coordinate 1
Real procedure "USF_Init.so" "UIni"
Velocity 2 = Variable Coordinate 1
Real procedure "USF_Init.so" "VIni"
! Dirichlet BC => Dirichlet = 0 for Adjoint
Adjoint 1 = Real 0.0
Adjoint 2 = Real 0.0"""
else:
sys.exit("Unknown BC for front of glacier.")
elif method == 'robin':
if (frontbc == 'neumann') or (frontbc == 'pressure'):
frontbc_text = """
Flow Force BC = Logical True
External Pressure = Variable Coordinate 3 !we are in MPa units
Real MATC "-1.0*waterpressure(tx)*1.0E-06" """
elif (frontbc == 'dirichlet') or (frontbc == 'velocity'):
frontbc_text = """
! Dirichlet BCs
Velocity 1 = Variable Coordinate 1, Coordinate 2
Real procedure "USF_Init.so" "UIni"
Velocity 2 = Variable Coordinate 1, Coordinate 2
Real procedure "USF_Init.so" "VIni"
! Dirichlet BC => Same Dirichlet
VeloD 1 = Variable Coordinate 1, Coordinate 2
Real procedure "USF_Init.so" "UIni"
VeloD 2 = Variable Coordinate 1, Coordinate 2
Real procedure "USF_Init.so" "VIni" """
# Set boundary condition for sidewalls (either measured velocity or slip coefficient).
if method == 'adjoint':
if sidewallbc == 'friction':
sidewallbc_text = """
Normal-Tangential Velocity = Logical True
Normal-Tangential Adjoint = Logical True
Adjoint Force BC = Logical True
Velocity 1 = Real 0.0e0
Adjoint 1 = Real 0.0e0
Slip Coefficient 2 = Real """ + slipcoefficient + """
Slip Coefficient 3 = Real """ + slipcoefficient
elif sidewallbc == 'freeslip':
sidewallbc_text = """
Normal-Tangential Velocity = Logical True
Normal-Tangential Adjoint = Logical True
Adjoint Force BC = Logical True
Velocity 1 = Real 0.0e0
Adjoint 1 = Real 0.0e0"""
elif sidewallbc == 'velocity':
sidewallbc_text = """
!! Dirichlet BC
Velocity 1 = Variable Coordinate 1
Real procedure "USF_Init.so" "UWa"
Velocity 2 = Variable Coordinate 1
Real procedure "USF_Init.so" "VWa"
! Dirichlet BC => Dirichlet = 0 for Adjoint
Adjoint 1 = Real 0.0
Adjoint 2 = Real 0.0"""
else:
sys.exit("Unknown sidewall BC of " + sidewallbc)
if method == 'robin':
if sidewallbc == 'friction':
sidewallbc_text = """
Normal-Tangential Velocity = Logical True
Normal-Tangential VeloD = Logical True
Flow Force BC = Logical True
Velocity 1 = Real 0.0
VeloD 1 = Real 0.0e0
Slip Coefficient 2 = Real """ + slipcoefficient + """
Slip Coefficient 3 = Real """ + slipcoefficient
elif sidewallbc == 'freeslip':
sidewallbc_text = """
Normal-Tangential Velocity = Logical True
Normal-Tangential VeloD = Logical True
Flow Force BC = Logical True
Velocity 1 = Real 0.0
VeloD 1 = Real 0.0e0"""
elif sidewallbc == 'velocity':
sidewallbc_text = """
! Dirichlet BCs
Velocity 1 = Variable Coordinate 1
Real procedure "USF_Init.so" "UWa"
Velocity 2 = Variable Coordinate 1
Real procedure "USF_Init.so" "VWa"
! Dirichlet BC => Same Dirichlet
VeloD 1 = Variable Coordinate 1
Real procedure "USF_Init.so" "UWa"
VeloD 2 = Variable Coordinate 1
Real procedure "USF_Init.so" "VWa" """
else:
sys.exit("Unknown sidewall BC of " + sidewallbc)
if temperature == 'model':
temperature_text = """
Viscosity = Variable Coordinate 1, Coordinate 2
Real Procedure "USF_Init.so" "ModelViscosity"
Constant Temperature = Variable Coordinate 1, Coordinate 2
Real Procedure "USF_Init.so" "ModelTemperature" """
else:
try:
A = flowparameterlib.arrhenius(273.15 + float(temperature))
E = 3
temperature_text = """
Viscosity = Real $((""" + '2*' + str(E) + '*' + str(
A[0]) + '*' + 'yearinsec)^(-1.0/3.0)*1.0e-6)\r' + """
Constant Temperature = Real """ + str(temperature)
except:
sys.exit("Unknown temperature of " + temperature)
#############################
# Run inversion solver file #
#############################
if not (os.path.exists(DIRR + "summary.dat")):
fid_info = open(DIRR + "summary.dat", "w")
fid_info.write('Lambda Nsim Cost Norm RelPrec_G \n')
if restartfile != 'none':
solverfile = restartfile
date = restartfile[-12:-4]
# Move previous timesteps to output directory
DIRR_lambda = DIRR + "lambda_" + regpar + "_" + date + "/"
names = os.listdir(DIRM + "/mesh2d")
if not os.path.exists(DIRR_lambda):
os.makedirs(DIRR_lambda)
for name in names:
if name.endswith('vtu') and name.startswith(method):
os.rename(DIRM + "/mesh2d/" + name, DIRR_lambda + name)
try:
os.rename(
DIRM + "M1QN3_" + method + "_beta.out",
DIRR_lambda + "M1QN3_" + method + "_beta_beforerestart.out")
os.rename(
DIRM + "gradientnormadjoint_" + method + "_beta.dat",
DIRR_lambda + "gradient_" + runname + "_beforerestart.dat")
os.rename(DIRM + "cost_" + method + "_beta.dat",
DIRR_lambda + "cost_" + runname + "_beforerestart.dat")
except:
try:
os.rename(
DIRR_lambda + "M1QN3_" + method + "_beta.out",
DIRR_lambda + "M1QN3_" + method +
"_beta_beforerestart.out")
os.rename(
DIRR_lambda + "gradientnormadjoint_" + method +
"_beta.dat",
DIRR_lambda + "gradient_" + runname + "_beforerestart.dat")
os.rename(
DIRR_lambda + "cost_" + method + "_beta.dat",
DIRR_lambda + "cost_" + runname + "_beforerestart.dat")
except:
pass
else:
# Get current date
now = datetime.datetime.now()
date = '{0}{1:02.0f}{2:02.0f}'.format((now.year), (now.month),
(now.day))
restartposition = 0
solverfile = method + '_beta_' + regpar + '_' + date + '.sif'
os.chdir(DIRM)
fid1 = open(DIRS + method + '_beta_grounded.sif', 'r')
fid2 = open(DIRM + solverfile, 'w')
lines = fid1.read()
lines = lines.replace('{Extrude}', '{0}'.format(extrude))
lines = lines.replace('{Lambda}', '{0}'.format(regpar))
lines = lines.replace('{FrontBC}', '{0}'.format(frontbc_text))
lines = lines.replace('{SidewallBC}', '{0}'.format(sidewallbc_text))
lines = lines.replace('{ItMax}', '{0}'.format(int(itmax)))
lines = lines.replace('{Temperature}', '{0}'.format(temperature_text))
fid2.write(lines + os.linesep)
fid1.close()
fid2.close()
del fid1, fid2
returncode = elmerrunlib.run_elmer(DIRM + solverfile, n=partitions)
#####################################
# Write cost values to summary file #
#####################################
fid = open(DIRM + "cost_" + method + "_beta.dat", "r")
lines = fid.readlines()
line = lines[-1]
p = line.split()
nsim = float(p[0])
cost1 = float(p[1])
cost2 = float(p[2])
norm = float(p[3])
fid.close()
fid_info = open(DIRR + "summary.dat", "a")
fid_info.write('{} {} {} {} {}\n'.format(regpar, nsim + restartposition,
cost1, cost2, norm))
fid_info.close()
del fid
#######################################
# Move results to one directory #
#######################################
DIRR_lambda = DIRR + "lambda_" + regpar + "_" + date + "/"
# Something wrong with saveline boundary, so moving to reading pvtu_files
#bed = elmerreadlib.saveline_boundary(DIRM+"/mesh2d/",runname,bbed,['velocity 1','velocity 2','velocity 3','beta'])
#surf = elmerreadlib.saveline_boundary(DIRM+"/mesh2d/",runname,bsurf,['vsurfini 1','vsurfini 2','velocity 1','velocity 2','velocity 3'])
data = elmerreadlib.pvtu_file(
DIRM + "/mesh2d/" + runname + "0001.pvtu",
['beta', 'velocity', 'vsurfini 1', 'vsurfini 2'])
surf = elmerreadlib.values_in_layer(data, 'surf')
bed = elmerreadlib.values_in_layer(data, 'bed')
names = os.listdir(DIRM + "/mesh2d")
if not os.path.exists(DIRR_lambda):
os.makedirs(DIRR_lambda)
for name in names:
if name.endswith('pvtu') and name.startswith(method):
os.rename(
DIRM + "/mesh2d/" + name, DIRR_lambda + '{0}{1:04d}{2}'.format(
name[0:-9],
int(name[-9:-5]) + restartposition, '.pvtu'))
elif name.endswith('vtu') and name.startswith(method):
os.rename(
DIRM + "/mesh2d/" + name, DIRR_lambda + '{0}{1:04d}{2}'.format(
name[0:-8],
int(name[-8:-4]) + restartposition, '.vtu'))
elif name.startswith(method) and 'result' in name:
os.rename(DIRM + "/mesh2d/" + name, DIRR_lambda + name)
# Move saveline results
files = os.listdir(DIRM + "/mesh2d/")
for file in files:
if file.startswith(runname) and ('.dat' in file):
os.rename(DIRM + "/mesh2d/" + file, DIRR_lambda + file)
# Move outputs for optimization
os.rename(DIRM + "M1QN3_" + method + "_beta.out",
DIRR_lambda + "M1QN3_" + method + "_beta.out")
os.rename(DIRM + "gradientnormadjoint_" + method + "_beta.dat",
DIRR_lambda + "gradient_" + runname + ".dat")
os.rename(DIRM + "cost_" + method + "_beta.dat",
DIRR_lambda + "cost_" + runname + ".dat")
################################
# Output friction coefficients #
################################
# Gridded linear beta square
x, y, u = elmerreadlib.input_file(inputs + "udem.xy", dim=2)
xx, yy = np.meshgrid(x, y)
beta_linear = scipy.interpolate.griddata((bed['x'],bed['y']),\
bed['beta']**2, (xx,yy), method='nearest')
beta_linear_lin = scipy.interpolate.griddata((bed['x'],bed['y']),\
bed['beta']**2, (xx,yy), method='linear')
beta_weertman = scipy.interpolate.griddata((bed['x'],bed['y']),\
(bed['beta']**2)/(bed['velocity']**(-2.0/3.0)), (xx,yy), method='nearest')
beta_weertman_lin = scipy.interpolate.griddata((bed['x'],bed['y']),\
(bed['beta']**2)/(bed['velocity']**(-2.0/3.0)), (xx,yy), method='linear')
#if glacier == 'Helheim':
# # To get rid of edge effects near terminus, we take an average beta from farther upstream
# # and use that near the terminus
# ind_ave = np.where((xx > 302000) & (xx < 306000) & (yy < -2576000) & (yy > -2578000))
# ind = np.where((xx > 306000) & (yy < -2572000) & (yy > -2583000))
# beta_linear_lin[ind] = np.mean(beta_linear_lin[ind_ave])
# beta_weertman_lin[ind] = np.mean(beta_weertman_lin[ind_ave])
ind = np.where(~(np.isnan(beta_linear_lin)))
beta_linear[ind] = beta_linear_lin[ind]
ind = np.where(~(np.isnan(beta_weertman_lin)))
beta_weertman[ind] = beta_weertman_lin[ind]
del beta_linear_lin, beta_weertman_lin
# Output original results
fidr = open(inputs + "beta_linear_" + regpar + "_FS_" + RES + ".dat", 'w')
fidw = open(inputs + "beta_weertman_" + regpar + "_FS_" + RES + ".dat",
'w')
fidt = open(inputs + "taub_" + regpar + "_FS_" + RES + ".dat", 'w')
fidr.write('{}\n'.format(len(bed['x'])))
fidw.write('{}\n'.format(len(bed['x'])))
fidt.write('{}\n'.format(len(bed['x'])))
for i in range(0, len(bed['x'])):
fidr.write('{0} {1} {2:.16f}\n'.format(bed['x'][i], bed['y'][i],
bed['beta'][i]**2))
fidw.write('{0} {1} {2:.16f}\n'.format(
bed['x'][i], bed['y'][i],
(bed['beta'][i]**2) / (bed['velocity'][i]**(-2.0 / 3.0))))
fidt.write('{0} {1} {2:.16f}\n'.format(bed['x'][i], bed['y'][i],
bed['taub'][i] * 1e3))
fidr.close()
fidw.close()
fidt.close()
del fidr, fidw, fidt
# Output gridded results
fidl = open(inputs + "beta_linear.xy", 'w')
fidw = open(inputs + "beta_weertman.xy", 'w')
fidl.write('{}\n{}\n'.format(len(x), len(y)))
fidw.write('{}\n{}\n'.format(len(x), len(y)))
for i in range(0, len(x)):
for j in range(0, len(y)):
fidl.write('{0} {1} {2:.6f}\n'.format(x[i], y[j], beta_linear[j,
i]))
fidw.write('{0} {1} {2:.6f}\n'.format(x[i], y[j],
beta_weertman[j, i]))
fidl.close()
fidw.close()
del beta_linear, beta_weertman, u, x, y, fidl, fidw, xx, yy
xgrid, ygrid, taubgrid = elmerreadlib.grid3d(bed, 'taub', holes, extent)
xgrid, ygrid, vmodgrid = elmerreadlib.grid3d(surf, 'velocity', holes,
extent)
xgrid, ygrid, vmesgrid1 = elmerreadlib.grid3d(surf, 'vsurfini 1', holes,
extent)
xgrid, ygrid, vmesgrid2 = elmerreadlib.grid3d(surf, 'vsurfini 2', holes,
extent)
plt.figure(figsize=(6.5, 3))
plt.subplot(121)
plt.imshow(taubgrid * 1e3, origin='lower', clim=[0, 500])
plt.xticks([])
plt.yticks([])
cb = plt.colorbar(ticks=np.arange(0, 600, 100))
cb.ax.tick_params(labelsize=10)
cb.set_label('Basal shear stress (kPa)')
plt.subplot(122)
plt.imshow(vmodgrid - np.sqrt(vmesgrid1**2 + vmesgrid2**2),
origin='lower',
clim=[-200, 200],
cmap='RdBu_r')
plt.xticks([])
plt.yticks([])
cb = plt.colorbar(ticks=np.arange(-500, 600, 100))
cb.ax.tick_params(labelsize=10)
cb.set_label('Modeled-Measured (m/yr)')
plt.tight_layout()
plt.savefig(DIRR + 'lambda_' + regpar + '_' + date + '.pdf',
format='PDF',
dpi=400)
plt.close()
zbed3[~inmesh] = float('nan')
zbed3[inhole1] = float('nan')
zbed3[inhole2] = float('nan')
zbed4[~inmesh] = float('nan')
zbed4[inhole1] = float('nan')
zbed4[inhole2] = float('nan')
zbed5[~inmesh] = float('nan')
zbed5[inhole1] = float('nan')
zbed5[inhole2] = float('nan')
zbed8[~inmesh] = float('nan')
zbed8[inhole1] = float('nan')
zbed8[inhole2] = float('nan')
# Load bsmooth3
bed3_0 = elmerreadlib.pvtu_file(DIR_bed3 + 'mesh2d/terminusdriven0001.pvtu',
['velocity', 'zs top'])
bed3_0 = bed3_0[bed3_0['zs top'] != 0]
bed3_1 = elmerreadlib.pvtu_file(DIR_bed3 + 'mesh2d/terminusdriven0367.pvtu',
['velocity', 'zs top'])
bed3_1 = bed3_1[bed3_1['zs top'] != 0]
bed3_z0 = griddata((bed3_0['x'], bed3_0['y']), bed3_0['z'], (xgrid, ygrid))
bed3_z1 = griddata((bed3_1['x'], bed3_1['y']), bed3_1['z'], (xgrid, ygrid))
bed3_z0[~inmesh] = float('nan')
bed3_z0[inhole1] = float('nan')
bed3_z0[inhole2] = float('nan')
bed3_z1[~inmesh] = float('nan')
bed3_z1[inhole1] = float('nan')
bed3_z1[inhole2] = float('nan')
regpars.append(p[0])
fid.close()
regpars = ['1e12','2e12','3e12','4e12','5e12','6e12','7e12','8e12','9e12','1e13']
nt = len(regpars)
###############################################################
# Compare results from different models for different regions #
###############################################################
# Get one of the models to get node coordinates
dirs = os.listdir(DIR+'/mesh2d/inversion_adjoint/')
for dir in dirs:
if dir.startswith('lambda_'+regpars[0]) and not(dir.endswith('.pdf')):
try:
vtu = elmerreadlib.pvtu_file(DIR+'/mesh2d/inversion_adjoint/'+dir+'/adjoint_beta_ssa0001.pvtu',\
['ssavelocity','beta','vsurfini'])
except:
vtu = elmerreadlib.pvtu_file(DIR+'/mesh2d/inversion_adjoint/'+dir+'/adjoint_beta0001.pvtu',\
['velocity','beta','vsurfini'])
bed = elmerreadlib.values_in_layer(vtu,'bed')
# Percentile range for calculating statistics
q = 50.
# Get indices for averages
ind_U = []
ind_M = []
ind_L = []
ind_S = []
for i in range(0,len(bed['x'])):
if region_U.contains_point([bed['x'][i],bed['y'][i]]):
def main():
##########
# inputs #
##########
args = get_arguments()
RES = args.mesh
partitions = str(args.n)
regpar = str(args.regpar)
frontbc = str(args.frontbc)
glacier = args.glacier
restartfile = args.restartfile
restartposition = args.restartposition
temperature = args.temperature
itmax = args.itmax
# Directories
DIRS = os.path.join(os.getenv("CODE_HOME"),
"big3/modeling/solverfiles/ssa/")
DIRM = os.path.join(os.getenv("MODEL_HOME"), glacier + "/3D/" + RES + "/")
DIRR = os.path.join(DIRM + 'mesh2d/inversion_adjoint/')
inputs = os.path.join(DIRM + "/inputs/")
extent = np.loadtxt(inputs + "mesh_extent.dat")
try:
hole1 = np.loadtxt(inputs + "mesh_hole1.dat")
hole2 = np.loadtxt(inputs + "mesh_hole2.dat")
holes = [hole1, hole2]
except:
holes = []
if not (os.path.exists(DIRR)):
os.makedirs(DIRR)
# Boundary numbers
bbed = 4
bsurf = 5
runname = "adjoint_beta_ssa"
if temperature == 'model':
temperature_text = """
mu = Variable Coordinate 1, Coordinate 2\r
Real Procedure "USF_Init.so" "SSAViscosity""" ""
else:
try:
print float(temperature)
A = flowparameterlib.arrhenius(273.15 + float(temperature))
E = 3
temperature_text = """
mu = Real $((""" + '2*' + str(E) + '*' + str(
A[0]) + '*' + 'yearinsec)^(-1.0/3.0)*1.0e-6)'
except:
sys.exit("Unknown temperature of " + temperature)
if frontbc == 'velocity' or frontbc == 'dirichlet':
frontbc_text = """
SSAVelocity 1= Equals vsurfini 1\r
SSAVelocity 2= Equals vsurfini 2\r
Adjoint 1 = Real 0.0\r
Adjoint 2 = Real 0.0"""
elif frontbc == 'pressure' or frontbc == 'neumann':
frontbc_text = """
Calving Front = Logical True"""
################################################
# Compile fortran libraries for adjoint solver #
################################################
# Check that fortran files are compiled
DIRELMERLIB = os.path.join(os.getenv("CODE_HOME"),
"big3/modeling/elmerlib/")
readfiles = os.listdir(DIRELMERLIB + "AdjointSSA/")
outputfile = DIRELMERLIB + "AdjointSSASolvers.so"
allstring = ''
for f in readfiles:
if f.endswith('.F90'):
allstring = allstring + f + ' '
os.chdir(DIRELMERLIB + "AdjointSSA/")
call(["elmerf90", "-o", outputfile, allstring])
del DIRELMERLIB
#############################
# Run inversion solver file #
#############################
if not (os.path.exists(DIRR + "summary.dat")):
fid_info = open(DIRR + "summary.dat", "w")
fid_info.write('Lambda Nsim Cost Norm RelPrec_G \n')
if restartfile != 'none':
solverfile = restartfile
date = restartfile[-12:-4]
# Move previous timesteps to output directory
DIRR_lambda = DIRR + "lambda_" + regpar + "_" + date + "/"
names = os.listdir(DIRM + "/mesh2d")
if not os.path.exists(DIRR_lambda):
os.makedirs(DIRR_lambda)
for name in names:
if name.endswith('vtu') and name.startswith('adjoint'):
os.rename(DIRM + "/mesh2d/" + name, DIRR_lambda + name)
else:
# Get current date
now = datetime.datetime.now()
date = '{0}{1:02.0f}{2:02.0f}'.format((now.year), (now.month),
(now.day))
restartposition = 0
solverfile = 'adjoint_beta_' + regpar + '_' + date + '.sif'
os.chdir(DIRM)
fid1 = open(DIRS + 'adjoint_beta_ssa.sif', 'r')
fid2 = open(DIRM + solverfile, 'w')
lines = fid1.read()
lines = lines.replace('{Lambda}', '{0}'.format(regpar))
lines = lines.replace('{ItMax}', '{0}'.format(int(itmax)))
lines = lines.replace('{Temperature}', '{0}'.format(temperature_text))
lines = lines.replace('{FrontBC}', '{0}'.format(frontbc_text))
fid2.write(lines)
fid1.close()
fid2.close()
del fid1, fid2
returncode = elmerrunlib.run_elmer(DIRM + solverfile, n=partitions)
#####################################
# Write cost values to summary file #
#####################################
fidcost = open(DIRM + "cost.dat", "r")
lines = fidcost.readlines()
line = lines[-1]
p = line.split()
nsim = float(p[0])
costsur = float(p[1])
fidcost.close()
fidcostreg = open(DIRM + "costreg.dat")
lines = fidcostreg.readlines()
line = lines[-1]
p = line.split()
nsim = float(p[0])
costbed = float(p[1]) #/float(regpar)
fidcostreg.close()
costtot = costsur + float(regpar) * costbed
fid_info = open(DIRR + "summary.dat", "a")
fid_info.write('{} {} {} {} {}\n'.format(regpar, nsim + restartposition,
costtot, costsur, costbed))
fid_info.close()
del fidcost, fidcostreg
#######################################
# Combine elmer results into one file #
#######################################
DIRR_lambda = DIRR + "lambda_" + regpar + "_" + date + "/"
names = os.listdir(DIRM + "/mesh2d")
if not os.path.exists(DIRR_lambda):
os.makedirs(DIRR_lambda)
for name in names:
if name.endswith('pvtu') and name.startswith('adjoint'):
os.rename(
DIRM + "/mesh2d/" + name, DIRR_lambda + '{0}{1:04d}{2}'.format(
name[0:-9],
int(name[-9:-5]) + restartposition, '.pvtu'))
elif name.endswith('vtu') and name.startswith('adjoint'):
os.rename(
DIRM + "/mesh2d/" + name, DIRR_lambda + '{0}{1:04d}{2}'.format(
name[0:-8],
int(name[-8:-4]) + restartposition, '.vtu'))
elif name.startswith('adjoint') and 'result' in name:
os.rename(DIRM + "/mesh2d/" + name, DIRR_lambda + name)
bed = elmerreadlib.pvtu_file(DIRR_lambda + 'adjoint_beta_ssa0001.pvtu',
['ssavelocity', 'beta', 'vsurfini'])
# Move outputs for optimization
os.rename(DIRM + "M1QN3_adjoint_beta_ssa.out",
DIRR_lambda + "M1QN3_adjoint_beta_ssa.out")
os.rename(DIRM + "cost.dat", DIRR_lambda + "cost.dat")
os.rename(DIRM + "costreg.dat", DIRR_lambda + "costreg.dat")
os.rename(DIRM + "gradientnormadjoint_adjoint_beta_ssa.dat",
DIRR_lambda + "gradientnormadjoint_adjoint_beta_ssa.dat")
################################
# Output friction coefficients #
################################
# Gridded linear beta square
x, y, u = elmerreadlib.input_file(inputs + "udem.xy", dim=2)
xx, yy = np.meshgrid(x, y)
beta_linear = scipy.interpolate.griddata((bed['x'],bed['y']),bed['beta']**2,(xx,yy),\
method='nearest')
beta_linear_lin = scipy.interpolate.griddata((bed['x'],bed['y']),bed['beta']**2,(xx,yy),\
method='linear')
beta_weertman_lin = scipy.interpolate.griddata((bed['x'],bed['y']),\
(bed['beta']**2)/(bed['ssavelocity']**(-2.0/3.0)), (xx,yy), method='linear')
beta_weertman = scipy.interpolate.griddata((bed['x'],bed['y']),\
(bed['beta']**2)*(bed['ssavelocity']**(-2.0/3.0)),(xx,yy),method='nearest')
ind = np.where(~(np.isnan(beta_linear_lin)))
beta_linear[ind] = beta_linear_lin[ind]
ind = np.where(~(np.isnan(beta_weertman_lin)))
beta_weertman[ind] = beta_weertman_lin[ind]
del beta_linear_lin, beta_weertman_lin
# Output original results
fidr = open(inputs + "beta_linear_" + regpar + "_SSA_" + RES + ".dat", 'w')
fidw = open(inputs + "beta_weertman_" + regpar + "_SSA_" + RES + ".dat",
'w')
fidt = open(inputs + "taub_" + regpar + "_SSA_" + RES + ".dat", 'w')
fidr.write('{}\n'.format(len(bed['x'])))
fidw.write('{}\n'.format(len(bed['x'])))
fidt.write('{}\n'.format(len(bed['x'])))
for i in range(0, len(bed['x'])):
fidr.write('{0} {1} {2:.16f}\n'.format(bed['x'][i], bed['y'][i],
bed['beta'][i]**2))
fidw.write('{0} {1} {2:.16f}\n'.format(bed['x'][i],bed['y'][i],\
(bed['beta'][i]**2)/(bed['ssavelocity'][i]**(-2.0/3.0))))
fidt.write('{0} {1} {2:.16f}\n'.format(bed['x'][i], bed['y'][i],
bed['taub'][i] * 1e3))
fidr.close()
fidw.close()
fidt.close()
del fidr, fidw, fidt
fidl = open(inputs + "beta_linear.xy", 'w')
fidw = open(inputs + "beta_weertman.xy", 'w')
fidl.write('{}\n{}\n'.format(len(x), len(y)))
fidw.write('{}\n{}\n'.format(len(x), len(y)))
for i in range(0, len(x)):
for j in range(0, len(y)):
fidl.write('{0} {1} {2}\n'.format(x[i], y[j], beta_linear[j, i]))
fidw.write('{0} {1} {2}\n'.format(x[i], y[j], beta_weertman[j, i]))
fidl.close()
fidw.close()
del beta_linear, beta_weertman, u, x, y, fidl, fidw, xx, yy
xgrid, ygrid, taubgrid = elmerreadlib.grid3d(bed, 'taub', holes, extent)
xgrid, ygrid, vmodgrid = elmerreadlib.grid3d(bed, 'ssavelocity', holes,
extent)
xgrid, ygrid, vmesgrid = elmerreadlib.grid3d(bed, 'vsurfini', holes,
extent)
plt.figure(figsize=(6.5, 3))
plt.subplot(121)
plt.imshow(taubgrid * 1e3, origin='lower', clim=[0, 500])
plt.xticks([])
plt.yticks([])
cb = plt.colorbar(ticks=np.arange(0, 600, 100))
cb.ax.tick_params(labelsize=10)
cb.set_label('Basal shear stress (kPa)')
plt.subplot(122)
plt.imshow(vmodgrid - vmesgrid,
origin='lower',
clim=[-200, 200],
cmap='RdBu_r')
plt.xticks([])
plt.yticks([])
cb = plt.colorbar(ticks=np.arange(-500, 600, 100))
cb.ax.tick_params(labelsize=10)
cb.set_label('Modeled-Measured (m/yr)')
plt.tight_layout()
plt.savefig(DIRR + 'lambda_' + regpar + '_' + date + '.pdf',
format='PDF',
dpi=400)
plt.close()
