assembly.h

Go to the documentation of this file.

#ifndef ASSEMBLY_H
#define ASSEMBLY_H
 
#include "libmesh/sparse_matrix.h"
#include "libmesh/numeric_vector.h"
#include "libmesh/dense_matrix.h"
#include "libmesh/dense_vector.h"
#include "libmesh/fe.h"
#include "libmesh/fe_interface.h"
#include "libmesh/fe_base.h"
#include "libmesh/elem_assembly.h"
#include "libmesh/quadrature_gauss.h"
#include "libmesh/boundary_info.h"
 
// rbOOmit includes
#include "libmesh/rb_theta.h"
#include "libmesh/rb_assembly_expansion.h"
#include "libmesh/rb_parametrized_function.h"
#include "libmesh/rb_eim_construction.h"
#include "libmesh/rb_eim_theta.h"
 
// Bring in bits from the libMesh namespace.
// Just the bits we're using, since this is a header.
using libMesh::boundary_id_type;
using libMesh::DenseSubMatrix;
using libMesh::ElemAssembly;
using libMesh::FEInterface;
using libMesh::FEMContext;
using libMesh::Number;
using libMesh::Point;
using libMesh::RBAssemblyExpansion;
using libMesh::RBConstruction;
using libMesh::RBParameters;
using libMesh::RBParametrizedFunction;
using libMesh::RBTheta;
using libMesh::RBThetaExpansion;
using libMesh::RBEIMAssembly;
using libMesh::RBEIMConstruction;
using libMesh::RBEIMEvaluation;
using libMesh::RBEIMTheta;
using libMesh::Real;
using libMesh::RealGradient;
using libMesh::Elem;
using libMesh::FEBase;
 
struct ElemAssemblyWithConstruction : ElemAssembly
{
  RBConstruction * rb_con;
};
 
// The "x component" of the function we're approximating with EIM
struct Gx : public RBParametrizedFunction
{
  virtual Number evaluate(const RBParameters & mu,
                          const Point & p,
                          const Elem &)
  {
    Real curvature = mu.get_value("curvature");
    return 1. + curvature*p(0);
  }
};
 
// The "y component" of the function we're approximating with EIM
struct Gy : public RBParametrizedFunction
{
  virtual Number evaluate(const RBParameters & mu,
                          const Point & p,
                          const Elem &)
  {
    Real curvature = mu.get_value("curvature");
    return 1. + curvature*p(0);
  }
};
 
// The "z component" of the function we're approximating with EIM
struct Gz : public RBParametrizedFunction
{
  virtual Number evaluate(const RBParameters & mu,
                          const Point & p,
                          const Elem &)
  {
    Real curvature = mu.get_value("curvature");
    return 1./(1. + curvature*p(0));
  }
};
 
struct ThetaA0 : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("kappa") * mu.get_value("Bi");
  }
};
 
struct AssemblyA0 : ElemAssemblyWithConstruction
{
  virtual void boundary_assembly(FEMContext & c)
  {
    std::vector<boundary_id_type> bc_ids;
    rb_con->get_mesh().get_boundary_info().boundary_ids (&c.get_elem(), c.side, bc_ids);
    for (std::vector<boundary_id_type>::const_iterator b =
           bc_ids.begin(); b != bc_ids.end(); ++b)
      if (*b == 1 || *b == 2 || *b == 3 || *b == 4)
        {
          const unsigned int u_var = 0;
 
          FEBase * side_fe = nullptr;
          c.get_side_fe(u_var, side_fe);
 
          const std::vector<Real> & JxW_side = side_fe->get_JxW();
 
          const std::vector<std::vector<Real>> & phi_side = side_fe->get_phi();
 
          // The number of local degrees of freedom in each variable
          const unsigned int n_u_dofs = c.get_dof_indices(u_var).size();
 
          // Now we will build the affine operator
          unsigned int n_sidepoints = c.get_side_qrule().n_points();
 
          for (unsigned int qp=0; qp != n_sidepoints; qp++)
            for (unsigned int i=0; i != n_u_dofs; i++)
              for (unsigned int j=0; j != n_u_dofs; j++)
                c.get_elem_jacobian()(i,j) += JxW_side[qp] * phi_side[j][qp]*phi_side[i][qp];
 
          break;
        }
  }
};
 
