def __init__(self, param_name): self.Param = Parameters() #Since these parameters are more related to the numeric part #rather than physics we choose to set a default value in order to #avoid problems in case they will not present in the file self.Param.add("Polynomial_degree", 1) self.Param.add("Number_vertices_x", 80) self.Param.add("Number_vertices_y", 160) self.Param.add("Log_Level", 21) #more than INFO level by default self.Param.add("Reinit_Type", 'Non_Conservative_Hyperbolic') self.Param.add("Stabilization_Type", 'SUPG') self.Param.add("NS_Procedure", 'ICT') self.Param.add("Interface_Thickness", 0.025) self.Param.add("Stabilization_Parameter", 0.01) self.Param.add("Reference_Dimensionalization", 'Dimensional') self.Param.add("Settings_Type", 'Physical') self.Param.add("Maximum_subiters_recon", 10) self.Param.add("Tolerance_recon", 1.0e-4) self.Param.add("Saving_Frequency", 50) self.Param.add("Reinitialization_Frequency", 1) self.Param.add("Saving_Directory", 'Sim') self.Param.add("Interface_Perturbation_RT", 'Cos') self.Param.add("Problem", 'Bubble') try: self.file = open(param_name, "r") except IOError: print( "Input parameter file '" + param_name + "' not found. Creating a default one (based on the rising bubble benchmark)" ) f = open(param_name, "w") f.write("Gravity = 0.98\n") f.write("Surface_tension = 1.96\n") f.write("Lighter_density = 1.0\n") f.write("Heavier_density = 1000.0\n") f.write("Viscosity_lighter_fluid = 1.0\n") f.write("Viscosity_heavier_fluid = 10.0\n") f.write("Time_step = 0.0008\n") f.write("End_time = 3.0\n") f.write("Base = 1.0\n") f.write("Height = 2.0\n") f.write("x_center = 0.5\n") f.write("y_center = 0.5\n") f.write("Radius = 0.25\n") f.close() self.file = open(param_name, "r") try: self.parse_parameters(self.file) #Close the file self.file.close() except Exception as e: print("Caught an exception: " + str(e))
def __init__(self, parameters=None, solver="ipcs"): "Create Navier-Stokes problem" self.parameters = Parameters("problem_parameters") # Create solver if solver == "taylor-hood": info("Using Taylor-Hood based Navier-Stokes solver") self.solver = TaylorHoodSolver(self) elif solver == "ipcs": info("Using IPCS based Navier-Stokes solver") self.solver = NavierStokesSolver(self) else: error("Unknown Navier--Stokes solver: %s" % solver) # Set up parameters self.parameters.add(self.solver.parameters)
def __init__(self, mesh, FE_phi, FE_chi, FE_v, FE_p, FE_th=None, constrained_domain=None): """ Initialize :py:data:`Discretization.parameters` and store given arguments for later setup. :param mesh: computational mesh :type mesh: :py:class:`dolfin.Mesh` :param FE_phi: finite element for discretization of order parameters :type FE_phi: :py:class:`dolfin.FiniteElement` :param FE_chi: finite element for discretization of chemical potentials :type FE_chi: :py:class:`dolfin.FiniteElement` :param FE_v: finite element for discretization of velocity components :type FE_v: :py:class:`dolfin.FiniteElement` :param FE_p: finite element for discretization of pressure :type FE_p: :py:class:`dolfin.FiniteElement` :param FE_th: finite element for discretization of temperature :type FE_th: :py:class:`dolfin.FiniteElement` :param constrained_domain: constrained subdomain with map function (for specification of periodic boundaries) :type constrained_domain: :py:class:`dolfin.SubDomain` """ # Initialize parameters self.parameters = Parameters(mpset["discretization"]) # Create R space on the given mesh self._R = FunctionSpace(mesh, "R", 0) # can be used to define constants # Store attributes self._mesh = mesh self._varnames = ("phi", "chi", "v", "p", "th") self._FE = dict() for var in self._varnames: self._FE[var] = eval("FE_" + var) self._subspace = {} self._ndofs = {} self._test_fcns = {} self._trial_fcns = {} self._constrained_domain = constrained_domain
def default_parameters(): "Return default values for solver parameters." p = Parameters("solver_parameters") p.add("solve_primal", True) p.add("solve_dual", True) p.add("estimate_error", True) p.add("plot_solution", False) p.add("save_solution", True) p.add("save_series", True) p.add("uniform_timestep", False) p.add("uniform_mesh", False) p.add("dorfler_marking", True) p.add("global_storage", False) p.add("structure_element_degree", 1) p.add("max_num_refinements", 100) p.add("tolerance", 0.001) p.add("fixedpoint_tolerance", 1e-12) p.add("initial_timestep", 0.05) p.add("num_initial_refinements", 0) p.add("maximum_iterations", 1000) p.add("num_smoothings", 50) p.add("w_h", 0.45) p.add("w_k", 0.45) p.add("w_c", 0.1) p.add("marking_fraction", 0.5) p.add("refinement_algorithm", "regular_cut") p.add("crossed_mesh", False) p.add("output_directory", "unspecified") p.add("description", "unspecified") return p
class NavierStokes(CBCProblem): "Base class for all Navier-Stokes problems" def __init__(self, parameters=None, solver="ipcs"): "Create Navier-Stokes problem" self.parameters = Parameters("problem_parameters") # Create solver if solver == "taylor-hood": info("Using Taylor-Hood based Navier-Stokes solver") self.solver = TaylorHoodSolver(self) elif solver == "ipcs": info("Using IPCS based Navier-Stokes solver") self.solver = NavierStokesSolver(self) else: error("Unknown Navier--Stokes solver: %s" % solver) # Set up parameters self.parameters.add(self.solver.parameters) def solve(self): "Solve and return computed solution (u, p)" # Update solver parameters self.solver.parameters.update(self.parameters["solver_parameters"]) # Call solver return self.solver.solve() def step(self, dt): "Make a time step of size dt" # Update solver parameters self.solver.parameters.update(self.parameters["solver_parameters"]) # Call solver return self.solver.step(dt) def update(self, t): "Propagate values to next time step" return self.solver.update(t) def solution(self): "Return current solution values" return self.solver.solution() def solution_values(self): "Return solution values at t_{n-1} and t_n" return self.solver.solution_values() #--- Functions that must be overloaded by subclasses --- def mesh(self): "Return mesh" missing_function("mesh") #--- Functions that may optionally be overloaded by subclasses --- def density(self): "Return density" return 1.0 def viscosity(self): "Return viscosity" return 1.0 def body_force(self, V): "Return body force f" return [] def boundary_traction(self, V): "Return boundary traction g = sigma(u, p) * n" return [] def mesh_velocity(self, V): "Return mesh velocity (for ALE formulations)" w = Constant((0,)*V.mesh().geometry().dim()) return w def boundary_conditions(self, V, Q): "Return boundary conditions for velocity and pressure" return [], [] def velocity_dirichlet_values(self): "Return Dirichlet boundary values for the velocity" return [] def velocity_dirichlet_boundaries(self): "Return Dirichlet boundaries for the velocity" return [] def pressure_dirichlet_values(self): "Return Dirichlet boundary conditions for the velocity" return [] def pressure_dirichlet_boundaries(self): "Return Dirichlet boundaries for the velocity" return [] def velocity_initial_condition(self): "Return initial condition for velocity" return None def pressure_initial_condition(self): "Return initial condition for pressure" return 0 def end_time(self): "Return end time" return 1.0 def time_step(self): "Return preferred time step" return None def max_velocity(self): "Return maximum velocity (used for selecting time step)" return 1.0 def __str__(self): "Return a short description of the problem" return "Navier-Stokes problem"
def default_parameters(): "Return default values for solver parameters." p = Parameters("solver_parameters"); p.add("solve_primal", True) p.add("solve_dual", True) p.add("estimate_error", True) p.add("plot_solution", False) p.add("save_solution", True) p.add("save_series", True) p.add("uniform_timestep", False) p.add("uniform_mesh", False) p.add("dorfler_marking", True) p.add("global_storage", False) p.add("structure_element_degree", 1) p.add("max_num_refinements", 100) p.add("tolerance", 0.001) p.add("fixedpoint_tolerance", 1e-12) p.add("initial_timestep", 0.05) p.add("num_initial_refinements", 0) p.add("maximum_iterations", 1000) p.add("num_smoothings", 50) p.add("w_h", 0.45) p.add("w_k", 0.45) p.add("w_c", 0.1) p.add("marking_fraction", 0.5) p.add("refinement_algorithm", "regular_cut") p.add("crossed_mesh", False) p.add("output_directory", "unspecified") p.add("description", "unspecified") return p
def __init__(self, name="muflon-parameters"): """ Create and initialize an instance of :py:class:`dolfin.Parameters` which is treated as *singleton*. :param name: name of the parameter set :type name: str """ # Initialize dolfin's Parameters super(MuflonParameterSet, self).__init__(name) # Helper variables for admissible parameter values _trunc_types = ["none", "minmax", "clamp_soft", "clamp_hard"] # Discretization nested_prm = Parameters("discretization") nested_prm.add("N", 2, 2, 7) nested_prm.add("PTL", 1, 1, 2) self.add(nested_prm) # Model parameters mobility_prm = Parameters("mobility") mobility_prm.add("M0", 1.0) mobility_prm.add("m", 0) mobility_prm.add("beta", 0.0, 0.0, 1.0) mobility_prm.add("cut", False) char_quants = Parameters("chq") char_quants.add("L", 1.0) char_quants.add("V", 1.0) char_quants.add("rho", 1.0) nested_prm = Parameters("model") nested_prm.add("doublewell", "Poly4", ["Poly4"]) # "MoYo" nested_prm.add("eps", 1.0) nested_prm.add(mobility_prm) nested_prm.add(Parameters("nu")) nested_prm["nu"].add("itype", "har", ["lin", "har"]) nested_prm["nu"].add("trunc", "none", _trunc_types) nested_prm.add(Parameters("rho")) nested_prm["rho"].add("itype", "lin", ["lin", "har"]) nested_prm["rho"].add("trunc", "none", _trunc_types) nested_prm.add(Parameters("sigma")) nested_prm.add(char_quants) self.add(nested_prm)
class NavierStokes(CBCProblem): "Base class for all Navier-Stokes problems" def __init__(self, parameters=None, solver="ipcs"): "Create Navier-Stokes problem" self.parameters = Parameters("problem_parameters") # Create solver if solver == "taylor-hood": info("Using Taylor-Hood based Navier-Stokes solver") self.solver = TaylorHoodSolver(self) elif solver == "ipcs": info("Using IPCS based Navier-Stokes solver") self.solver = NavierStokesSolver(self) else: error("Unknown Navier--Stokes solver: %s" % solver) # Set up parameters self.parameters.add(self.solver.parameters) def solve(self): "Solve and return computed solution (u, p)" # Update solver parameters self.solver.parameters.update(self.parameters["solver_parameters"]) # Call solver return self.solver.solve() def step(self, dt): "Make a time step of size dt" # Update solver parameters self.solver.parameters.update(self.parameters["solver_parameters"]) # Call solver return self.solver.step(dt) def update(self, t): "Propagate values to next time step" return self.solver.update(t) def solution(self): "Return current solution values" return self.solver.solution() def solution_values(self): "Return solution values at t_{n-1} and t_n" return self.solver.solution_values() #--- Functions that must be overloaded by subclasses --- def mesh(self): "Return mesh" missing_function("mesh") #--- Functions that may optionally be overloaded by subclasses --- def density(self): "Return density" return 1.0 def viscosity(self): "Return viscosity" return 1.0 def body_force(self, V): "Return body force f" return [] def boundary_traction(self, V): "Return boundary traction g = sigma(u, p) * n" return [] def mesh_velocity(self, V): "Return mesh velocity (for ALE formulations)" w = Constant((0, ) * V.mesh().geometry().dim()) return w def boundary_conditions(self, V, Q): "Return boundary conditions for velocity and pressure" return [], [] def velocity_dirichlet_values(self): "Return Dirichlet boundary values for the velocity" return [] def velocity_dirichlet_boundaries(self): "Return Dirichlet boundaries for the velocity" return [] def pressure_dirichlet_values(self): "Return Dirichlet boundary conditions for the velocity" return [] def pressure_dirichlet_boundaries(self): "Return Dirichlet boundaries for the velocity" return [] def velocity_initial_condition(self): "Return initial condition for velocity" return None def pressure_initial_condition(self): "Return initial condition for pressure" return 0 def end_time(self): "Return end time" return 1.0 def time_step(self): "Return preferred time step" return None def max_velocity(self): "Return maximum velocity (used for selecting time step)" return 1.0 def __str__(self): "Return a short description of the problem" return "Navier-Stokes problem"
class My_Parameters: """Class constructor which reads or eventually creates the file with parameters and instantiates the FENICS Parameter class""" def __init__(self, param_name): self.Param = Parameters() #Since these parameters are more related to the numeric part #rather than physics we choose to set a default value in order to #avoid problems in case they will not present in the file self.Param.add("Polynomial_degree", 1) self.Param.add("Number_vertices_x", 80) self.Param.add("Number_vertices_y", 160) self.Param.add("Log_Level", 21) #more than INFO level by default self.Param.add("Reinit_Type", 'Non_Conservative_Hyperbolic') self.Param.add("Stabilization_Type", 'SUPG') self.Param.add("NS_Procedure", 'ICT') self.Param.add("Interface_Thickness", 0.025) self.Param.add("Stabilization_Parameter", 0.01) self.Param.add("Reference_Dimensionalization", 'Dimensional') self.Param.add("Settings_Type", 'Physical') self.Param.add("Maximum_subiters_recon", 10) self.Param.add("Tolerance_recon", 1.0e-4) self.Param.add("Saving_Frequency", 50) self.Param.add("Reinitialization_Frequency", 1) self.Param.add("Saving_Directory", 'Sim') self.Param.add("Interface_Perturbation_RT", 'Cos') self.Param.add("Problem", 'Bubble') try: self.file = open(param_name, "r") except IOError: print( "Input parameter file '" + param_name + "' not found. Creating a default one (based on the rising bubble benchmark)" ) f = open(param_name, "w") f.write("Gravity = 0.98\n") f.write("Surface_tension = 1.96\n") f.write("Lighter_density = 1.0\n") f.write("Heavier_density = 1000.0\n") f.write("Viscosity_lighter_fluid = 1.0\n") f.write("Viscosity_heavier_fluid = 10.0\n") f.write("Time_step = 0.0008\n") f.write("End_time = 3.0\n") f.write("Base = 1.0\n") f.write("Height = 2.0\n") f.write("x_center = 0.5\n") f.write("y_center = 0.5\n") f.write("Radius = 0.25\n") f.close() self.file = open(param_name, "r") try: self.parse_parameters(self.file) #Close the file self.file.close() except Exception as e: print("Caught an exception: " + str(e)) """Parse parameters file into the standard FENICS Parameters class""" def parse_parameters(self, param_file): for line in param_file.read().splitlines(): if line.strip(): #Avoid reading blank lines idx_eq = line.find(' = ') if (idx_eq != -1): if (line[0:idx_eq] in self.Param.keys()): self.Param[line[0:idx_eq]] = type( self.Param[line[0:idx_eq]])(line[idx_eq + 3:]) else: self.Param.add(line[0:idx_eq], line[idx_eq + 3:]) else: raise Exception("Invalid format to read parameters. \ Please check the configuration file: \ you need a space before and after the equal" ) """Return the standard FENICS Parameters class""" def get_param(self): return self.Param
""" ascot specific parameters """ __author__ = "Marie E. Rognes ([email protected])" __license__ = "GNU LGPL version 3 or any later version" from dolfin import Parameters ascot_parameters = Parameters("ascot") ascot_parameters.add("eps", 1.e-05) ascot_parameters.add("magic_rate", 0.1) ascot_parameters.add("only_stable", False) ascot_parameters.add("check_continuity", False) ascot_parameters.add("inf", 1.e10) ascot_parameters.add("number_of_eigenvalues", 1) # Eigensolver parameters for the different conditions: bip = Parameters("brezzi_infsup") bip.add("solver", "krylov-schur") bip.add("spectral_transform", "shift-and-invert") bip.add("spectrum", "target magnitude") bip.add("spectral_shift", -0.1) bcp = Parameters("brezzi_coercivity") bcp.add("solver", "lapack") bab = Parameters("babuska") bab.add("solver", "krylov-schur") bab.add("spectral_transform", "shift-and-invert") bab.add("spectral_shift", 1.e-06)
def default_fsinewtonsolver_parameters(): p = Parameters("FSINewtonSolver") #Fluid velocity vf = Parameters("V_F") vf.add("deg",2) vf.add("elem","CG") p.add(vf) #Optional fluid velocity enrichment space for mini element #In two dimension use Bubble 3 element, in 3 dimensions Bubble 4. bf = Parameters("B_F") bf.add("deg","None") bf.add("elem","None") p.add(bf) #Fluid pressure qf = Parameters("Q_F") qf.add("deg",1) qf.add("elem","CG") p.add(qf) #Velocity Lagrange multiplier mu = Parameters("M_U") mu.add("deg",0) mu.add("elem","DG") p.add(mu) #Structure displacement cs = Parameters("C_S") cs.add("deg",1) cs.add("elem","CG") p.add(cs) #Structure velocity vs = Parameters("V_S") vs.add("deg",1) vs.add("elem","CG") p.add(vs) #Fluid domain displacement cf = Parameters("C_F") cf.add("deg",1) cf.add("elem","CG") p.add(cf) #Displacement Lagrange Multiplier md = Parameters("M_D") md.add("deg",0) md.add("elem","DG") p.add(md) p.add("solve",True) #Local plotting and storage by the FSINewtonSolver p.add("store",False) p.add("plot",False) rndata = Parameters("runtimedata") rndata.add("fsisolver","False") rndata.add("newtonsolver","False") p.add(rndata) #Time schemes #This parameter refers to how the fluid domain mapping is #time discretized in the Navier Stokes equation p.add("fluid_domain_time_discretization","end-point") #Alternative is "mid-point" #Run time optimization opt = Parameters("optimization") opt.add("reuse_jacobian",True) opt.add("simplify_jacobian",False) opt.add("max_reuse_jacobian",30) opt.add("reduce_quadrature",0) #0 means no reduction, i >0 means reduce to order i. p.add(opt) p.add("jacobian","buff") # "manual", "auto", "buff" p.add("newtonitrmax",100) ################################## #This parameter is only necessary for the problem class NewtonFSI p.add("newtonsoltol",1.0e-13) ################################## p.add("bigblue",False) return p
def default_parameters(): "Return default values for solver parameters." p = Parameters("solver_parameters"); p.add("solve_primal", True) p.add("primal_solver", "Newton") #Newton or fixpoint p.add("solve_dual", True) p.add("estimate_error", True) p.add("plot_solution", False) p.add("save_solution", True) p.add("save_series", True) p.add("uniform_timestep", False) p.add("uniform_mesh", False) p.add("dorfler_marking", True) p.add("global_storage", False) p.add("structure_element_degree", 1) p.add("mesh_element_degree", 1) p.add("max_num_refinements", 100) p.add("tolerance", 0.001) p.add("iteration_tolerance", 1e-12) p.add("initial_timestep", 0.05) p.add("num_initial_refinements", 0) p.add("maximum_iterations", 1000) p.add("num_smoothings", 50) p.add("w_h", 0.45) p.add("w_k", 0.45) p.add("w_c", 0.1) p.add("marking_fraction", 0.5) p.add("refinement_algorithm", "regular_cut") p.add("crossed_mesh", False) p.add("use_exact_solution", False) p.add("output_directory", "unspecified") p.add("description", "unspecified") p.add(default_fsinewtonsolver_parameters()) # Hacks p.add("fluid_solver", "ipcs") # q = Parameters("dualsolver") q.add("timestepping","FE") #CG1 BE or FE q.add("fluid_domain_time_discretization","end-point") p.add(q) return p
def _init_parameters(): """ .. _tab_tsprm: ==================== ============= =================================== TimeStepping \ \ parameters ------------------------------------------------------------------------ Option Suboption Description ==================== ============= =================================== --xdmf \ .folder name of the folder for XDMF files \ .flush flush output of XDMF files \ .modulo modulo for saving results \ .iconds whether to save initial conditions ==================== ============= =================================== """ prm = Parameters("time-stepping") nested_prm = Parameters("xdmf") nested_prm.add("folder", "XDMFdata") nested_prm.add("flush", False) nested_prm.add("modulo", 1) nested_prm.add("iconds", True) prm.add(nested_prm) return prm