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
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 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__(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, 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 __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, 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)
""" 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