ffc_l2proj_05.h

利用C

    A[6] = -0.00238095238095238*G0_;
    A[7] = -0.00158730158730158*G0_;
    A[8] = -0.00158730158730158*G0_;
    A[9] = -0.00158730158730158*G0_;
    A[10] = 0.000396825396825395*G0_;
    A[11] = 0.00238095238095238*G0_;
    A[12] = 0.000396825396825396*G0_;
    A[13] = 0.000396825396825396*G0_;
    A[14] = -0.00238095238095237*G0_;
    A[15] = -0.00158730158730158*G0_;
    A[16] = -0.00158730158730158*G0_;
    A[17] = -0.00238095238095238*G0_;
    A[18] = -0.00238095238095237*G0_;
    A[19] = -0.00158730158730158*G0_;
    A[20] = 0.000396825396825396*G0_;
    A[21] = 0.000396825396825396*G0_;
    A[22] = 0.00238095238095238*G0_;
    A[23] = 0.000396825396825398*G0_;
    A[24] = -0.00158730158730159*G0_;
    A[25] = -0.00238095238095238*G0_;
    A[26] = -0.00158730158730159*G0_;
    A[27] = -0.00238095238095238*G0_;
    A[28] = -0.00158730158730159*G0_;
    A[29] = -0.00238095238095238*G0_;
    A[30] = 0.000396825396825397*G0_;
    A[31] = 0.000396825396825396*G0_;
    A[32] = 0.000396825396825398*G0_;
    A[33] = 0.00238095238095238*G0_;
    A[34] = -0.00158730158730159*G0_;
    A[35] = -0.00158730158730159*G0_;
    A[36] = -0.00238095238095238*G0_;
    A[37] = -0.00158730158730159*G0_;
    A[38] = -0.00238095238095238*G0_;
    A[39] = -0.00238095238095238*G0_;
    A[40] = -0.00238095238095237*G0_;
    A[41] = -0.00238095238095237*G0_;
    A[42] = -0.00158730158730159*G0_;
    A[43] = -0.00158730158730159*G0_;
    A[44] = 0.0126984126984127*G0_;
    A[45] = 0.00634920634920634*G0_;
    A[46] = 0.00634920634920635*G0_;
    A[47] = 0.00634920634920634*G0_;
    A[48] = 0.00634920634920634*G0_;
    A[49] = 0.00317460317460317*G0_;
    A[50] = -0.00238095238095238*G0_;
    A[51] = -0.00158730158730158*G0_;
    A[52] = -0.00238095238095238*G0_;
    A[53] = -0.00158730158730159*G0_;
    A[54] = 0.00634920634920634*G0_;
    A[55] = 0.0126984126984127*G0_;
    A[56] = 0.00634920634920635*G0_;
    A[57] = 0.00634920634920634*G0_;
    A[58] = 0.00317460317460317*G0_;
    A[59] = 0.00634920634920634*G0_;
    A[60] = -0.00238095238095238*G0_;
    A[61] = -0.00158730158730158*G0_;
    A[62] = -0.00158730158730159*G0_;
    A[63] = -0.00238095238095238*G0_;
    A[64] = 0.00634920634920635*G0_;
    A[65] = 0.00634920634920635*G0_;
    A[66] = 0.0126984126984127*G0_;
    A[67] = 0.00317460317460317*G0_;
    A[68] = 0.00634920634920634*G0_;
    A[69] = 0.00634920634920634*G0_;
    A[70] = -0.00158730158730158*G0_;
    A[71] = -0.00238095238095238*G0_;
    A[72] = -0.00238095238095238*G0_;
    A[73] = -0.00158730158730159*G0_;
    A[74] = 0.00634920634920634*G0_;
    A[75] = 0.00634920634920634*G0_;
    A[76] = 0.00317460317460317*G0_;
    A[77] = 0.0126984126984127*G0_;
    A[78] = 0.00634920634920634*G0_;
    A[79] = 0.00634920634920634*G0_;
    A[80] = -0.00158730158730158*G0_;
    A[81] = -0.00238095238095237*G0_;
    A[82] = -0.00158730158730159*G0_;
    A[83] = -0.00238095238095238*G0_;
    A[84] = 0.00634920634920634*G0_;
    A[85] = 0.00317460317460317*G0_;
    A[86] = 0.00634920634920634*G0_;
    A[87] = 0.00634920634920634*G0_;
    A[88] = 0.0126984126984127*G0_;
    A[89] = 0.00634920634920634*G0_;
    A[90] = -0.00158730158730158*G0_;
    A[91] = -0.00158730158730158*G0_;
    A[92] = -0.00238095238095238*G0_;
    A[93] = -0.00238095238095238*G0_;
    A[94] = 0.00317460317460317*G0_;
    A[95] = 0.00634920634920634*G0_;
    A[96] = 0.00634920634920634*G0_;
    A[97] = 0.00634920634920634*G0_;
    A[98] = 0.00634920634920634*G0_;
    A[99] = 0.0126984126984127*G0_;
  }

};

