import src.physical_constants as pc
from data.data_factory import DataFactory
from pylab import *
from gmshpy import *
from scipy.interpolate import RectBivariateSpline
from src.utilities import DataInput
from scipy.io import loadmat
#===============================================================================
# data preparation :
thklim = 200.0
# collect the raw data :
bamber = DataFactory.get_bamber(thklim = thklim)
searise = DataFactory.get_searise(thklim = thklim)
#meas_shf = DataFactory.get_shift_gre_measures()
#dbv = DataInput("../results/", ("Ubmag_measures.mat", "Ubmag.mat"),
# gen_space=False)
dsr = DataInput(None, searise, gen_space=False)
dbm = DataInput(None, bamber, gen_space=False)
#dmss = DataInput(None, meas_shf, gen_space=False)
#dbv.set_data_min('Ubmag', 0.0, 0.0)
#dbv.set_data_max('Ubmag', 500.0, 500.0)
dsr.change_projection(dbm)
dsr.set_data_min('U_ob', 0.0, 0.0)
dsr.set_data_max('U_ob', 400.0, 400.0)
from data.data_factory import DataFactory
from src.utilities import DataInput, DataOutput
from src.helper import *
from dolfin import *
from time import time
out_dir = './stress_balance_stokes_5H/'
in_dir = './results_stokes_5H/03/'
set_log_active(True)
#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)
import sys
import os
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput, MeshGenerator
from data.data_factory import DataFactory
# create meshgrid for contour :
vara = DataFactory.get_bamber()
H = vara['H']['map_data']
S = vara['h']['map_data']
B = vara['b']['map_data']
H[S <= 0] = 0.0
vara['H']['map_data'] = H
# process the data :
dd = DataInput(None, vara, flip=False, gen_space=False)
#dd.set_data_max('mask', 2, 0)
m = MeshGenerator(dd, 'mesh', './')
# 20 works well for the last arg. below
m.create_contour('H', 200.0, 3)
m.plot_contour()
m.eliminate_intersections()
m.plot_contour()
# 10000 works well on the following line
m.write_gmsh_contour(1000)
import sys
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput,DataOutput
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
from src.physics import VelocityBalance_2
from dolfin import Mesh, set_log_active
set_log_active(True)
thklim = 50.0
bedmap1 = DataFactory.get_bedmap1(thklim=thklim)
bedmap2 = DataFactory.get_bedmap2(thklim=thklim)
# load a mesh :
mesh = Mesh("meshes/2dmesh.xml")
db1 = DataInput(None, bedmap1, mesh=mesh)
db2 = DataInput(None, bedmap2, mesh=mesh)
h = db2.get_projection("h_n")
H = db2.get_projection("H_n")
adot = db1.get_projection("adot")
prb = VelocityBalance_2(mesh, H, h, adot, 12.0)
prb.solve_forward()
# File ouput
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput,DataOutput
from data.data_factory import DataFactory
from src.physics import VelocityBalance_2
from numpy import sqrt
from pylab import *
from dolfin import *
from scipy.optimize import fmin_l_bfgs_b
import os
set_log_active(True)
# collect the raw data :
searise = DataFactory.get_searise()
measure = DataFactory.get_gre_measures()
bamber = DataFactory.get_bamber()
direc = os.path.dirname(os.path.realpath(__file__))
# load a mesh :
mesh = Mesh("./mesh_5km.xml")
# create data objects to use with varglas :
dsr = DataInput(None, searise, mesh=mesh)
dbam = DataInput(None, bamber, mesh=mesh)
dms = DataInput(None, measure, mesh=mesh, flip=True)
dms.change_projection(dsr)
# Bound data to managable values
import sys
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput, DataOutput
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
from src.physics import VelocityBalance_2
from dolfin import Mesh, set_log_active
set_log_active(True)
thklim = 50.0
bedmap1 = DataFactory.get_bedmap1(thklim=thklim)
bedmap2 = DataFactory.get_bedmap2(thklim=thklim)
# load a mesh :
mesh = Mesh("meshes/2dmesh.xml")
db1 = DataInput(None, bedmap1, mesh=mesh)
db2 = DataInput(None, bedmap2, mesh=mesh)
h = db2.get_projection("h_n")
H = db2.get_projection("H_n")
adot = db1.get_projection("adot")
prb = VelocityBalance_2(mesh, H, h, adot, 12.0)
prb.solve_forward()
# File ouput
import sys
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput,DataOutput
from data.data_factory import DataFactory
from src.physics import VelocityBalance_2
from dolfin import Mesh, set_log_active
from plot.plothelp.plotting import plotIce
import os
set_log_active(True)
# collect the raw data :
searise = DataFactory.get_searise()
measure = DataFactory.get_gre_measures()
#bamber = DataFactory.get_bamber()
direc = os.path.dirname(os.path.realpath(__file__))
# load a mesh :
mesh = Mesh("../meshes/mesh.xml")
# create data objects to use with varglas :
dsr = DataInput(None, searise, mesh=mesh, create_proj=True)
#dbm = DataInput(None, bamber, mesh=mesh)
dms = DataInput(None, measure, mesh=mesh, create_proj=True, flip=True)
dms.change_projection(dsr)
dsr.set_data_min('H', 10.0, 10.0)
import sys
src_directory = '../../../'
sys.path.append(src_directory)
import src.model as model
import src.solvers as solvers
import src.physical_constants as pc
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
from src.helper import default_nonlin_solver_params
from src.utilities import DataInput
from dolfin import *
set_log_active(True)
var_measures = DataFactory.get_ant_measures()
var_bedmap1 = DataFactory.get_lebrocq()
var_bedmap2 = DataFactory.get_bedmap2()
mesh = MeshFactory.get_antarctica_coarse()
flat_mesh = MeshFactory.get_antarctica_coarse()
dm = DataInput(None, var_measures, mesh=mesh,flip=True)
db1 = DataInput(None, var_bedmap1, mesh=mesh)
db2 = DataInput(None, var_bedmap2, mesh=mesh, flip=True)
thklim = 50.0
db2.set_data_min("H", thklim, thklim)
db2.set_data_min("h", 0.0,0.0)
import sys
import os
src_directory = '../../../'
sys.path.append(src_directory)
from pylab import *
from dolfin import *
from src.utilities import DataInput, DataOutput
from src.physics import VelocityBalance_2
from plot.plothelp.plotting import plotIce
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
set_log_level(PROGRESS)
bm1 = DataFactory.get_lebrocq()
bm2 = DataFactory.get_bedmap2()
direc = os.path.dirname(os.path.realpath(__file__))
mesh = Mesh("../meshes/mesh.xml")
# Import data :
d1 = DataInput(None, bm1, mesh=mesh)
d3 = DataInput(None, bm2, mesh=mesh, flip=True)
# set minimum values for data :
d3.set_data_val("H", 32767, 10.0)
d3.set_data_val("h", 32767, 0.0)
d3.set_data_val("mask", 127, 1.0)
sys.path.append(src_directory)
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
from src.utilities import DataInput
from src.model import Model
from src.solvers import SteadySolver, TransientSolver
from src.physical_constants import IceParameters
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']
import sys
import os
src_directory = '../../../'
sys.path.append(src_directory)
from pylab import *
from dolfin import *
from src.utilities import DataInput, DataOutput
from src.physics import VelocityBalance_2
from plot.plothelp.plotting import plotIce
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
set_log_level(PROGRESS)
bm1 = DataFactory.get_bedmap1()
bm2 = DataFactory.get_bedmap2()
direc = os.path.dirname(os.path.realpath(__file__))
mesh = Mesh("../meshes/mesh.xml")
# Import data :
d1 = DataInput(None, bm1, mesh=mesh)
d3 = DataInput(None, bm2, mesh=mesh, flip=True)
# set minimum values for data :
d3.set_data_val("H", 32767, 10.0)
d3.set_data_val("h", 32767, 0.0)
d3.set_data_val("mask", 127, 1.0)
from src.helper import default_nonlin_solver_params
from src.utilities import DataInput, DataOutput
from dolfin import *
from pylab import sqrt, copy
from time import time
# make the directory if needed :
out_dir = './test_results/'
set_log_active(True)
#set_log_level(PROGRESS)
thklim = 200.0
# collect the raw data :
searise = DataFactory.get_searise(thklim = thklim)
measure = DataFactory.get_gre_measures()
meas_shf = DataFactory.get_shift_gre_measures()
bamber = DataFactory.get_bamber(thklim = thklim)
fm_qgeo = DataFactory.get_gre_qgeo_fox_maule()
sec_qgeo = DataFactory.get_gre_qgeo_secret()
# define the meshes :
mesh = Mesh('meshes/mesh_high_new.xml')
flat_mesh = Mesh('meshes/mesh_high_new.xml')
#mesh = Mesh('meshes/mesh_low.xml')
#flat_mesh = Mesh('meshes/mesh_low.xml')
mesh.coordinates()[:,2] /= 100000.0
flat_mesh.coordinates()[:,2] /= 100000.0
# get the input args : i = int(sys.argv[2]) # assimilation number dir_b = sys.argv[1] + '/0' # directory to save # set the output directory : out_dir = dir_b + str(i) + '/' set_log_active(True) #set_log_level(PROGRESS) thklim = 200.0 # collect the raw data : searise = DataFactory.get_searise(thklim = thklim) bamber = DataFactory.get_bamber(thklim = thklim) fm_qgeo = DataFactory.get_gre_qgeo_fox_maule() #measure = DataFactory.get_gre_measures() rignot = DataFactory.get_gre_rignot() # define the mesh : mesh = MeshFactory.get_greenland_coarse() # 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) dfm = DataInput(None, fm_qgeo, mesh=mesh) drg = DataInput(None, rignot, mesh=mesh)
import sys
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput,DataOutput
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
from src.physics import VelocityBalance_2
from dolfin import Mesh, set_log_active
set_log_active(True)
thklim = 20.0
# collect the raw data :
searise = DataFactory.get_searise()
measure = DataFactory.get_gre_measures()
meas_shf = DataFactory.get_shift_gre_measures()
bamber = DataFactory.get_bamber(thklim = thklim)
# load a mesh :
mesh = Mesh("results/meshes/refined_mesh.xml")
# 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)
dms.change_projection(dsr)
from src.helper import default_nonlin_solver_params
from src.utilities import DataInput, DataOutput
from dolfin import *
from pylab import sqrt, copy
from time import time
# make the directory if needed :
out_dir = './results/'
set_log_active(True)
#set_log_level(PROGRESS)
thklim = 10.0
# collect the raw data :
searise = DataFactory.get_searise(thklim = thklim)
bamber = DataFactory.get_bamber(thklim = thklim)
fm_qgeo = DataFactory.get_gre_qgeo_fox_maule()
# define the meshes :
mesh = Mesh('../../../meshes/greenland/greenland_coarse_mesh.xml')
flat_mesh = Mesh('../../../meshes/greenland/greenland_coarse_mesh.xml')
mesh.coordinates()[:,2] /= 1000.0
flat_mesh.coordinates()[:,2] /= 1000.0
# create data objects to use with varglas :
dsr = DataInput(None, searise, mesh=mesh)
dbm = DataInput(None, bamber, mesh=mesh)
dfm = DataInput(None, fm_qgeo, mesh=mesh)
from src.helper import default_nonlin_solver_params
from src.utilities import DataInput, DataOutput
from dolfin import *
from pylab import sqrt, copy
from time import time
# make the directory if needed :
out_dir = './test_results/'
set_log_active(True)
#set_log_level(PROGRESS)
thklim = 200.0
# collect the raw data :
searise = DataFactory.get_searise(thklim=thklim)
measure = DataFactory.get_gre_measures()
meas_shf = DataFactory.get_shift_gre_measures()
bamber = DataFactory.get_bamber(thklim=thklim)
fm_qgeo = DataFactory.get_gre_qgeo_fox_maule()
sec_qgeo = DataFactory.get_gre_qgeo_secret()
# define the meshes :
mesh = Mesh('meshes/mesh_high_new.xml')
flat_mesh = Mesh('meshes/mesh_high_new.xml')
#mesh = Mesh('meshes/mesh_low.xml')
#flat_mesh = Mesh('meshes/mesh_low.xml')
mesh.coordinates()[:, 2] /= 100000.0
flat_mesh.coordinates()[:, 2] /= 100000.0
# create data objects to use with varglas :
import sys
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput, DataOutput
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
from src.physics import VelocityBalance_2
from dolfin import Mesh, set_log_active
set_log_active(True)
thklim = 20.0
# collect the raw data :
searise = DataFactory.get_searise()
measure = DataFactory.get_gre_measures()
meas_shf = DataFactory.get_shift_gre_measures()
bamber = DataFactory.get_bamber(thklim=thklim)
# load a mesh :
mesh = Mesh("results/meshes/refined_mesh.xml")
# 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)
dms.change_projection(dsr)
import sys
import os
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput, MeshGenerator
from data.data_factory import DataFactory
# create meshgrid for contour :
vara = DataFactory.get_bedmap2()
# process the data :
dd = DataInput(None, vara, flip=True, gen_space=False)
#dd.set_data_max('mask', 2, 0)
m = MeshGenerator(dd, 'mesh', '../meshes/')
m.create_contour('mask', 0.999, 100)
m.plot_contour()
m.eliminate_intersections()
m.write_gmsh_contour(10000.)
m.finish()
import os
src_directory = '../../../../'
sys.path.append(src_directory)
from src.utilities import DataInput, MeshGenerator, MeshRefiner
from data.data_factory import DataFactory
from pylab import *
#===============================================================================
# data preparation :
thklim = 0.0
# collect the raw data :
bamber = DataFactory.get_bamber(thklim = thklim)
searise = DataFactory.get_searise(thklim = thklim)
dsr = DataInput(None, searise, gen_space=False)
dbm = DataInput(None, bamber, gen_space=False)
#===============================================================================
# generate the contour :
m = MeshGenerator(dbm, 'mesh', '')
m.create_contour('H', zero_cntr=200.0, skip_pts=2)
m.eliminate_intersections(dist=40)
#m.plot_contour()
m.write_gmsh_contour(boundary_extend=False)
m.extrude(h=100000, n_layers=10)
import sys
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput,DataOutput
from data.data_factory import DataFactory
from src.physics import VelocityBalance_2
from dolfin import Mesh, set_log_active
from plot.plothelp.plotting import plotIce
import os
set_log_active(True)
# collect the raw data :
searise = DataFactory.get_searise()
measure = DataFactory.get_gre_measures()
#bamber = DataFactory.get_bamber()
direc = os.path.dirname(os.path.realpath(__file__))
# load a mesh :
mesh = Mesh("../meshes/mesh.xml")
# create data objects to use with varglas :
dsr = DataInput(None, searise, mesh=mesh, create_proj=True)
#dbm = DataInput(None, bamber, mesh=mesh)
dms = DataInput(None, measure, mesh=mesh, create_proj=True, flip=True)
dms.change_projection(dsr)
dsr.set_data_min('H', 10.0, 10.0)
#set_log_level(DEBUG)
# output directory :
i = int(sys.argv[1])
dir_b = './results_shelves/0'
# make the directory if needed :
out_dir = dir_b + str(i) + '/'
d = os.path.dirname(out_dir)
if not os.path.exists(d):
os.makedirs(d)
thklim = 200.0
measures = DataFactory.get_ant_measures(res=900)
bedmap1 = DataFactory.get_bedmap1(thklim=thklim)
bedmap2 = DataFactory.get_bedmap2(thklim=thklim)
mesh = Mesh('meshes/mesh_low.xml')
flat_mesh = Mesh('meshes/mesh_low.xml')
#mesh.coordinates()[:,2] /= 100000.0
#flat_mesh.coordinates()[:,2] /= 100000.0
dm = DataInput(None, measures, mesh=mesh)
db1 = DataInput(None, bedmap1, mesh=mesh)
db2 = DataInput(None, bedmap2, mesh=mesh)
db2.set_data_val('H', 32767, thklim)
db2.set_data_val('h', 32767, 0.0)
from src.helper import default_nonlin_solver_params
from src.utilities import DataInput, DataOutput
from dolfin import *
from pylab import sqrt, copy
from time import time
# make the directory if needed :
out_dir = './results/'
set_log_active(True)
#set_log_level(PROGRESS)
thklim = 10.0
# collect the raw data :
searise = DataFactory.get_searise(thklim = thklim)
measure = DataFactory.get_gre_measures()
#meas_shf = DataFactory.get_shift_gre_measures()
bamber = DataFactory.get_bamber(thklim = thklim)
fm_qgeo = DataFactory.get_gre_qgeo_fox_maule()
#sec_qgeo = DataFactory.get_gre_qgeo_secret()
merged = DataFactory.get_gre_merged()
# define the meshes :
mesh = Mesh('../../../meshes/greenland/greenland_coarse_mesh.xml')
flat_mesh = Mesh('../../../meshes/greenland/greenland_coarse_mesh.xml')
mesh.coordinates()[:,2] /= 1000.0
flat_mesh.coordinates()[:,2] /= 1000.0
# create data objects to use with varglas :
src_directory = '../../../'
sys.path.append(src_directory)
import src.model as model
import src.solvers as solvers
import src.physical_constants as pc
from data.data_factory import DataFactory
from meshes.mesh_factory import MeshFactory
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()
import sys
import os
src_directory = '../../../'
sys.path.append(src_directory)
from src.utilities import DataInput, MeshGenerator
from data.data_factory import DataFactory
# create meshgrid for contour :
vara = DataFactory.get_bamber()
H = vara['H']['map_data']
S = vara['h']['map_data']
B = vara['b']['map_data']
H[S<=0] = 0.0
vara['H']['map_data'] = H
# process the data :
dd = DataInput(None, vara, flip=False, gen_space=False)
#dd.set_data_max('mask', 2, 0)
m = MeshGenerator(dd, 'mesh', './')
# 20 works well for the last arg. below
m.create_contour('H', 200.0,3)
m.plot_contour()
m.eliminate_intersections()
m.plot_contour()
# 10000 works well on the following line
m.write_gmsh_contour(1000)
from data.data_factory import DataFactory
from src.utilities import DataInput, DataOutput
from src.helper import *
from dolfin import *
from time import time
out_dir = './stress_balance_stokes_5H/'
in_dir = './results_stokes_5H/03/'
set_log_active(True)
#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)
