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