/// This class defines the interface for the assembly of the global
/// tensor corresponding to a form with r + n arguments, that is, a
/// mapping
///
///     a : V1 x V2 x ... Vr x W1 x W2 x ... x Wn -> R
///
/// with arguments v1, v2, ..., vr, w1, w2, ..., wn. The rank r
/// global tensor A is defined by
///
///     A = a(V1, V2, ..., Vr, w1, w2, ..., wn),
///
/// where each argument Vj represents the application to the
/// sequence of basis functions of Vj and w1, w2, ..., wn are given
/// fixed functions (coefficients).

class UFC_ffc_L2proj_05BilinearForm: public ufc::form
{
public:

  /// Constructor
  UFC_ffc_L2proj_05BilinearForm() : ufc::form()
  {
    // Do nothing
  }

  /// Destructor
  virtual ~UFC_ffc_L2proj_05BilinearForm()
  {
    // Do nothing
  }

  /// Return a string identifying the form
  virtual const char* signature() const
  {
    return " | vi1[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]*vi0[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]*dX(0)";
  }

  /// Return the rank of the global tensor (r)
  virtual unsigned int rank() const
  {
    return 2;
  }

  /// Return the number of coefficients (n)
  virtual unsigned int num_coefficients() const
  {
    return 0;
  }

  /// Return the number of cell integrals
  virtual unsigned int num_cell_integrals() const
  {
    return 1;
  }
  
  /// Return the number of exterior facet integrals
  virtual unsigned int num_exterior_facet_integrals() const
  {
    return 0;
  }
  
  /// Return the number of interior facet integrals
  virtual unsigned int num_interior_facet_integrals() const
  {
    return 0;
  }
    
  /// Create a new finite element for argument function i
  virtual ufc::finite_element* create_finite_element(unsigned int i) const
  {
    switch ( i )
    {
    case 0:
      return new UFC_ffc_L2proj_05BilinearForm_finite_element_0();
      break;
    case 1:
      return new UFC_ffc_L2proj_05BilinearForm_finite_element_1();
      break;
    }
    return 0;
  }
  
  /// Create a new dof map for argument function i
  virtual ufc::dof_map* create_dof_map(unsigned int i) const
  {
    switch ( i )
    {
    case 0:
      return new UFC_ffc_L2proj_05BilinearForm_dof_map_0();
      break;
    case 1:
      return new UFC_ffc_L2proj_05BilinearForm_dof_map_1();
      break;
    }
    return 0;
  }

  /// Create a new cell integral on sub domain i
  virtual ufc::cell_integral* create_cell_integral(unsigned int i) const
  {
    return new UFC_ffc_L2proj_05BilinearForm_cell_integral_0();
  }

  /// Create a new exterior facet integral on sub domain i
  virtual ufc::exterior_facet_integral* create_exterior_facet_integral(unsigned int i) const
  {
    return 0;
  }

  /// Create a new interior facet integral on sub domain i
  virtual ufc::interior_facet_integral* create_interior_facet_integral(unsigned int i) const
  {
    return 0;
  }

};

/// This class defines the interface for a finite element.

class UFC_ffc_L2proj_05LinearForm_finite_element_0: public ufc::finite_element
{
public:

  /// Constructor
  UFC_ffc_L2proj_05LinearForm_finite_element_0() : ufc::finite_element()
  {
    // Do nothing
  }

  /// Destructor
  virtual ~UFC_ffc_L2proj_05LinearForm_finite_element_0()
  {
    // Do nothing
  }

  /// Return a string identifying the finite element
  virtual const char* signature() const
  {
    return "Lagrange finite element of degree 2 on a tetrahedron";
  }

  /// Return the cell shape
  virtual ufc::shape cell_shape() const
  {
    return ufc::tetrahedron;
  }

  /// Return the dimension of the finite element function space
  virtual unsigned int space_dimension() const
  {
    return 10;
  }

  /// Return the rank of the value space
  virtual unsigned int value_rank() const
  {
    return 0;
  }

  /// Return the dimension of the value space for axis i
  virtual unsigned int value_dimension(unsigned int i) const
  {
    return 1;
  }

  /// Evaluate basis function i at given point in cell
  virtual void evaluate_basis(unsigned int i,
                              double* values,
                              const double* coordinates,
                              const ufc::cell& c) const
  {
    throw std::runtime_error("// Function evaluate_basis not generated (compiled with -fno-evaluate_basis)");
  }

  /// Evaluate all basis functions at given point in cell
  virtual void evaluate_basis_all(double* values,
                                  const double* coordinates,
                                  const ufc::cell& c) const
  {
    throw std::runtime_error("The vectorised version of evaluate_basis() is not yet implemented.");
  }

