def assign_variable(self, u, var):
r"""
Manually assign the values from ``var`` to ``u``. The parameter ``var``
may be a string pointing to the location of an :class:`~dolfin.cpp.io.XDMFFile`,
:class:`~dolfin.cpp.io.HDF5File`, or an xml file.
:param u: FEniCS :class:`~dolfin.functions.function.Function` assigning to
:param var: value assigning from
:param annotate: allow ``dolfin_adjoint`` annotation
:type var: float, int, :class:`~dolfin.functions.expression.Expression`, :class:`~dolfin.functions.constant.Constant`, :class:`~dolfin.cpp.la.GenericVector`, string, :class:`~dolfin.cpp.io.HDF5File`, :class:`~numpy.ndarray`
:type u: :class:`~dolfin.functions.function.Function`, :class:`~dolfin.cpp.la.GenericVector`, :class:`~dolfin.Constant`, float, int
"""
# if this is a list, convert it to a numpy array :
if type(var) == list:
var = np.array(var)
if isinstance(var, float) or isinstance(var, int):
if isinstance(u, dl.GenericVector) or isinstance(u, dl.Function):
u.vector()[:] = var
elif isinstance(u, dl.Constant):
u.assign(var)
elif isinstance(u, float) or isinstance(u, int):
u = var
elif isinstance(var, np.ndarray):
if var.dtype != np.float64:
var = var.astype(np.float64)
u.vector().set_local(var)
u.vector().apply('insert')
elif isinstance(var, dl.Expression) \
or isinstance(var, dl.Constant) \
or isinstance(var, dl.Function) \
or isinstance(var, dl.GenericVector):
u.assign(var)
#u.interpolate(var, annotate=annotate)
#elif isinstance(var, GenericVector):
# self.assign_variable(u, var.array(), annotate=annotate)
elif isinstance(var, str):
File(var) >> u
elif isinstance(var, dl.HDF5File):
var.read(u, u.name())
else:
s = "*************************************************************\n" + \
"assign_variable() function requires a Function, array, float,\n" + \
" int, Vector, Expression, Constant, or string path to .xml,\n" + \
"not %s." + \
"*************************************************************"
print_text(s % type(var), 'red', 1)
if self.verbose:
print_min_max(u, u.name())
def update_mass(self, m):
r"""
Update the grid mass :math:`m_i`, ``self.m`` to parameter ``m``.
:param m: grid mass
:type m: :class:`~dolfin.functions.function.Function`,
"""
# assign the mass to the model variable :
self.assm.assign(self.m, m)
if self.verbose:
print_min_max(self.m, 'GridModel.m')
def update_internal_force_vector(self, f_int):
r"""
Update the grid acceleration :math:`\mathbf{f}_i^{\mathrm{int}} = [f_x^{\mathrm{int}}\ f_y^{\mathrm{int}}\ f_z^{\mathrm{int}}]^{\intercal}` to paramter ``f_int``.
:param f_int: grid internal force
:type f_int: list of :class:`~dolfin.functions.function.Function`\s
"""
# assign the variables to the functions :
self.assf_int_x.assign(self.f_int_x, f_int[0])
self.assf_int_y.assign(self.f_int_y, f_int[1])
if self.verbose:
print_min_max(f_int[0], 'GridModel.f_int_x')
print_min_max(f_int[1], 'GridModel.f_int_y')
def update_acceleration(self, a):
r"""
Update the grid acceleration :math:`\mathbf{a}_i = [a_x\ a_y\ a_z]^{\intercal}`, ``self.a3`` to parameter ``a``.
:param a: grid acceleration
:type a: list of :class:`~dolfin.functions.function.Function`\s
"""
# assign the variables to the functions :
self.assa_x.assign(self.a_x, a[0])
self.assa_y.assign(self.a_y, a[1])
if self.verbose:
print_min_max(a[0], 'GridModel.a_x')
print_min_max(a[1], 'GridModel.a_y')
def update_velocity(self, U):
r"""
Update the grid velocity :math:`\mathbf{u}_i = [u\ v\ w]^{\intercal}`, ``self.U3`` to parameter ``U``.
:param U: grid velocity
:type U: list of :class:`~dolfin.functions.function.Function`\s
"""
# assign the variables to the functions :
assign(self.u, U[0])
assign(self.v, U[1])
if self.verbose:
print_min_max(U[0], 'GridModel.u')
print_min_max(U[1], 'GridModel.v')
def retrieve_cpp_material_properties(self):
"""
Transfer material properties from C++ back to python for further analysis
with PyLab.
"""
# iterate through all materials :
for M in self.materials:
M.retrieve_cpp_vrt()
M.retrieve_cpp_phi()
M.retrieve_cpp_grad_phi()
M.retrieve_cpp_grad_u()
M.retrieve_cpp_x()
M.retrieve_cpp_u()
M.retrieve_cpp_a()
M.retrieve_cpp_F()
M.retrieve_cpp_epsilon()
M.retrieve_cpp_sigma()
M.retrieve_cpp_rho()
M.retrieve_cpp_V()
M.retrieve_cpp_V0()
if self.verbose:
print_min_max(M.grad_u, 'M.grad_u')
print_min_max(M.x, 'M.x')
print_min_max(M.u, 'M.u')
print_min_max(M.a, 'M.a')
print_min_max(M.F, 'M.F_0')
print_min_max(M.epsilon, 'M.epsilon_0')
print_min_max(M.sigma, 'M.sigma_0')
print_min_max(M.rho, 'M.rho_0')
print_min_max(M.V, 'M.V')
print_min_max(M.V0, 'M.V_0')