Uobs_o = Uobs.copy() # So that we can eliminate 'no data' point in a minute
# Multiply the observed velocities by a 'shape factor' to go
# from the surface to the vertical averaged velocities.
# I think that this can be represented pretty well with a sigmoid
# (logistic) function:
# |u| / |u_s| = .8 + .2 / (1 + exp(-(|u| - 50) * .25))
#
# Which is centered at 50 m/a and has about a 25 m/a width.
# We might experiment with these values later.
Uobs = project(Uobs * (.8 + .2 / (1 + exp(-(Uobs - 50) * .25))))
Uobs.vector()[Uobs_o.vector().array()<0] = NO_DATA # Relies on copy, Uobs_o
U_sar_spline = dms.get_spline_expression("sp")
# Create a mask that only uses lower error velocities.
VELOCITY_THRESHOLD = 0.5 # A lower limit on credible InSAR measurements.
V_ERROR_THRESHOLD = 0.15 # Errors larger than this fraction ignored
insar_mask = CellFunctionSizet(mesh)
insar_mask.set_all(0)
for c in cells(mesh):
x,y = c.midpoint().x(),c.midpoint().y()
Uval = U_sar_spline(x,y)
vxerrval = vxerr(x,y)
verrval = verr(x,y)
if Uval>VELOCITY_THRESHOLD and vxerrval != NO_DATA\
# create data objects to use with varglas :
dsr = DataInput(None, searise, mesh=mesh)
dbm = DataInput(None, bamber, mesh=mesh)
#dms = DataInput(None, measure, mesh=mesh)
#dmss = DataInput(None, meas_shf, mesh=mesh)
dfm = DataInput(None, fm_qgeo, mesh=mesh)
#dsq = DataInput(None, sec_qgeo, mesh=mesh)
dmg = DataInput(None, merged, mesh=mesh)
#dbv = DataInput("results/", ("Ubmag_measures.mat", "Ubmag.mat"), mesh=mesh)
# change the projection of the measures data to fit with other data :
#dms.change_projection(dsr)
dmg.change_projection(dsr)
# get the expressions used by varglas :
Thickness = dbm.get_spline_expression('H')
Surface = dbm.get_spline_expression('h')
Bed = dbm.get_spline_expression('b')
SurfaceTemperature = dsr.get_spline_expression('T')
BasalHeatFlux = dfm.get_spline_expression('q_geo')
adot = dsr.get_spline_expression('adot')
U_observed = dmg.get_spline_expression('v_mag')
model = model.Model()
model.set_geometry(Surface, Bed)
model.set_mesh(mesh, flat_mesh=flat_mesh, deform=True)
model.set_parameters(pc.IceParameters())
model.initialize_variables()
# specifify non-linear solver parameters :
flat_mesh.coordinates()[:, 2] /= 100000.0
# create data objects to use with varglas :
dsr = DataInput(None, searise, mesh=mesh)
dbm = DataInput(None, bamber, mesh=mesh)
#dms = DataInput(None, measure, mesh=mesh)
#dmss = DataInput(None, meas_shf, mesh=mesh)
dfm = DataInput(None, fm_qgeo, mesh=mesh)
dsq = DataInput(None, sec_qgeo, mesh=mesh)
#dbv = DataInput("results/", ("Ubmag_measures.mat", "Ubmag.mat"), mesh=mesh)
# change the projection of the measures data to fit with other data :
#dms.change_projection(dsr)
# get the expressions used by varglas :
Thickness = dbm.get_spline_expression('H')
Surface = dbm.get_spline_expression('h')
Bed = dbm.get_spline_expression('b')
SurfaceTemperature = dsr.get_spline_expression('T')
#BasalHeatFlux = dsr.get_spline_expression('q_geo')
BasalHeatFlux = dsq.get_spline_expression('q_geo')
#BasalHeatFlux = dfm.get_spline_expression('q_geo')
adot = dsr.get_spline_expression('adot')
U_observed = dsr.get_spline_expression('U_ob')
# inspect the data values :
do = DataOutput('results_pre/')
model = model.Model()
model.set_geometry(Surface, Bed)
model.set_mesh(mesh, flat_mesh=flat_mesh, deform=True)
model.set_parameters(pc.IceParameters())
thklim = 50.0
db2.set_data_min("H", thklim, thklim)
db2.set_data_min("h", 0.0,0.0)
db2.set_data_max("H",30000.,thklim)
db2.set_data_max("h",30000.,0.0)
db2.data['b'] = db2.data['h']-db2.data['H']
db1.data['srfTemp'] += 273.15
db1.data['q_geo'] *= 60**2*24*365
Surface = db2.get_spline_expression("h")
Bed = db2.get_spline_expression("b")
SurfaceTemperature = db1.get_spline_expression("srfTemp")
BasalHeatFlux = db1.get_spline_expression("q_geo")
U_observed = dm.get_spline_expression("v_mag")
#===============================================================================
nonlin_solver_params = default_nonlin_solver_params()
nonlin_solver_params['newton_solver']['relaxation_parameter'] = 0.5
nonlin_solver_params['newton_solver']['relative_tolerance'] = 1e-3
nonlin_solver_params['newton_solver']['maximum_iterations'] = 20
nonlin_solver_params['newton_solver']['error_on_nonconvergence'] = False
nonlin_solver_params['linear_solver'] = 'mumps'
nonlin_solver_params['preconditioner'] = 'default'
#set_log_level(PROGRESS)
thklim = 200.0
# collect the raw data :
bamber = DataFactory.get_bamber(thklim=thklim)
# define the meshes :
mesh = Mesh('meshes/greenland_3D_5H.xml')
mesh.coordinates()[:, 2] /= 100000.0
# create data objects to use with varglas :
dbm = DataInput(None, bamber, mesh=mesh)
# get the expressions used by varglas :
Surface = dbm.get_spline_expression('h')
Bed = dbm.get_spline_expression('b')
model = model.Model(out_dir=out_dir)
model.set_geometry(Surface, Bed)
model.set_mesh(mesh, deform=True)
model.set_parameters(pc.IceParameters())
model.initialize_variables()
parameters['form_compiler']['quadrature_degree'] = 2
File(in_dir + 'u.xml') >> model.u
File(in_dir + 'v.xml') >> model.v
File(in_dir + 'w.xml') >> model.w
File(in_dir + 'beta2.xml') >> model.beta2
File(in_dir + 'eta.xml') >> model.eta
dms = DataInput(None, measure, mesh=mesh, create_proj=True, flip=True)
dms.change_projection(dsr)
dbam.set_data_min('H', 10.0, 10.0)
dsr.set_data_min('U_ob',0.0,0.0)
dms.set_data_val('sp',-0.1,-2e9)
H = dbam.get_interpolation("H")
S = dbam.get_interpolation("h")
adot = dsr.get_interpolation("adot")
#Uobs = dms.get_interpolation("sp",kx=1,ky=1)
Uobs = dsr.get_interpolation("U_ob",kx=1,ky=1)
Uobs.vector()[Uobs.vector().array()<0] = 0.0
U_sar_spline = dms.get_spline_expression("sp",kx=1,ky=1)
insar_mask = CellFunctionSizet(mesh)
insar_mask.set_all(0)
for c in cells(mesh):
x,y = c.midpoint().x(),c.midpoint().y()
Uval = U_sar_spline(x,y)
print Uval
if Uval>0:
insar_mask[c]=1
prb = VelocityBalance_2(mesh, H, S, adot, 8.0,Uobs=Uobs,Uobs_mask=insar_mask,alpha=[0.0,1e7,0.0])
n = len(mesh.coordinates())
Uopt_file = File('results/Uopt.pvd')
Uobs_file = File('results/Uobs.pvd')
H_file = File('results/H.pvd')
from src.helper import default_nonlin_solver_params
from src.utilities import DataInput
from dolfin import *
set_log_active(True)
parameters['form_compiler']['quadrature_degree'] = 1
vara = DataFactory.get_searise()
mesh = MeshFactory.get_greenland_medium()
#mesh.coordinates()[:,2] = mesh.coordinates()[:,2]/1000.0
flat_mesh = MeshFactory.get_greenland_medium()
dd = DataInput(None, vara, mesh=mesh)
Surface = dd.get_spline_expression('h')
Bed = dd.get_spline_expression('b')
Smb = dd.get_spline_expression('adot')
SurfaceTemperature = dd.get_spline_expression('T')
BasalHeatFlux = dd.get_spline_expression('q_geo')
U_observed = dd.get_spline_expression('U_ob')
nonlin_solver_params = default_nonlin_solver_params()
nonlin_solver_params['newton_solver']['relaxation_parameter'] = 0.7
nonlin_solver_params['newton_solver']['relative_tolerance'] = 1e-3
nonlin_solver_params['newton_solver']['maximum_iterations'] = 20
nonlin_solver_params['newton_solver']['error_on_nonconvergence'] = False
nonlin_solver_params['linear_solver'] = 'mumps'
nonlin_solver_params['preconditioner'] = 'default'
config = { 'mode' : 'steady',
db2.set_data_val('h', 32767, 0.0)
dm.set_data_min('v_mag', 0.0, 0.0)
#h = db2.get_projection('h')
#H = db2.get_projection('H')
#v_mag = dm.get_projection('v_mag')
#surfTemp = db1.get_projection("srfTemp")
#q_geo = db1.get_projection("q_geo")
#File('tests/q_geo.pvd') << q_geo
#File('tests/srfTemp.pvd') << surfTemp
#File('tests/hf.pvd') << h
#File('tests/Hf.pvd') << H
#File('tests/v_magf.pvd') << v_mag
Thickness = db2.get_spline_expression("H")
Surface = db2.get_spline_expression("h")
Bed = db2.get_spline_expression("b")
Mask = db2.get_nearest_expression("mask")
SurfaceTemperature = db1.get_spline_expression("srfTemp")
BasalHeatFlux = db1.get_spline_expression("q_geo")
adot = db1.get_spline_expression("adot")
U_observed = dm.get_spline_expression("v_mag")
model = model.Model()
model.set_geometry(Surface, Bed, Mask)
model.set_mesh(mesh, flat_mesh=flat_mesh, deform=True)
model.set_parameters(pc.IceParameters())
model.initialize_variables()
from src.helper import default_nonlin_solver_params
from pylb import *
from dolfin import set_log_active
from scipy.io import *
set_log_active(True)
vara = DataFactory.get_searise(thklim = 50.0)
mesh = MeshFactory.get_greenland_coarse()
flat_mesh = MeshFactory.get_greenland_coarse()
mesh.coordinates()[:,2] = mesh.coordinates()[:,2]/1000.0
dd = DataInput(None, vara, mesh=mesh)
Surface = dd.get_spline_expression('h')
Bed = dd.get_spline_expression('b')
SMB = dd.get_spline_expression('adot')
SurfaceTemperature = dd.get_spline_expression('T')
BasalHeatFlux = dd.get_spline_expression('q_geo')
U_observed = dd.get_spline_expression('U_ob')
Tn = vara['Tn']['map_data']
nonlin_solver_params = default_nonlin_solver_params()
nonlin_solver_params['newton_solver']['relaxation_parameter'] = 0.7
nonlin_solver_params['newton_solver']['relative_tolerance'] = 1e-3
nonlin_solver_params['newton_solver']['maximum_iterations'] = 20
nonlin_solver_params['newton_solver']['error_on_nonconvergence'] = False
nonlin_solver_params['newton_solver']['linear_solver'] = 'gmres'
nonlin_solver_params['newton_solver']['preconditioner'] = 'hypre_amg'
# create data objects to use with varglas :
dsr = DataInput(None, searise, mesh=mesh)
dbm = DataInput(None, bamber, mesh=mesh)
#dms = DataInput(None, measure, mesh=mesh)
#dmss = DataInput(None, meas_shf, mesh=mesh)
dfm = DataInput(None, fm_qgeo, mesh=mesh)
dsq = DataInput(None, sec_qgeo, mesh=mesh)
#dbv = DataInput("results/", ("Ubmag_measures.mat", "Ubmag.mat"), mesh=mesh)
# change the projection of the measures data to fit with other data :
#dms.change_projection(dsr)
# get the expressions used by varglas :
Thickness = dbm.get_spline_expression('H')
Surface = dbm.get_spline_expression('h')
Bed = dbm.get_spline_expression('b')
SurfaceTemperature = dsr.get_spline_expression('T')
#BasalHeatFlux = dsr.get_spline_expression('q_geo')
BasalHeatFlux = dsq.get_spline_expression('q_geo')
#BasalHeatFlux = dfm.get_spline_expression('q_geo')
adot = dsr.get_spline_expression('adot')
U_observed = dsr.get_spline_expression('U_ob')
# inspect the data values :
do = DataOutput('results_pre/')
model = model.Model()
model.set_geometry(Surface, Bed)
model.set_mesh(mesh, flat_mesh=flat_mesh, deform=True)
model.set_parameters(pc.IceParameters())
#set_log_level(PROGRESS)
thklim = 200.0
# collect the raw data :
bamber = DataFactory.get_bamber(thklim = thklim)
# define the meshes :
mesh = Mesh('meshes/greenland_3D_5H.xml')
mesh.coordinates()[:,2] /= 100000.0
# create data objects to use with varglas :
dbm = DataInput(None, bamber, mesh=mesh)
# get the expressions used by varglas :
Surface = dbm.get_spline_expression('h')
Bed = dbm.get_spline_expression('b')
model = model.Model(out_dir = out_dir)
model.set_geometry(Surface, Bed)
model.set_mesh(mesh, deform=True)
model.set_parameters(pc.IceParameters())
model.initialize_variables()
parameters['form_compiler']['quadrature_degree'] = 2
File(in_dir + 'u.xml') >> model.u
File(in_dir + 'v.xml') >> model.v
File(in_dir + 'w.xml') >> model.w
File(in_dir + 'beta2.xml') >> model.beta2
File(in_dir + 'eta.xml') >> model.eta