  /// Evaluate order n derivatives of basis function i at given point in cell
  virtual void evaluate_basis_derivatives(unsigned int i,
                                          unsigned int n,
                                          double* values,
                                          const double* coordinates,
                                          const ufc::cell& c) const
  {
    throw std::runtime_error("// Function evaluate_basis_derivatives not generated (compiled with -fno-evaluate_basis_derivatives)");
  }

  /// Evaluate order n derivatives of all basis functions at given point in cell
  virtual void evaluate_basis_derivatives_all(unsigned int n,
                                              double* values,
                                              const double* coordinates,
                                              const ufc::cell& c) const
  {
    throw std::runtime_error("The vectorised version of evaluate_basis_derivatives() is not yet implemented.");
  }

  /// Evaluate linear functional for dof i on the function f
  virtual double evaluate_dof(unsigned int i,
                              const ufc::function& f,
                              const ufc::cell& c) const
  {
    // The reference points, direction and weights:
    const static double X[10][1][3] = {{{0, 0, 0}}, {{1, 0, 0}}, {{0, 1, 0}}, {{0, 0, 1}}, {{0, 0.5, 0.5}}, {{0.5, 0, 0.5}}, {{0.5, 0.5, 0}}, {{0, 0, 0.5}}, {{0, 0.5, 0}}, {{0.5, 0, 0}}};
    const static double W[10][1] = {{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}};
    const static double D[10][1][1] = {{{1}}, {{1}}, {{1}}, {{1}}, {{1}}, {{1}}, {{1}}, {{1}}, {{1}}, {{1}}};
    
    const double * const * x = c.coordinates;
    double result = 0.0;
    // Iterate over the points:
    // Evaluate basis functions for affine mapping
    const double w0 = 1.0 - X[i][0][0] - X[i][0][1] - X[i][0][2];
    const double w1 = X[i][0][0];
    const double w2 = X[i][0][1];
    const double w3 = X[i][0][2];
    
    // Compute affine mapping y = F(X)
    double y[3];
    y[0] = w0*x[0][0] + w1*x[1][0] + w2*x[2][0] + w3*x[3][0];
    y[1] = w0*x[0][1] + w1*x[1][1] + w2*x[2][1] + w3*x[3][1];
    y[2] = w0*x[0][2] + w1*x[1][2] + w2*x[2][2] + w3*x[3][2];
    
    // Evaluate function at physical points
    double values[1];
    f.evaluate(values, y, c);
    
    // Map function values using appropriate mapping
    // Affine map: Do nothing
    
    // Note that we do not map the weights (yet).
    
    // Take directional components
    for(int k = 0; k < 1; k++)
      result += values[k]*D[i][0][k];
    // Multiply by weights 
    result *= W[i][0];
    
    return result;
  }

  /// Evaluate linear functionals for all dofs on the function f
  virtual void evaluate_dofs(double* values,
                             const ufc::function& f,
                             const ufc::cell& c) const
  {
    throw std::runtime_error("Not implemented (introduced in UFC v1.1).");
  }

  /// Interpolate vertex values from dof values
  virtual void interpolate_vertex_values(double* vertex_values,
                                         const double* dof_values,
                                         const ufc::cell& c) const
  {
    // Evaluate at vertices and use affine mapping
    vertex_values[0] = dof_values[0];
    vertex_values[1] = dof_values[1];
    vertex_values[2] = dof_values[2];
    vertex_values[3] = dof_values[3];
  }

  /// Return the number of sub elements (for a mixed element)
  virtual unsigned int num_sub_elements() const
  {
    return 1;
  }

  /// Create a new finite element for sub element i (for a mixed element)
  virtual ufc::finite_element* create_sub_element(unsigned int i) const
  {
    return new UFC_ffc_L2proj_05LinearForm_finite_element_0();
  }

};

/// This class defines the interface for a finite element.

class UFC_ffc_L2proj_05LinearForm_finite_element_1: public ufc::finite_element
{
public:

  /// Constructor
  UFC_ffc_L2proj_05LinearForm_finite_element_1() : ufc::finite_element()
  {
    // Do nothing
  }

  /// Destructor
  virtual ~UFC_ffc_L2proj_05LinearForm_finite_element_1()
  {
    // Do nothing
  }

  /// Return a string identifying the finite element
  virtual const char* signature() const
  {
    return "Lagrange finite element of degree 2 on a tetrahedron";
  }

  /// Return the cell shape
  virtual ufc::shape cell_shape() const
  {
    return ufc::tetrahedron;
  }

  /// Return the dimension of the finite element function space
  virtual unsigned int space_dimension() const
  {
    return 10;
  }

  /// Return the rank of the value space
  virtual unsigned int value_rank() const
  {
    return 0;
  }