struct ThetaA1 : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("kappa") * mu.get_value("Bi") * mu.get_value("curvature");
  }
};
 
struct AssemblyA1 : ElemAssemblyWithConstruction
{
  virtual void boundary_assembly(FEMContext & c)
  {
    std::vector<boundary_id_type> bc_ids;
    rb_con->get_mesh().get_boundary_info().boundary_ids (&c.get_elem(), c.side, bc_ids);
    for (std::vector<boundary_id_type>::const_iterator b =
           bc_ids.begin(); b != bc_ids.end(); ++b)
      if (*b == 1 || *b == 3) // y == -0.2, y == 0.2
        {
          const unsigned int u_var = 0;
 
          FEBase * side_fe = nullptr;
          c.get_side_fe(u_var, side_fe);
 
          const std::vector<Real> & JxW_side = side_fe->get_JxW();
 
          const std::vector<std::vector<Real>> & phi_side = side_fe->get_phi();
 
          const std::vector<Point> & xyz = side_fe->get_xyz();
 
          // The number of local degrees of freedom in each variable
          const unsigned int n_u_dofs = c.get_dof_indices(u_var).size();
 
          // Now we will build the affine operator
          unsigned int n_sidepoints = c.get_side_qrule().n_points();
 
          for (unsigned int qp=0; qp != n_sidepoints; qp++)
            {
              Real x_hat = xyz[qp](0);
 
              for (unsigned int i=0; i != n_u_dofs; i++)
                for (unsigned int j=0; j != n_u_dofs; j++)
                  c.get_elem_jacobian()(i,j) += JxW_side[qp] * x_hat * phi_side[j][qp]*phi_side[i][qp];
            }
 
          break;
        }
  }
};
 
struct ThetaA2 : RBTheta {
  virtual Number evaluate(const RBParameters & mu)
  {
    return 0.2*mu.get_value("kappa") * mu.get_value("Bi") * mu.get_value("curvature");
  }
};
struct AssemblyA2 : ElemAssemblyWithConstruction
{
  virtual void boundary_assembly(FEMContext & c)
  {
    std::vector<boundary_id_type> bc_ids;
    rb_con->get_mesh().get_boundary_info().boundary_ids (&c.get_elem(), c.side, bc_ids);
    for (std::vector<boundary_id_type>::const_iterator b =
           bc_ids.begin(); b != bc_ids.end(); ++b)
      if (*b == 2 || *b == 4) // x == 0.2, x == -0.2
        {
          const unsigned int u_var = 0;
 
          FEBase * side_fe = nullptr;
          c.get_side_fe(u_var, side_fe);
 
          const std::vector<Real> & JxW_side = side_fe->get_JxW();
 
          const std::vector<std::vector<Real>> & phi_side = side_fe->get_phi();
 
          // The number of local degrees of freedom in each variable
          const unsigned int n_u_dofs = c.get_dof_indices(u_var).size();
 
          // Now we will build the affine operator
          unsigned int n_sidepoints = c.get_side_qrule().n_points();
 
          if (*b==2)
            {
              for (unsigned int qp=0; qp != n_sidepoints; qp++)
                {
                  for (unsigned int i=0; i != n_u_dofs; i++)
                    for (unsigned int j=0; j != n_u_dofs; j++)
                      c.get_elem_jacobian()(i,j) += JxW_side[qp] * phi_side[j][qp]*phi_side[i][qp];
                }
            }
 
          if (*b==4)
            {
              for (unsigned int qp=0; qp != n_sidepoints; qp++)
                {
                  for (unsigned int i=0; i != n_u_dofs; i++)
                    for (unsigned int j=0; j != n_u_dofs; j++)
                      c.get_elem_jacobian()(i,j) -= JxW_side[qp] * phi_side[j][qp]*phi_side[i][qp];
                }
            }
        }
  }
};
 
