void testRestart()
{
SlitFunc slitfunc;
_mesh->write("slit_mesh.xda");
_es->write("slit_solution.xda",
EquationSystems::WRITE_DATA |
EquationSystems::WRITE_SERIAL_FILES);
Mesh mesh2(*TestCommWorld);
mesh2.read("slit_mesh.xda");
EquationSystems es2(mesh2);
es2.read("slit_solution.xda");
System & sys2 = es2.get_system<System> ("SimpleSystem");
unsigned int dim = 2;
CPPUNIT_ASSERT_EQUAL( sys2.n_vars(), 1u );
FEMContext context(sys2);
FEBase * fe = NULL;
context.get_element_fe( 0, fe, dim );
const std::vector<Point> & xyz = fe->get_xyz();
fe->get_phi();
MeshBase::const_element_iterator el =
mesh2.active_local_elements_begin();
const MeshBase::const_element_iterator end_el =
mesh2.active_local_elements_end();
for (; el != end_el; ++el)
{
const Elem * elem = *el;
context.pre_fe_reinit(sys2, elem);
context.elem_fe_reinit();
const unsigned int n_qp = xyz.size();
for (unsigned int qp=0; qp != n_qp; ++qp)
{
const Number exact_val = slitfunc(context, xyz[qp]);
const Number discrete_val = context.interior_value(0, qp);
CPPUNIT_ASSERT_DOUBLES_EQUAL(libmesh_real(exact_val),
libmesh_real(discrete_val),
TOLERANCE*TOLERANCE);
}
}
}
void testSystem()
{
SlitFunc slitfunc;
unsigned int dim = 2;
CPPUNIT_ASSERT_EQUAL( _sys->n_vars(), 1u );
FEMContext context(*_sys);
FEBase * fe = NULL;
context.get_element_fe( 0, fe, dim );
const std::vector<Point> & xyz = fe->get_xyz();
fe->get_phi();
MeshBase::const_element_iterator el =
_mesh->active_local_elements_begin();
const MeshBase::const_element_iterator end_el =
_mesh->active_local_elements_end();
for (; el != end_el; ++el)
{
const Elem * elem = *el;
context.pre_fe_reinit(*_sys, elem);
context.elem_fe_reinit();
const unsigned int n_qp = xyz.size();
for (unsigned int qp=0; qp != n_qp; ++qp)
{
const Number exact_val = slitfunc(context, xyz[qp]);
const Number discrete_val = context.interior_value(0, qp);
CPPUNIT_ASSERT_DOUBLES_EQUAL(libmesh_real(exact_val),
libmesh_real(discrete_val),
TOLERANCE*TOLERANCE);
}
}
}
void HeatSystem::init_context(DiffContext & context)
{
FEMContext & c = libmesh_cast_ref<FEMContext &>(context);
const std::set<unsigned char> & elem_dims =
c.elem_dimensions();
for (std::set<unsigned char>::const_iterator dim_it =
elem_dims.begin(); dim_it != elem_dims.end(); ++dim_it)
{
const unsigned char dim = *dim_it;
FEBase * fe = libmesh_nullptr;
c.get_element_fe(T_var, fe, dim);
fe->get_JxW(); // For integration
fe->get_dphi(); // For bilinear form
fe->get_xyz(); // For forcing
fe->get_phi(); // For forcing
}
FEMSystem::init_context(context);
}
bool HeatSystem::element_time_derivative (bool request_jacobian,
DiffContext & context)
{
FEMContext & c = libmesh_cast_ref<FEMContext &>(context);
const unsigned int mesh_dim =
c.get_system().get_mesh().mesh_dimension();
// First we get some references to cell-specific data that
// will be used to assemble the linear system.
const unsigned int dim = c.get_elem().dim();
FEBase * fe = libmesh_nullptr;
c.get_element_fe(T_var, fe, dim);
// Element Jacobian * quadrature weights for interior integration
const std::vector<Real> & JxW = fe->get_JxW();
const std::vector<Point> & xyz = fe->get_xyz();
const std::vector<std::vector<Real> > & phi = fe->get_phi();
const std::vector<std::vector<RealGradient> > & dphi = fe->get_dphi();
// The number of local degrees of freedom in each variable
const unsigned int n_T_dofs = c.get_dof_indices(T_var).size();
// The subvectors and submatrices we need to fill:
DenseSubMatrix<Number> & K = c.get_elem_jacobian(T_var, T_var);
DenseSubVector<Number> & F = c.get_elem_residual(T_var);
// Now we will build the element Jacobian and residual.
// Constructing the residual requires the solution and its
// gradient from the previous timestep. This must be
// calculated at each quadrature point by summing the
// solution degree-of-freedom values by the appropriate
// weight functions.
unsigned int n_qpoints = c.get_element_qrule().n_points();
for (unsigned int qp=0; qp != n_qpoints; qp++)
{
// Compute the solution gradient at the Newton iterate
Gradient grad_T = c.interior_gradient(T_var, qp);
const Number k = _k[dim];
const Point & p = xyz[qp];
// solution + laplacian depend on problem dimension
const Number u_exact = (mesh_dim == 2) ?
std::sin(libMesh::pi*p(0)) * std::sin(libMesh::pi*p(1)) :
std::sin(libMesh::pi*p(0)) * std::sin(libMesh::pi*p(1)) *
std::sin(libMesh::pi*p(2));
// Only apply forcing to interior elements
const Number forcing = (dim == mesh_dim) ?
-k * u_exact * (dim * libMesh::pi * libMesh::pi) : 0;
const Number JxWxNK = JxW[qp] * -k;
for (unsigned int i=0; i != n_T_dofs; i++)
F(i) += JxWxNK * (grad_T * dphi[i][qp] + forcing * phi[i][qp]);
if (request_jacobian)
{
const Number JxWxNKxD = JxWxNK *
context.get_elem_solution_derivative();
for (unsigned int i=0; i != n_T_dofs; i++)
for (unsigned int j=0; j != n_T_dofs; ++j)
K(i,j) += JxWxNKxD * (dphi[i][qp] * dphi[j][qp]);
}
} // end of the quadrature point qp-loop
return request_jacobian;
}
bool SolidSystem::side_time_derivative(bool request_jacobian,
DiffContext &context) {
FEMContext &c = libmesh_cast_ref<FEMContext&>(context);
// Apply displacement boundary conditions with penalty method
// Get the current load step
Real ratio = this->get_equation_systems().parameters.get<Real>("progress")
+ 0.001;
// The BC are stored in the simulation parameters as array containing sequences of
// four numbers: Id of the side for the displacements and three values describing the
// displacement. E.g.: bc/displacement = '5 nan nan -1.0'. This will move all nodes of
// side 5 about 1.0 units down the z-axis while leaving all other directions unrestricted
// Get number of BCs to enforce
unsigned int num_bc = args.vector_variable_size("bc/displacement");
if (num_bc % 4 != 0) {
libMesh::err
<< "ERROR, Odd number of values in displacement boundary condition.\n"
<< std::endl;
libmesh_error();
}
num_bc /= 4;
// Loop over all BCs
for (unsigned int nbc = 0; nbc < num_bc; nbc++) {
// Get IDs of the side for this BC
short int positive_boundary_id = args("bc/displacement", 1, nbc * 4);
// The current side may not be on the boundary to be restricted
if (!this->get_mesh().boundary_info->has_boundary_id
(c.elem,c.side,positive_boundary_id))
continue;
// Read values from configuration file
Point diff_value;
for (unsigned int d = 0; d < c.dim; ++d) {
diff_value(d) = args("bc/displacement", NAN, nbc * 4 + 1 + d);
}
// Scale according to current load step
diff_value *= ratio;
Real penalty_number = args("bc/displacement_penalty", 1e7);
FEBase * fe = c.side_fe_var[var[0]];
const std::vector<std::vector<Real> > & phi = fe->get_phi();
const std::vector<Real>& JxW = fe->get_JxW();
const std::vector<Point>& coords = fe->get_xyz();
unsigned int n_x_dofs = c.dof_indices_var[this->var[0]].size();
// get mappings for dofs for auxiliary system for original mesh positions
const System & auxsys = this->get_equation_systems().get_system(
"auxiliary");
const DofMap & auxmap = auxsys.get_dof_map();
std::vector<dof_id_type> undefo_dofs[3];
for (unsigned int d = 0; d < c.dim; ++d) {
auxmap.dof_indices(c.elem, undefo_dofs[d], undefo_var[d]);
}
for (unsigned int qp = 0; qp < c.side_qrule->n_points(); ++qp) {
// calculate coordinates of qp on undeformed mesh
Point orig_point;
for (unsigned int i = 0; i < n_x_dofs; ++i) {
for (unsigned int d = 0; d < c.dim; ++d) {
Number orig_val = auxsys.current_solution(undefo_dofs[d][i]);
#if LIBMESH_USE_COMPLEX_NUMBERS
orig_point(d) += phi[i][qp] * orig_val.real();
#else
orig_point(d) += phi[i][qp] * orig_val;
#endif
}
}
// Calculate displacement to be enforced.
Point diff = coords[qp] - orig_point - diff_value;
// Assemble
for (unsigned int i = 0; i < n_x_dofs; ++i) {
for (unsigned int d1 = 0; d1 < c.dim; ++d1) {
if (libmesh_isnan(diff(d1)))
continue;
Real val = JxW[qp] * phi[i][qp] * diff(d1) * penalty_number;
c.elem_subresiduals[var[d1]]->operator ()(i) += val;
}
if (request_jacobian) {
for (unsigned int j = 0; j < n_x_dofs; ++j) {
for (unsigned int d1 = 0; d1 < c.dim; ++d1) {
if (libmesh_isnan(diff(d1)))
continue;
Real val = JxW[qp] * phi[i][qp] * phi[j][qp] * penalty_number;
c.elem_subjacobians[var[d1]][var[d1]]->operator ()(i, j) += val;
}
}
}
}
}
}
return request_jacobian;
}
void testRestart()
{
SlitFunc slitfunc;
_mesh->write("slit_mesh.xda");
_es->write("slit_solution.xda",
EquationSystems::WRITE_DATA |
EquationSystems::WRITE_SERIAL_FILES);
Mesh mesh2(*TestCommWorld);
mesh2.read("slit_mesh.xda");
EquationSystems es2(mesh2);
es2.read("slit_solution.xda");
System & sys2 = es2.get_system<System> ("SimpleSystem");
unsigned int dim = 2;
CPPUNIT_ASSERT_EQUAL( sys2.n_vars(), 1u );
FEMContext context(sys2);
FEBase * fe = NULL;
context.get_element_fe( 0, fe, dim );
const std::vector<Point> & xyz = fe->get_xyz();
fe->get_phi();
// While we're in the middle of a unique id based test case, let's
// make sure our unique ids were all read in correctly too.
UniquePtr<PointLocatorBase> locator = _mesh->sub_point_locator();
MeshBase::const_element_iterator el =
mesh2.active_local_elements_begin();
const MeshBase::const_element_iterator end_el =
mesh2.active_local_elements_end();
for (; el != end_el; ++el)
{
const Elem * elem = *el;
const Elem * mesh1_elem = (*locator)(elem->centroid());
if (mesh1_elem)
{
CPPUNIT_ASSERT_EQUAL( elem->unique_id(),
mesh1_elem->unique_id() );
for (unsigned int n=0; n != elem->n_nodes(); ++n)
{
const Node & node = elem->node_ref(n);
const Node & mesh1_node = mesh1_elem->node_ref(n);
CPPUNIT_ASSERT_EQUAL( node.unique_id(),
mesh1_node.unique_id() );
}
}
context.pre_fe_reinit(sys2, elem);
context.elem_fe_reinit();
const unsigned int n_qp = xyz.size();
for (unsigned int qp=0; qp != n_qp; ++qp)
{
const Number exact_val = slitfunc(context, xyz[qp]);
const Number discrete_val = context.interior_value(0, qp);
CPPUNIT_ASSERT_DOUBLES_EQUAL(libmesh_real(exact_val),
libmesh_real(discrete_val),
TOLERANCE*TOLERANCE);
}
}
}