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 __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 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