struct ThetaEIM : RBEIMTheta
{
  ThetaEIM(RBEIMEvaluation & rb_eim_eval_in, unsigned int index_in) :
    RBEIMTheta(rb_eim_eval_in, index_in)
  {}
 
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("kappa") * RBEIMTheta::evaluate(mu);
  }
};
 
struct AssemblyEIM : RBEIMAssembly
{
  AssemblyEIM(RBEIMConstruction & rb_eim_con_in,
              unsigned int basis_function_index_in) :
    RBEIMAssembly(rb_eim_con_in,
                  basis_function_index_in)
  {}
 
  virtual void interior_assembly(FEMContext & c)
  {
    // PDE variable numbers
    const unsigned int u_var = 0;
 
    // EIM variable numbers
    const unsigned int Gx_var = 0;
    const unsigned int Gy_var = 1;
    const unsigned int Gz_var = 2;
 
    FEBase * elem_fe = nullptr;
    c.get_element_fe(u_var, elem_fe);
 
    const std::vector<Real> & JxW = elem_fe->get_JxW();
 
    const std::vector<std::vector<RealGradient>> & dphi = elem_fe->get_dphi();
 
    // The number of local degrees of freedom in each variable
    const unsigned int n_u_dofs = c.get_dof_indices(u_var).size();
 
    std::vector<Number> eim_values_Gx;
    evaluate_basis_function(Gx_var,
                            c.get_elem(),
                            c.get_element_qrule().get_points(),
                            eim_values_Gx);
 
    std::vector<Number> eim_values_Gy;
    evaluate_basis_function(Gy_var,
                            c.get_elem(),
                            c.get_element_qrule().get_points(),
                            eim_values_Gy);
 
    std::vector<Number> eim_values_Gz;
    evaluate_basis_function(Gz_var,
                            c.get_elem(),
                            c.get_element_qrule().get_points(),
                            eim_values_Gz);
 
    for (unsigned int qp=0; qp != c.get_element_qrule().n_points(); qp++)
      for (unsigned int i=0; i != n_u_dofs; i++)
        for (unsigned int j=0; j != n_u_dofs; j++)
          c.get_elem_jacobian()(i,j) += JxW[qp] * (eim_values_Gx[qp]*dphi[i][qp](0)*dphi[j][qp](0) +
                                                   eim_values_Gy[qp]*dphi[i][qp](1)*dphi[j][qp](1) +
                                                   eim_values_Gz[qp]*dphi[i][qp](2)*dphi[j][qp](2));
  }
};
 
 
struct ThetaF0 : RBTheta
{
  virtual Number evaluate(const RBParameters &) { return 1.; }
};
 
struct AssemblyF0 : ElemAssembly
{
 
  virtual void interior_assembly(FEMContext & c)
  {
    const unsigned int u_var = 0;
 
    FEBase * elem_fe = nullptr;
    c.get_element_fe(u_var, elem_fe);
 
    const std::vector<Real> & JxW = elem_fe->get_JxW();
 
    const std::vector<std::vector<Real>> & phi = elem_fe->get_phi();
 
    // The number of local degrees of freedom in each variable
    const unsigned int n_u_dofs = c.get_dof_indices(u_var).size();
 
    // Now we will build the affine operator
    unsigned int n_qpoints = c.get_element_qrule().n_points();
 
    for (unsigned int qp=0; qp != n_qpoints; qp++)
      for (unsigned int i=0; i != n_u_dofs; i++)
        c.get_elem_residual()(i) += JxW[qp] * (1.*phi[i][qp]);
  }
};
 
struct ThetaF1 : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("curvature");
  }
};
 
struct AssemblyF1 : ElemAssembly
{
 
  virtual void interior_assembly(FEMContext & c)
  {
    const unsigned int u_var = 0;
 
    FEBase * elem_fe = nullptr;
    c.get_element_fe(u_var, elem_fe);
 
    const std::vector<Real> & JxW = elem_fe->get_JxW();
 
    const std::vector<std::vector<Real>> & phi = elem_fe->get_phi();
 
    const std::vector<Point> & xyz = elem_fe->get_xyz();
 
    // The number of local degrees of freedom in each variable
    const unsigned int n_u_dofs = c.get_dof_indices(u_var).size();
 
    // Now we will build the affine operator
    unsigned int n_qpoints = c.get_element_qrule().n_points();
 
    for (unsigned int qp=0; qp != n_qpoints; qp++)
      {
        Real x_hat = xyz[qp](0);
 
        for (unsigned int i=0; i != n_u_dofs; i++)
          c.get_elem_residual()(i) += JxW[qp] * (1.*x_hat*phi[i][qp]);
      }
  }
};
 
