def prepare_inputs_for_forward_model(k):
''' make directory to run the fowrard model in, copy across the input files and
modify the time step in flml so the forward model will run just for one time step'''
# make a directory to run the code in and copy across input files
cwd = os.getcwd()
input_file_name = "fwd_model.flml"
# print "files in cwd"
# for files in os.listdir(cwd):
# print files
if not os.path.isdir( str(k) ):
print "attempting to mkdir"
os.mkdir(str(k))
os.system('cp *.msh ' + str(k))
os.system('cp *_' +str(k)+ '_checkpoint* ' + str(k))
os.chdir(str(k))
# modify the checkpoint file times
for files in os.listdir('./'):
# get the name of the checkpoint flml
if files.endswith(str(k)+"_checkpoint.flml"):
# pos = files.rfind('.')
checkpoint_file_name = files
# print "checkpoint fname", checkpoint_file_name
# load options from checkpoint file
libspud.load_options(checkpoint_file_name)
# change the name of the output
libspud.set_option('/simulation_name','2d_canyon')
# change the final time so it runs from t_k to t_k+1 only
t0 = libspud.get_option('/timestepping/current_time')
dt = libspud.get_option('/timestepping/timestep')
libspud.set_option('/timestepping/finish_time',t0+dt)
# could check with vtu's that these are the correct times
# rename input file
libspud.write_options(input_file_name)
libspud.clear_options()
os.chdir(cwd)
return input_file_name
try:
libspud.add_option('/foo')
except libspud.SpudNewKeyWarning, e:
print "caught libspud.SpudNewKeyWarning: " + e.message
print libspud.option_count('/foo')
libspud.set_option('/problem_type', 'helloworld')
print libspud.get_option('/problem_type')
try:
libspud.set_option_attribute('/foo/bar', 'foobar')
except libspud.SpudNewKeyWarning, e:
print "caught libspud.SpudNewKeyWarning: " + e.message
print libspud.get_option('/foo/bar')
libspud.delete_option('/foo')
print libspud.option_count('/foo')
try:
libspud.get_option('/foo')
except libspud.SpudKeyError, e:
print "caught libspud.SpudKeyError: " + e.message
try:
libspud.get_option('/geometry')
except libspud.SpudTypeError, e:
print "caught libspud.SpudTypeError: " + e.message
libspud.write_options('test_out.flml')
def data_assimilation(opal_options):
global Model_updated, iter_count
# functions used within data_assimilation: J() and gradJ()
def J(v):
global Model_updated, iter_count
iter_count = iter_count + 1
vT = np.transpose(v)
vTv = np.dot(vT,v)
Vv = np.dot(V,v)
HVv = np.dot(H,Vv)
# we need the model results - check if these are already available, if not, run the forward model with Vv as the input
if Model_updated:
print "in J(): using pre-exiting forward model model solution"
Model_updated = False
else:
print "in J(): updating the forward model solution"
# prepare directory and input files for forward model
input_file_name = prepare_inputs_for_forward_model(k)
# modify initial condition of tracer
field = modify_initial_conditions_at_tk(k,Vv)
# run forward model
run_forward_model_tk(k,opal_options.executable,input_file_name)
Model_updated = True
# retrieve the forward model results, MVv
path_to_vtu_file = str(k) + '/2d_canyon_1.vtu'
vtu_data = vtktools.vtu(path_to_vtu_file)
MVv = vtu_data.GetScalarField(field)
# print "J(): MVv[0:10]", MVv[0:10]
##MVv = np.dot(M,Vv)
HMVv = np.dot(H,MVv)
Jmis = np.subtract(HVv,d)
JmisM = np.subtract(HMVv,d)
invR = np.linalg.inv(R)
JmisT = np.transpose(Jmis)
JmisMT = np.transpose(JmisM)
RJmis = np.dot(invR,JmisT)
RJmisM = np.dot(invR,JmisMT)
J1 = np.dot(Jmis,RJmis)
JM1 = np.dot(JmisM,RJmisM)
Jv = (vTv + J1 + JM1) / 2
return Jv
###############################################
####### GRADIENT OF J ########
###############################################
def gradJ(v):
global Model_updated
Vv = np.dot(V,v)
HVv = np.dot(H,Vv)
# CODE COPIED FROM J() ###########################################
# we need the model results - check if these are already available,
# if not, run the forward model with Vv as the input
if Model_updated:
print "in gradJ(): using pre-exiting forward model model solution"
Model_updated = False
else:
print "in gradJ(): updating the forward model solution"
# prepare directory and input files for forward model
input_file_name = prepare_inputs_for_forward_model(k)
# modify initial condition of tracer
field = modify_initial_conditions_at_tk(k,Vv)
# run forward model
run_forward_model_tk(k,opal_options.executable,input_file_name)
Model_updated = True
# END OF CODE COPIED FROM J() ###########################################
# MVv = np.dot(M,Vv)
# retrieve the forward model results, MVv
path_to_vtu_file = str(k) + '/2d_canyon_1.vtu'
vtu_data = vtktools.vtu(path_to_vtu_file)
MVv = vtu_data.GetScalarField('Tracer') #vtu_data.GetScalarField(field)
# print "gradJ: MVv[0:10]", MVv[0:10]
HMVv = np.dot(H,MVv)
Jmis = np.subtract(HVv,d)
JmisM = np.subtract(HMVv,d)
invR = np.linalg.inv(R)
RJmis = np.dot(invR,Jmis)
RJmisM = np.dot(invR,JmisM)
HT = np.transpose(H)
g1 = np.dot(HT,RJmis)
g1M = np.dot(HT,RJmisM)
##MT = ... MT(g1M) = from importance map t_k+1 , map at t_k
VT = np.transpose(V)
##VTMT = np.dot(VT,MT)
g2 = np.dot(VT,g1)
ggJ = v + g2 ##+ VTMT
return ggJ
#print "exectuable which has been selected:", opal_options.executable
# ......... read the input .........
###############################################
## TRUNCATION AND REGULARIZATION PARAMETERS ###
###############################################
# inputs
n = 852
lam = 1 #REGULARIZATION PARAMETER
m = 45 #TRUNCATION PARAMETER FROM buildV.py
xB = np.ones(n)
y = np.ones(n)
k = 8 # time at which observation is known
###############################################
######## INTIAL RUN OF FLUIDITY #############
###############################################
# put checkpointing on for file k
print "name of fwd_input_file", opal_options.data_assimilation.fwd_input_file
libspud.load_options('2d_canyon.flml')#(opal_options.data_assimilation.fwd_input_file)
# don't need these currently
if libspud.have_option('io/checkpointing/checkpoint_at_start'):
libspud.delete_option('io/checkpointing/checkpoint_at_start')
if libspud.have_option('io/checkpointing/checkpoint_at_end'):
libspud.delete_option('io/checkpointing/checkpoint_at_end')
if libspud.have_option('io/checkpointing/checkpoint_period_in_dumps'):
libspud.set_option('io/checkpointing/checkpoint_period_in_dumps',k)
else:
print "checkpoint_period_in_dumps option missing from xml file"
sys.exit(0)
libspud.write_options(opal_options.data_assimilation.fwd_input_file)
libspud.clear_options()
string = opal_options.executable + " " + opal_options.data_assimilation.fwd_input_file
# run code which will checkpoint every "k" dumps at the moment....
print string
os.system(string)
###############################################
######## COVARIANCE MATRICES #############
###############################################
V = np.loadtxt('matrixVprec'+str(m)+'.txt', usecols=range(m))
R = lam * 0.5 * np.identity(n)
H = np.identity(n)
###############################################
####### FROM PHYSICAL TO CONTROL SPACE ########
###############################################
x0 = np.ones(n)
Vin = np.linalg.pinv(V)
v0 = np.dot(Vin,x0)
###############################################
####### COMPUTE THE MISFIT ########
###############################################
VT = np.transpose(V)
HxB = np.dot(H,xB)
# consider multiple observations later - just one for now
d = np.subtract(y,HxB)
###############################################
####### COMPUTE THE MINIMUM OF J ########
###############################################
t = time.time()
iter_count = 0
Model_updated = False
res = minimize(J, v0, method='L-BFGS-B', jac=gradJ,
options={'disp': True})
###############################################
####### FROM CONTROL TO PHYSICAL SPACE ########
###############################################
vDA = np.array([])
vDA = res.x
deltaxDA = np.dot(V,vDA)
xDA = xB + deltaxDA
elapsed = time.time() - t
print " iter_count", iter_count
#return
###############################################
####### PRECONDITIONED COST FUNCTION J ########
###############################################
return
def gen_flmls(params, template_dir, output_dir, paths, names, verbose):
import types
# get flml file from template_dir - first one we come across
# If you have more in there, tough.
full_flml = glob.glob(os.path.join(template_dir, '*.flml'))[0]
# strip to the filename only
flml = os.path.basename(full_flml)
f = open(os.path.join(output_dir, 'runs', "directory_listing.csv"), "w")
# append data to directory listing file
line = "Directory number"
for n in names:
line = line + "," + n
line = line + "\n"
f.write(line)
# loop over paramas
# create a new directory, with a unqiue number, starting from 1
# This makes it easier to use in an array job on CX1
dir_num = 1
for p_set in params:
if (verbose):
print "Processing " + str(dir_num)
# copy contents from template folder to directory number
dirname = os.path.join(output_dir, 'runs', str(dir_num))
if (os.path.exists(os.path.join(dirname))):
shutil.rmtree(dirname)
shutil.copytree(template_dir, dirname)
# open FLML file
output_file = os.path.join(dirname, flml)
# This load the data into the memory of the libspud library
libspud.load_options(output_file)
i = 0
for path in paths:
path = path.strip()
# get type
path_type = libspud.get_option_type(path)
path_rank = libspud.get_option_rank(path)
path_shape = libspud.get_option_shape(path)
if (path_type is float and path_rank == 0):
libspud.set_option(path, float(p_set[i]))
elif (path_rank == 1 and path_type is float):
value = eval(p_set[i])
val = list(map(float, value))
libspud.set_option(path, val)
elif (path_rank == 2 and path_type is float):
value = eval(p_set[i])
val = []
for row in value:
val.append(list(map(float, row)))
libspud.set_option(path, val)
i = i + 1
# save file
libspud.write_options(output_file)
# append data to directory listing file
line = str(dir_num)
for p in p_set:
# quoting the params so csv parsers can get the columns right
line = line + "," + '"' + str(p) + '"'
line = line + "\n"
f.write(line)
dir_num += 1
f.close()
def convert(fluidity_options_file_path, ff_options_file_path):
# Read in Fluidity simulation options
libspud.clear_options()
libspud.load_options(fluidity_options_file_path)
# Simulation name
simulation_name = libspud.get_option("/simulation_name")
# Geometry
base = "/geometry"
dimension = libspud.get_option(base + "/dimension")
mesh_path = libspud.get_option(
base + "/mesh::CoordinateMesh/from_file/file_name"
) + ".msh" # FIXME: Always assumes gmsh format.
# Function spaces
velocity_function_space = FunctionSpace("/geometry", 1)
freesurface_function_space = FunctionSpace("/geometry", 2)
# Timestepping
base = "/timestepping"
current_time = libspud.get_option(base + "/current_time")
timestep = libspud.get_option(base + "/timestep")
finish_time = libspud.get_option(base + "/finish_time")
## Steady-state
if (libspud.have_option(base + "/steady_state")):
if (libspud.have_option(base + "/steady_state/tolerance")):
steady_state = libspud.get_option(base + "/steady_state/tolerance")
else:
steady_state = 1e-7
else:
steady_state = None
# I/O
base = "/io"
dump_format = libspud.get_option(base + "/dump_format")
if (libspud.have_option(base + "/dump_period")):
dump_period = libspud.get_option(base + "/dump_period/constant")
elif (libspud.have_option(base + "/dump_period_in_timesteps")):
dump_period = libspud.get_option(
base + "/dump_period_in_timesteps/constant") * timestep
else:
print "Unable to obtain dump_period."
sys.exit()
# Gravity
g_magnitude = libspud.get_option("/physical_parameters/gravity/magnitude")
# Velocity field (momentum equation)
base = "/material_phase[0]/vector_field::Velocity"
## Depth (free surface mean height)
c = libspud.get_child_name(
base +
"/prognostic/equation::ShallowWater/scalar_field::BottomDepth/prescribed/value::WholeMesh/",
1)
depth = libspud.get_option(
base +
"/prognostic/equation::ShallowWater/scalar_field::BottomDepth/prescribed/value::WholeMesh/%s"
% c)
## Bottom drag coefficient
if (libspud.have_option(base +
"/prognostic/equation::ShallowWater/bottom_drag")):
c = libspud.get_child_name(
base +
"/prognostic/equation::ShallowWater/bottom_drag/scalar_field::BottomDragCoefficient/prescribed/value::WholeMesh/",
1)
bottom_drag = libspud.get_option(
base +
"/prognostic/equation::ShallowWater/bottom_drag/scalar_field::BottomDragCoefficient/prescribed/value::WholeMesh/%s"
% c)
else:
bottom_drag = None
## Viscosity
if (libspud.have_option(base + "/prognostic/tensor_field::Viscosity")):
viscosity = libspud.get_option(
base +
"/prognostic/tensor_field::Viscosity/prescribed/value::WholeMesh/anisotropic_symmetric/constant"
)[0][0]
else:
viscosity = None
## Momentum source
if (libspud.have_option(base + "/prognostic/vector_field::Source")):
c = libspud.get_child_name(
base +
"/prognostic/vector_field::Source/prescribed/value::WholeMesh/", 1)
momentum_source = libspud.get_option(
base +
"/prognostic/vector_field::Source/prescribed/value::WholeMesh/%s" %
c)
else:
momentum_source = None
## Initial condition
if (libspud.have_option(base +
"/prognostic/initial_condition::WholeMesh")):
c = libspud.get_child_name(
base + "/prognostic/initial_condition::WholeMesh/", 1)
velocity_initial_condition = libspud.get_option(
base + "/prognostic/initial_condition::WholeMesh/%s" % c)
else:
velocity_initial_condition = 0.0
## Boundary conditions
number_of_bcs = libspud.option_count(base +
"/prognostic/boundary_conditions")
velocity_bcs = []
for i in range(number_of_bcs):
velocity_bcs.append(
VelocityBoundaryCondition(base +
"/prognostic/boundary_conditions[%d]" %
i))
# Pressure field (continuity equation)
base = "/material_phase[0]/scalar_field::Pressure"
integrate_by_parts = libspud.have_option(
base +
"/prognostic/spatial_discretisation/continuous_galerkin/integrate_continuity_by_parts"
)
## Initial condition
if (libspud.have_option(base +
"/prognostic/initial_condition::WholeMesh")):
c = libspud.get_child_name(
base + "/prognostic/initial_condition::WholeMesh/", 1)
pressure_initial_condition = libspud.get_option(
base + "/prognostic/initial_condition::WholeMesh/%s" % c)
else:
pressure_initial_condition = 0.0
## Boundary conditions
number_of_bcs = libspud.option_count(base +
"/prognostic/boundary_conditions")
pressure_bcs = []
for i in range(number_of_bcs):
pressure_bcs.append(
PressureBoundaryCondition(base +
"/prognostic/boundary_conditions[%d]" %
i))
## Continuity source
if (libspud.have_option(base + "/prognostic/scalar_field::Source")):
c = libspud.get_child_name(
base +
"/prognostic/scalar_field::Source/prescribed/value::WholeMesh/", 1)
continuity_source = libspud.get_option(
base +
"/prognostic/scalar_field::Source/prescribed/value::WholeMesh/%s" %
c)
else:
continuity_source = None
# Write out to a Firedrake-Fluids simulation configuration file
libspud.clear_options()
# Create a bare-bones .swml file to add to.
f = open(ff_options_file_path, "w")
f.write("<?xml version='1.0' encoding='utf-8'?>\n")
f.write("<shallow_water_options>\n")
f.write("</shallow_water_options>\n")
f.close()
libspud.load_options(ff_options_file_path)
# Simulation name
libspud.set_option("/simulation_name", simulation_name)
# Geometry
base = "/geometry"
libspud.set_option(base + "/dimension", dimension)
libspud.set_option(base + "/mesh/from_file/relative_path", mesh_path)
# Function spaces
base = "/function_spaces"
libspud.set_option(base + "/function_space::VelocityFunctionSpace/degree",
velocity_function_space.degree)
libspud.set_option(base + "/function_space::VelocityFunctionSpace/family",
velocity_function_space.family)
libspud.set_option(
base + "/function_space::FreeSurfaceFunctionSpace/degree",
freesurface_function_space.degree)
libspud.set_option(
base + "/function_space::FreeSurfaceFunctionSpace/family",
freesurface_function_space.family)
# I/O
base = "/io"
libspud.set_option(base + "/dump_format", dump_format)
libspud.set_option(base + "/dump_period", dump_period)
# Timestepping
base = "/timestepping"
print timestep
libspud.set_option(base + "/current_time", current_time)
try:
libspud.set_option(base + "/timestep", timestep)
except:
pass
libspud.set_option(base + "/finish_time", finish_time)
## Steady-state
if (steady_state):
libspud.set_option(base + "/steady_state/tolerance", steady_state)
# Gravity
libspud.set_option("/physical_parameters/gravity/magnitude", g_magnitude)
# System/Core Fields: Velocity
base = "/system/core_fields/vector_field::Velocity"
## Initial condition
if (isinstance(velocity_initial_condition, str)):
libspud.set_option(base + "/initial_condition/python",
velocity_initial_condition)
else:
libspud.set_option(base + "/initial_condition/constant",
velocity_initial_condition)
## Boundary conditions
try:
for i in range(len(velocity_bcs)):
libspud.set_option(
base +
"/boundary_condition::%s/surface_ids" % velocity_bcs[i].name,
velocity_bcs[i].surface_ids)
libspud.set_option_attribute(
base +
"/boundary_condition::%s/type/name" % velocity_bcs[i].name,
velocity_bcs[i].type)
if (velocity_bcs[i].type == "dirichlet"):
if (isinstance(velocity_bcs[i].value, str)):
libspud.set_option(
base +
"/boundary_condition::%s/type::dirichlet/value/python"
% velocity_bcs[i].name, velocity_bcs[i].value)
else:
libspud.set_option(
base +
"/boundary_condition::%s/type::dirichlet/value/constant"
% velocity_bcs[i].name, velocity_bcs[i].value)
except:
pass
# System/Core Fields: FreeSurfacePerturbation
base = "/system/core_fields/scalar_field::FreeSurfacePerturbation"
#FIXME: Pressure initial and boundary conditions are multiplied by 'g' in Fluidity, but not in Firedrake-Fluids.
## Initial condition
if (isinstance(pressure_initial_condition, str)):
libspud.set_option(base + "/initial_condition/python",
pressure_initial_condition)
else:
libspud.set_option(base + "/initial_condition/constant",
pressure_initial_condition)
## Boundary conditions
try:
for i in range(len(pressure_bcs)):
libspud.set_option(
base +
"/boundary_condition::%s/surface_ids" % pressure_bcs[i].name,
pressure_bcs[i].surface_ids)
libspud.set_option(
base +
"/boundary_condition::%s/type/name" % pressure_bcs[i].name,
pressure_bcs[i].type)
if (pressure_bcs[i].type == "dirichlet"):
if (isinstance(pressure_bcs[i].value, str)):
libspud.set_option(
base +
"/boundary_condition::%s/type::dirichlet/value/python"
% pressure_bcs[i].name, pressure_bcs[i].value)
else:
libspud.set_option(
base +
"/boundary_condition::%s/type::dirichlet/value/constant"
% pressure_bcs[i].name, pressure_bcs[i].value)
except:
pass
# System/Core Fields: FreeSurfaceMean
base = "/system/core_fields/scalar_field::FreeSurfaceMean"
if (isinstance(depth, str)):
libspud.set_option(base + "/value/python", depth)
else:
libspud.set_option(base + "/value/constant", depth)
# Equations: Continuity equation
base = "/system/equations/continuity_equation"
libspud.set_option(base + "/integrate_by_parts", integrate_by_parts)
## Source term
if (continuity_source is not None):
if (isinstance(continuity_source, str)):
libspud.set_option(
base + "/source_term/scalar_field::Source/value/python",
continuity_source)
else:
libspud.set_option(
base + "/source_term/scalar_field::Source/value/constant",
continuity_source)
# Equations: Momentum equation
base = "/system/equations/momentum_equation"
## Viscosity
if (viscosity is not None):
if (isinstance(viscosity, str)):
libspud.set_option(
base + "/stress_term/scalar_field::Viscosity/value/python",
viscosity)
else:
libspud.set_option(
base + "/stress_term/scalar_field::Viscosity/value/constant",
viscosity)
## Bottom drag
if (bottom_drag is not None):
if (isinstance(bottom_drag, str)):
libspud.set_option(
base +
"/drag_term/scalar_field::BottomDragCoefficient/value/python",
bottom_drag)
else:
libspud.set_option(
base +
"/drag_term/scalar_field::BottomDragCoefficient/value/constant",
bottom_drag)
## Source term
if (momentum_source is not None):
if (isinstance(momentum_source, str)):
libspud.set_option(
base + "/source_term/vector_field::Source/value/python",
momentum_source)
else:
libspud.set_option(
base + "/source_term/vector_field::Source/value/constant",
momentum_source)
# Write all the applied options to file.
libspud.write_options(ff_options_file_path)
return
libspud.delete_option('/foo')
assert libspud.option_count('/foo') == 0
try:
libspud.get_option('/foo')
assert False
except libspud.SpudKeyError, e:
pass
try:
libspud.get_option('/geometry')
assert False
except libspud.SpudTypeError, e:
pass
libspud.write_options('test_out.flml')
try:
libspud.set_option('/test', 4.3)
except libspud.SpudNewKeyWarning, e:
pass
assert libspud.get_option('/test') == 4.3
libspud.set_option('/test',4)
assert libspud.get_option('/test') == 4
libspud.set_option('/test',[[4.0,2.0,3.0],[2.0,5.0,6.6]])
assert libspud.get_option('/test') == [[4.0,2.0,3.0],[2.0,5.0,6.6]]
def gen_flmls(params, template_dir, output_dir, paths, names, verbose):
import types
# get flml file from template_dir - first one we come across
# If you have more in there, tough.
full_flml = glob.glob(os.path.join(template_dir,'*.flml'))[0]
# strip to the filename only
flml = os.path.basename(full_flml)
f = open(os.path.join(output_dir,'runs',"directory_listing.csv"),"w")
# append data to directory listing file
line = "Directory number"
for n in names:
line = line+","+n
line = line + "\n"
f.write(line)
# loop over paramas
# create a new directory, with a unqiue number, starting from 1
# This makes it easier to use in an array job on CX1
dir_num = 1
for p_set in params:
if (verbose):
print "Processing "+str(dir_num)
# copy contents from template folder to directory number
dirname = os.path.join(output_dir,'runs',str(dir_num))
if (os.path.exists(os.path.join(dirname))):
shutil.rmtree(dirname)
shutil.copytree(template_dir,dirname)
# open FLML file
output_file = os.path.join(dirname,flml)
# This load the data into the memory of the libspud library
libspud.load_options(output_file)
i = 0
for path in paths:
path = path.strip()
# get type
path_type = libspud.get_option_type(path)
path_rank = libspud.get_option_rank(path)
path_shape = libspud.get_option_shape(path)
if (path_type is float and path_rank == 0):
libspud.set_option(path,float(p_set[i]))
elif (path_rank == 1 and path_type is float):
value = eval(p_set[i])
val = list(map(float, value))
libspud.set_option(path,val)
elif (path_rank == 2 and path_type is float):
value = eval(p_set[i])
val = []
for row in value:
val.append(list(map(float, row)))
libspud.set_option(path,val)
i = i+1
# save file
libspud.write_options(output_file)
# append data to directory listing file
line = str(dir_num)
for p in p_set:
# quoting the params so csv parsers can get the columns right
line = line+","+'"'+str(p)+'"'
line = line +"\n"
f.write(line)
dir_num += 1
f.close()
libspud.set_option('/problem_type', 'helloworld')
test("libspud.get_option('/problem_type') == 'helloworld'")
exception_test("libspud.set_option_attribute('/foo/bar', 'foobar')",
libspud.SpudNewKeyWarning)
test("libspud.get_option('/foo/bar') == 'foobar'")
libspud.delete_option('/foo')
test("libspud.option_count('/foo') == 0")
exception_test("libspud.get_option('/foo')", libspud.SpudKeyError)
exception_test("libspud.get_option('/geometry')", libspud.SpudTypeError)
libspud.write_options(dirpath + 'test_out.flml')
exception_test("libspud.set_option('/test', 4.3)", libspud.SpudNewKeyWarning)
test("libspud.get_option('/test') == 4.3")
test("libspud.set_option('/test',4) or True")
test("libspud.get_option('/test') == 4")
libspud.set_option('/test', [[4.0, 2.0, 3.0], [2.0, 5.0, 6.6]])
test("libspud.get_option('/test') == [[4.0,2.0,3.0],[2.0,5.0,6.6]]")
libspud.set_option('/test', "Hallo")
test("libspud.get_option('/test') == 'Hallo'")
import libspud
import shutil
class flml_things:
"list of things to change in an flml file"
def __init__(self,name='',mesh='',dt=0.2):
self.name = name
self.dt = dt
self.mesh = mesh
parent_file = 'diffusion_dg1'
diffusion_dg_A = flml_things(name='diffusion_dg_A',mesh='MMS_A',dt=0.2)
diffusion_dg_B = flml_things(name='diffusion_dg_B',mesh='MMS_B',dt=0.2)
diffusion_dg_C = flml_things(name='diffusion_dg_C',mesh='MMS_C',dt=0.2)
diffusion_dg_D = flml_things(name='diffusion_dg_D',mesh='MMS_D',dt=0.2)
diffusion_dg_E = flml_things(name='diffusion_dg_E',mesh='MMS_E',dt=0.2)
filelist = [diffusion_dg_A,diffusion_dg_B,diffusion_dg_C,diffusion_dg_D,diffusion_dg_E]
for file in filelist:
shutil.copy(parent_file+'.flml',file.name+'.flml')
libspud.load_options(file.name+'.flml')
libspud.set_option('/simulation_name', file.name)
libspud.set_option('/geometry/mesh[@name="CoordinateMesh"]/from_file/file_name', file.mesh)
libspud.set_option('/timestepping/timestep', file.dt)
libspud.write_options(file.name+'.flml')
def convert(fluidity_options_file_path, ff_options_file_path):
# Read in Fluidity simulation options
libspud.clear_options()
libspud.load_options(fluidity_options_file_path)
# Simulation name
simulation_name = libspud.get_option("/simulation_name")
# Geometry
base = "/geometry"
dimension = libspud.get_option(base + "/dimension")
mesh_path = libspud.get_option(base + "/mesh::CoordinateMesh/from_file/file_name") + ".msh" # FIXME: Always assumes gmsh format.
# Function spaces
velocity_function_space = FunctionSpace("/geometry", 1)
freesurface_function_space = FunctionSpace("/geometry", 2)
# Timestepping
base = "/timestepping"
current_time = libspud.get_option(base + "/current_time")
timestep = libspud.get_option(base + "/timestep")
finish_time = libspud.get_option(base + "/finish_time")
## Steady-state
if(libspud.have_option(base + "/steady_state")):
if(libspud.have_option(base + "/steady_state/tolerance")):
steady_state = libspud.get_option(base + "/steady_state/tolerance")
else:
steady_state = 1e-7
else:
steady_state = None
# I/O
base = "/io"
dump_format = libspud.get_option(base + "/dump_format")
if(libspud.have_option(base + "/dump_period")):
dump_period = libspud.get_option(base + "/dump_period/constant")
elif(libspud.have_option(base + "/dump_period_in_timesteps")):
dump_period = libspud.get_option(base + "/dump_period_in_timesteps/constant")*timestep
else:
print "Unable to obtain dump_period."
sys.exit()
# Gravity
g_magnitude = libspud.get_option("/physical_parameters/gravity/magnitude")
# Velocity field (momentum equation)
base = "/material_phase[0]/vector_field::Velocity"
## Depth (free surface mean height)
c = libspud.get_child_name(base + "/prognostic/equation::ShallowWater/scalar_field::BottomDepth/prescribed/value::WholeMesh/", 1)
depth = libspud.get_option(base + "/prognostic/equation::ShallowWater/scalar_field::BottomDepth/prescribed/value::WholeMesh/%s" % c)
## Bottom drag coefficient
if(libspud.have_option(base + "/prognostic/equation::ShallowWater/bottom_drag")):
c = libspud.get_child_name(base + "/prognostic/equation::ShallowWater/bottom_drag/scalar_field::BottomDragCoefficient/prescribed/value::WholeMesh/", 1)
bottom_drag = libspud.get_option(base + "/prognostic/equation::ShallowWater/bottom_drag/scalar_field::BottomDragCoefficient/prescribed/value::WholeMesh/%s" % c)
else:
bottom_drag = None
## Viscosity
if(libspud.have_option(base + "/prognostic/tensor_field::Viscosity")):
viscosity = libspud.get_option(base + "/prognostic/tensor_field::Viscosity/prescribed/value::WholeMesh/anisotropic_symmetric/constant")[0][0]
else:
viscosity = None
## Momentum source
if(libspud.have_option(base + "/prognostic/vector_field::Source")):
c = libspud.get_child_name(base + "/prognostic/vector_field::Source/prescribed/value::WholeMesh/", 1)
momentum_source = libspud.get_option(base + "/prognostic/vector_field::Source/prescribed/value::WholeMesh/%s" % c)
else:
momentum_source = None
## Initial condition
if(libspud.have_option(base + "/prognostic/initial_condition::WholeMesh")):
c = libspud.get_child_name(base + "/prognostic/initial_condition::WholeMesh/", 1)
velocity_initial_condition = libspud.get_option(base + "/prognostic/initial_condition::WholeMesh/%s" % c)
else:
velocity_initial_condition = 0.0
## Boundary conditions
number_of_bcs = libspud.option_count(base + "/prognostic/boundary_conditions")
velocity_bcs = []
for i in range(number_of_bcs):
velocity_bcs.append(VelocityBoundaryCondition(base + "/prognostic/boundary_conditions[%d]" % i))
# Pressure field (continuity equation)
base = "/material_phase[0]/scalar_field::Pressure"
integrate_by_parts = libspud.have_option(base + "/prognostic/spatial_discretisation/continuous_galerkin/integrate_continuity_by_parts")
## Initial condition
if(libspud.have_option(base + "/prognostic/initial_condition::WholeMesh")):
c = libspud.get_child_name(base + "/prognostic/initial_condition::WholeMesh/", 1)
pressure_initial_condition = libspud.get_option(base + "/prognostic/initial_condition::WholeMesh/%s" % c)
else:
pressure_initial_condition = 0.0
## Boundary conditions
number_of_bcs = libspud.option_count(base + "/prognostic/boundary_conditions")
pressure_bcs = []
for i in range(number_of_bcs):
pressure_bcs.append(PressureBoundaryCondition(base + "/prognostic/boundary_conditions[%d]" % i))
## Continuity source
if(libspud.have_option(base + "/prognostic/scalar_field::Source")):
c = libspud.get_child_name(base + "/prognostic/scalar_field::Source/prescribed/value::WholeMesh/", 1)
continuity_source = libspud.get_option(base + "/prognostic/scalar_field::Source/prescribed/value::WholeMesh/%s" % c)
else:
continuity_source = None
# Write out to a Firedrake-Fluids simulation configuration file
libspud.clear_options()
# Create a bare-bones .swml file to add to.
f = open(ff_options_file_path, "w")
f.write("<?xml version='1.0' encoding='utf-8'?>\n")
f.write("<shallow_water_options>\n")
f.write("</shallow_water_options>\n")
f.close()
libspud.load_options(ff_options_file_path)
# Simulation name
libspud.set_option("/simulation_name", simulation_name)
# Geometry
base = "/geometry"
libspud.set_option(base + "/dimension", dimension)
libspud.set_option(base + "/mesh/from_file/relative_path", mesh_path)
# Function spaces
base = "/function_spaces"
libspud.set_option(base + "/function_space::VelocityFunctionSpace/degree", velocity_function_space.degree)
libspud.set_option(base + "/function_space::VelocityFunctionSpace/family", velocity_function_space.family)
libspud.set_option(base + "/function_space::FreeSurfaceFunctionSpace/degree", freesurface_function_space.degree)
libspud.set_option(base + "/function_space::FreeSurfaceFunctionSpace/family", freesurface_function_space.family)
# I/O
base = "/io"
libspud.set_option(base + "/dump_format", dump_format)
libspud.set_option(base + "/dump_period", dump_period)
# Timestepping
base = "/timestepping"
print timestep
libspud.set_option(base + "/current_time", current_time)
try:
libspud.set_option(base + "/timestep", timestep)
except:
pass
libspud.set_option(base + "/finish_time", finish_time)
## Steady-state
if(steady_state):
libspud.set_option(base + "/steady_state/tolerance", steady_state)
# Gravity
libspud.set_option("/physical_parameters/gravity/magnitude", g_magnitude)
# System/Core Fields: Velocity
base = "/system/core_fields/vector_field::Velocity"
## Initial condition
if(isinstance(velocity_initial_condition, str)):
libspud.set_option(base + "/initial_condition/python", velocity_initial_condition)
else:
libspud.set_option(base + "/initial_condition/constant", velocity_initial_condition)
## Boundary conditions
try:
for i in range(len(velocity_bcs)):
libspud.set_option(base + "/boundary_condition::%s/surface_ids" % velocity_bcs[i].name, velocity_bcs[i].surface_ids)
libspud.set_option_attribute(base + "/boundary_condition::%s/type/name" % velocity_bcs[i].name, velocity_bcs[i].type)
if(velocity_bcs[i].type == "dirichlet"):
if(isinstance(velocity_bcs[i].value, str)):
libspud.set_option(base + "/boundary_condition::%s/type::dirichlet/value/python" % velocity_bcs[i].name, velocity_bcs[i].value)
else:
libspud.set_option(base + "/boundary_condition::%s/type::dirichlet/value/constant" % velocity_bcs[i].name, velocity_bcs[i].value)
except:
pass
# System/Core Fields: FreeSurfacePerturbation
base = "/system/core_fields/scalar_field::FreeSurfacePerturbation"
#FIXME: Pressure initial and boundary conditions are multiplied by 'g' in Fluidity, but not in Firedrake-Fluids.
## Initial condition
if(isinstance(pressure_initial_condition, str)):
libspud.set_option(base + "/initial_condition/python", pressure_initial_condition)
else:
libspud.set_option(base + "/initial_condition/constant", pressure_initial_condition)
## Boundary conditions
try:
for i in range(len(pressure_bcs)):
libspud.set_option(base + "/boundary_condition::%s/surface_ids" % pressure_bcs[i].name, pressure_bcs[i].surface_ids)
libspud.set_option(base + "/boundary_condition::%s/type/name" % pressure_bcs[i].name, pressure_bcs[i].type)
if(pressure_bcs[i].type == "dirichlet"):
if(isinstance(pressure_bcs[i].value, str)):
libspud.set_option(base + "/boundary_condition::%s/type::dirichlet/value/python" % pressure_bcs[i].name, pressure_bcs[i].value)
else:
libspud.set_option(base + "/boundary_condition::%s/type::dirichlet/value/constant" % pressure_bcs[i].name, pressure_bcs[i].value)
except:
pass
# System/Core Fields: FreeSurfaceMean
base = "/system/core_fields/scalar_field::FreeSurfaceMean"
if(isinstance(depth, str)):
libspud.set_option(base + "/value/python", depth)
else:
libspud.set_option(base + "/value/constant", depth)
# Equations: Continuity equation
base = "/system/equations/continuity_equation"
libspud.set_option(base + "/integrate_by_parts", integrate_by_parts)
## Source term
if(continuity_source is not None):
if(isinstance(continuity_source, str)):
libspud.set_option(base + "/source_term/scalar_field::Source/value/python", continuity_source)
else:
libspud.set_option(base + "/source_term/scalar_field::Source/value/constant", continuity_source)
# Equations: Momentum equation
base = "/system/equations/momentum_equation"
## Viscosity
if(viscosity is not None):
if(isinstance(viscosity, str)):
libspud.set_option(base + "/stress_term/scalar_field::Viscosity/value/python", viscosity)
else:
libspud.set_option(base + "/stress_term/scalar_field::Viscosity/value/constant", viscosity)
## Bottom drag
if(bottom_drag is not None):
if(isinstance(bottom_drag, str)):
libspud.set_option(base + "/drag_term/scalar_field::BottomDragCoefficient/value/python", bottom_drag)
else:
libspud.set_option(base + "/drag_term/scalar_field::BottomDragCoefficient/value/constant", bottom_drag)
## Source term
if(momentum_source is not None):
if(isinstance(momentum_source, str)):
libspud.set_option(base + "/source_term/vector_field::Source/value/python", momentum_source)
else:
libspud.set_option(base + "/source_term/vector_field::Source/value/constant", momentum_source)
# Write all the applied options to file.
libspud.write_options(ff_options_file_path)
return