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; }
// This function assembles the system matrix and right-hand-side // for the discrete form of our wave equation. void assemble_wave(EquationSystems & es, const std::string & system_name) { // It is a good idea to make sure we are assembling // the proper system. libmesh_assert_equal_to (system_name, "Wave"); #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS // Get a constant reference to the mesh object. const MeshBase & mesh = es.get_mesh(); // Get a reference to the system we are solving. LinearImplicitSystem & system = es.get_system<LinearImplicitSystem>("Wave"); // A reference to the \p DofMap object for this system. The \p DofMap // object handles the index translation from node and element numbers // to degree of freedom numbers. const DofMap & dof_map = system.get_dof_map(); // The dimension that we are running. const unsigned int dim = mesh.mesh_dimension(); // Copy the speed of sound to a local variable. const Real speed = es.parameters.get<Real>("speed"); // Get a constant reference to the Finite Element type // for the first (and only) variable in the system. const FEType & fe_type = dof_map.variable_type(0); // Build a Finite Element object of the specified type. Since the // \p FEBase::build() member dynamically creates memory we will // store the object as an \p UniquePtr<FEBase>. Check ex5 for details. UniquePtr<FEBase> fe (FEBase::build(dim, fe_type)); // Do the same for an infinite element. UniquePtr<FEBase> inf_fe (FEBase::build_InfFE(dim, fe_type)); // A 2nd order Gauss quadrature rule for numerical integration. QGauss qrule (dim, SECOND); // Tell the finite element object to use our quadrature rule. fe->attach_quadrature_rule (&qrule); // Due to its internal structure, the infinite element handles // quadrature rules differently. It takes the quadrature // rule which has been initialized for the FE object, but // creates suitable quadrature rules by @e itself. The user // need not worry about this. inf_fe->attach_quadrature_rule (&qrule); // Define data structures to contain the element matrix // and right-hand-side vector contribution. Following // basic finite element terminology we will denote these // "Ke", "Ce", "Me", and "Fe" for the stiffness, damping // and mass matrices, and the load vector. Note that in // Acoustics, these descriptors though do @e not match the // true physical meaning of the projectors. The final // overall system, however, resembles the conventional // notation again. DenseMatrix<Number> Ke; DenseMatrix<Number> Ce; DenseMatrix<Number> Me; DenseVector<Number> Fe; // This vector will hold the degree of freedom indices for // the element. These define where in the global system // the element degrees of freedom get mapped. std::vector<dof_id_type> dof_indices; // Now we will loop over all the elements in the mesh. // We will compute the element matrix and right-hand-side // contribution. 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) { // Store a pointer to the element we are currently // working on. This allows for nicer syntax later. const Elem * elem = *el; // Get the degree of freedom indices for the // current element. These define where in the global // matrix and right-hand-side this element will // contribute to. dof_map.dof_indices (elem, dof_indices); // The mesh contains both finite and infinite elements. These // elements are handled through different classes, namely // \p FE and \p InfFE, respectively. However, since both // are derived from \p FEBase, they share the same interface, // and overall burden of coding is @e greatly reduced through // using a pointer, which is adjusted appropriately to the // current element type. FEBase * cfe = libmesh_nullptr; // This here is almost the only place where we need to // distinguish between finite and infinite elements. // For faster computation, however, different approaches // may be feasible. // // Up to now, we do not know what kind of element we // have. Aske the element of what type it is: if (elem->infinite()) { // We have an infinite element. Let \p cfe point // to our \p InfFE object. This is handled through // an UniquePtr. Through the \p UniquePtr::get() we "borrow" // the pointer, while the \p UniquePtr \p inf_fe is // still in charge of memory management. cfe = inf_fe.get(); } else { // This is a conventional finite element. Let \p fe handle it. cfe = fe.get(); // Boundary conditions. // Here we just zero the rhs-vector. For natural boundary // conditions check e.g. previous examples. { // Zero the RHS for this element. Fe.resize (dof_indices.size()); system.rhs->add_vector (Fe, dof_indices); } // end boundary condition section } // else if (elem->infinite()) // This is slightly different from the Poisson solver: // Since the finite element object may change, we have to // initialize the constant references to the data fields // each time again, when a new element is processed. // // The element Jacobian * quadrature weight at each integration point. const std::vector<Real> & JxW = cfe->get_JxW(); // The element shape functions evaluated at the quadrature points. const std::vector<std::vector<Real> > & phi = cfe->get_phi(); // The element shape function gradients evaluated at the quadrature // points. const std::vector<std::vector<RealGradient> > & dphi = cfe->get_dphi(); // The infinite elements need more data fields than conventional FE. // These are the gradients of the phase term \p dphase, an additional // radial weight for the test functions \p Sobolev_weight, and its // gradient. // // Note that these data fields are also initialized appropriately by // the \p FE method, so that the weak form (below) is valid for @e both // finite and infinite elements. const std::vector<RealGradient> & dphase = cfe->get_dphase(); const std::vector<Real> & weight = cfe->get_Sobolev_weight(); const std::vector<RealGradient> & dweight = cfe->get_Sobolev_dweight(); // Now this is all independent of whether we use an \p FE // or an \p InfFE. Nice, hm? ;-) // // Compute the element-specific data, as described // in previous examples. cfe->reinit (elem); // Zero the element matrices. Boundary conditions were already // processed in the \p FE-only section, see above. Ke.resize (dof_indices.size(), dof_indices.size()); Ce.resize (dof_indices.size(), dof_indices.size()); Me.resize (dof_indices.size(), dof_indices.size()); // The total number of quadrature points for infinite elements // @e has to be determined in a different way, compared to // conventional finite elements. This type of access is also // valid for finite elements, so this can safely be used // anytime, instead of asking the quadrature rule, as // seen in previous examples. unsigned int max_qp = cfe->n_quadrature_points(); // Loop over the quadrature points. for (unsigned int qp=0; qp<max_qp; qp++) { // Similar to the modified access to the number of quadrature // points, the number of shape functions may also be obtained // in a different manner. This offers the great advantage // of being valid for both finite and infinite elements. const unsigned int n_sf = cfe->n_shape_functions(); // Now we will build the element matrices. Since the infinite // elements are based on a Petrov-Galerkin scheme, the // resulting system matrices are non-symmetric. The additional // weight, described before, is part of the trial space. // // For the finite elements, though, these matrices are symmetric // just as we know them, since the additional fields \p dphase, // \p weight, and \p dweight are initialized appropriately. // // test functions: weight[qp]*phi[i][qp] // trial functions: phi[j][qp] // phase term: phase[qp] // // derivatives are similar, but note that these are of type // Point, not of type Real. for (unsigned int i=0; i<n_sf; i++) for (unsigned int j=0; j<n_sf; j++) { // (ndt*Ht + nHt*d) * nH Ke(i,j) += ( (dweight[qp] * phi[i][qp] // Point * Real = Point + // + dphi[i][qp] * weight[qp] // Point * Real = Point ) * dphi[j][qp] ) * JxW[qp]; // (d*Ht*nmut*nH - ndt*nmu*Ht*H - d*nHt*nmu*H) Ce(i,j) += ( (dphase[qp] * dphi[j][qp]) // (Point * Point) = Real * weight[qp] * phi[i][qp] // * Real * Real = Real - // - (dweight[qp] * dphase[qp]) // (Point * Point) = Real * phi[i][qp] * phi[j][qp] // * Real * Real = Real - // - (dphi[i][qp] * dphase[qp]) // (Point * Point) = Real * weight[qp] * phi[j][qp] // * Real * Real = Real ) * JxW[qp]; // (d*Ht*H * (1 - nmut*nmu)) Me(i,j) += ( (1. - (dphase[qp] * dphase[qp])) // (Real - (Point * Point)) = Real * phi[i][qp] * phi[j][qp] * weight[qp] // * Real * Real * Real = Real ) * JxW[qp]; } // end of the matrix summation loop } // end of quadrature point loop // The element matrices are now built for this element. // Collect them in Ke, and then add them to the global matrix. // The \p SparseMatrix::add_matrix() member does this for us. Ke.add(1./speed , Ce); Ke.add(1./(speed*speed), Me); // If this assembly program were to be used on an adaptive mesh, // we would have to apply any hanging node constraint equations dof_map.constrain_element_matrix(Ke, dof_indices); system.matrix->add_matrix (Ke, dof_indices); } // end of element loop // Note that we have not applied any boundary conditions so far. // Here we apply a unit load at the node located at (0,0,0). { // Iterate over local nodes MeshBase::const_node_iterator nd = mesh.local_nodes_begin(); const MeshBase::const_node_iterator nd_end = mesh.local_nodes_end(); for (; nd != nd_end; ++nd) { // Get a reference to the current node. const Node & node = **nd; // Check the location of the current node. if (std::abs(node(0)) < TOLERANCE && std::abs(node(1)) < TOLERANCE && std::abs(node(2)) < TOLERANCE) { // The global number of the respective degree of freedom. unsigned int dn = node.dof_number(0,0,0); system.rhs->add (dn, 1.); } } } #else // dummy assert libmesh_assert_not_equal_to (es.get_mesh().mesh_dimension(), 1); #endif //ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS }
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; }