struct Ex6InnerProduct : ElemAssembly
{
  // Assemble the Laplacian operator
  virtual void interior_assembly(FEMContext & c)
  {
    const unsigned int u_var = 0;
 
    FEBase * elem_fe = nullptr;
    c.get_element_fe(u_var, elem_fe);
 
    const std::vector<Real> & JxW = elem_fe->get_JxW();
 
    const std::vector<std::vector<RealGradient>> & dphi = elem_fe->get_dphi();
 
    // The number of local degrees of freedom in each variable
    const unsigned int n_u_dofs = c.get_dof_indices(u_var).size();
 
    // Now we will build the affine operator
    unsigned int n_qpoints = c.get_element_qrule().n_points();
 
    for (unsigned int qp=0; qp != n_qpoints; qp++)
      for (unsigned int i=0; i != n_u_dofs; i++)
        for (unsigned int j=0; j != n_u_dofs; j++)
          c.get_elem_jacobian()(i,j) += JxW[qp] * dphi[j][qp]*dphi[i][qp];
  }
};
 
struct Ex6EIMInnerProduct : ElemAssembly
{
  // Use the L2 inner product to find the best fit
  virtual void interior_assembly(FEMContext & c)
  {
    FEBase * elem_fe = nullptr;
    c.get_element_fe(0, elem_fe);
 
    const std::vector<Real> & JxW = elem_fe->get_JxW();
 
    const std::vector<std::vector<Real>> & phi = elem_fe->get_phi();
 
    const unsigned int n_dofs = c.get_dof_indices().size();
 
    unsigned int n_qpoints = c.get_element_qrule().n_points();
 
    for (unsigned int qp=0; qp != n_qpoints; qp++)
      for (unsigned int i=0; i != n_dofs; i++)
        for (unsigned int j=0; j != n_dofs; j++)
          {
            c.get_elem_jacobian()(i,j) += JxW[qp] * phi[j][qp]*phi[i][qp];
          }
  }
};
 
// Define an RBThetaExpansion class for this PDE
// The A terms depend on EIM, so we deal with them later
struct Ex6ThetaExpansion : RBThetaExpansion
{
 
  Ex6ThetaExpansion()
  {
    attach_A_theta(&theta_a0);
    attach_A_theta(&theta_a1);
    attach_A_theta(&theta_a2);
    attach_F_theta(&theta_f0); // Attach the rhs theta
    attach_F_theta(&theta_f1);
  }
 
  // The RBTheta member variables
  ThetaA0 theta_a0;
  ThetaA1 theta_a1;
  ThetaA2 theta_a2;
  ThetaF0 theta_f0;
  ThetaF1 theta_f1;
};
 
// Define an RBAssemblyExpansion class for this PDE
// The A terms depend on EIM, so we deal with them later
struct Ex6AssemblyExpansion : RBAssemblyExpansion
{
 
  Ex6AssemblyExpansion(RBConstruction & rb_con)
  {
    // Point to the RBConstruction object
    assembly_a0.rb_con = &rb_con;
    assembly_a1.rb_con = &rb_con;
    assembly_a2.rb_con = &rb_con;
 
    attach_A_assembly(&assembly_a0);
    attach_A_assembly(&assembly_a1);
    attach_A_assembly(&assembly_a2);
    attach_F_assembly(&assembly_f0); // Attach the rhs assembly
    attach_F_assembly(&assembly_f1);
  }
 
  // The ElemAssembly objects
  AssemblyA0 assembly_a0;
  AssemblyA1 assembly_a1;
  AssemblyA2 assembly_a2;
  AssemblyF0 assembly_f0;
  AssemblyF1 assembly_f1;
};
 
#endif