assembly.h

Go to the documentation of this file.

#ifndef ASSEMBLY_H
#define ASSEMBLY_H

// rbOOmit includes
#include "libmesh/rb_parameters.h"
#include "libmesh/rb_theta.h"
#include "libmesh/rb_theta_expansion.h"
#include "libmesh/rb_assembly_expansion.h"
#include "libmesh/elem_assembly.h"

// Bring in bits from the libMesh namespace.
// Just the bits we're using, since this is a header.
using libMesh::ElemAssembly;
using libMesh::FEMContext;
using libMesh::Number;
using libMesh::Real;
using libMesh::RBAssemblyExpansion;
using libMesh::RBParameters;
using libMesh::RBTheta;
using libMesh::RBThetaExpansion;
using libMesh::numeric_index_type;
using libMesh::System;
using libMesh::Node;

// boundary IDs
#define BOUNDARY_ID_MIN_Z 0
#define BOUNDARY_ID_MIN_Y 1
#define BOUNDARY_ID_MAX_X 2
#define BOUNDARY_ID_MAX_Y 3
#define BOUNDARY_ID_MIN_X 4
#define BOUNDARY_ID_MAX_Z 5
#define NODE_BOUNDARY_ID 10

class ElasticityRBConstruction;

// Kronecker delta function
inline Real kronecker_delta(unsigned int i,
                            unsigned int j);

// Rank-4 tensor for elasticity
Real elasticity_tensor(unsigned int i,
                       unsigned int j,
                       unsigned int k,
                       unsigned int l);

struct ElasticityAssembly : ElemAssembly
{

  ElasticityAssembly(ElasticityRBConstruction & rb_sys_in) :
    rb_sys(rb_sys_in)
  {}

  ElasticityRBConstruction & rb_sys;
};

struct ThetaA0 : RBTheta
{
  virtual Number evaluate(const RBParameters &)
  {
    return 1.;
  }
};

struct AssemblyA0 : ElasticityAssembly
{

  AssemblyA0(ElasticityRBConstruction & rb_sys_in) :
    ElasticityAssembly(rb_sys_in)
  {}

  // The interior assembly operator
  virtual void interior_assembly(FEMContext & c);
};

struct ThetaA1 : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("x_scaling");
  }
};

struct AssemblyA1 : ElasticityAssembly
{
  AssemblyA1(ElasticityRBConstruction & rb_sys_in) :
    ElasticityAssembly(rb_sys_in)
  {}

  // The interior assembly operator
  virtual void interior_assembly(FEMContext & c);
};

struct ThetaA2 : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return 1./mu.get_value("x_scaling");
  }
};

struct AssemblyA2 : ElasticityAssembly
{

  AssemblyA2(ElasticityRBConstruction & rb_sys_in)
    :
    ElasticityAssembly(rb_sys_in)
  {}

  // The interior assembly operator
  virtual void interior_assembly(FEMContext & c);
};

struct ThetaF0 : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("load_Fx");
  }
};

struct AssemblyF0 : ElasticityAssembly
{
  AssemblyF0(ElasticityRBConstruction & rb_sys_in)
    :
    ElasticityAssembly(rb_sys_in)
  {}

  // Apply a traction
  virtual void boundary_assembly(FEMContext & c);
};

struct ThetaF1 : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("load_Fy");
  }
};

struct AssemblyF1 : ElasticityAssembly
{
  AssemblyF1(ElasticityRBConstruction & rb_sys_in)
    :
    ElasticityAssembly(rb_sys_in)
  {}

  // Apply a traction
  virtual void boundary_assembly(FEMContext & c);
};

struct ThetaF2 : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("load_Fz");
  }
};

struct AssemblyF2 : ElasticityAssembly
{
  AssemblyF2(ElasticityRBConstruction & rb_sys_in)
    :
    ElasticityAssembly(rb_sys_in)
  {}

  // Apply a traction
  virtual void boundary_assembly(FEMContext & c);
};

struct ThetaPointLoadX : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("point_load_Fx");
  }
};

struct AssemblyPointLoadX : ElemAssembly
{
  AssemblyPointLoadX()
  {}

  // Apply a point load
  virtual void get_nodal_rhs_values(std::map<numeric_index_type, Number> & values,
                                    const System & sys,
                                    const Node & node);

};

struct ThetaPointLoadY : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("point_load_Fy");
  }
};

struct AssemblyPointLoadY : ElemAssembly
{
  AssemblyPointLoadY()
  {}

  // Apply a point load
  virtual void get_nodal_rhs_values(std::map<numeric_index_type, Number> & values,
                                    const System & sys,
                                    const Node & node);

};

struct ThetaPointLoadZ : RBTheta
{
  virtual Number evaluate(const RBParameters & mu)
  {
    return mu.get_value("point_load_Fz");
  }
};

struct AssemblyPointLoadZ : ElemAssembly
{
  AssemblyPointLoadZ()
  {}

  // Apply a point load
  virtual void get_nodal_rhs_values(std::map<numeric_index_type, Number> & values,
                                    const System & sys,
                                    const Node & node);

};

struct InnerProductAssembly : ElasticityAssembly
{

  InnerProductAssembly(ElasticityRBConstruction & rb_sys_in)
    :
    ElasticityAssembly(rb_sys_in)
  {}

  // The interior assembly operator
  virtual void interior_assembly(FEMContext & c);
};

// Define an RBThetaExpansion class for this PDE
struct ElasticityThetaExpansion : RBThetaExpansion
{

  ElasticityThetaExpansion()
  {
    // set up the RBThetaExpansion object
    attach_A_theta(&theta_a_0);
    attach_A_theta(&theta_a_1);
    attach_A_theta(&theta_a_2);
    attach_F_theta(&theta_f_0);
    attach_F_theta(&theta_f_1);
    attach_F_theta(&theta_f_2);
    attach_F_theta(&theta_point_load_x);
    attach_F_theta(&theta_point_load_y);
    attach_F_theta(&theta_point_load_z);
  }

  // The RBTheta member variables
  ThetaA0 theta_a_0;
  ThetaA1 theta_a_1;
  ThetaA2 theta_a_2;
  ThetaF0 theta_f_0;
  ThetaF1 theta_f_1;
  ThetaF2 theta_f_2;
  ThetaPointLoadX theta_point_load_x;
  ThetaPointLoadY theta_point_load_y;
  ThetaPointLoadZ theta_point_load_z;
};

// Define an RBAssemblyExpansion class for this PDE
struct ElasticityAssemblyExpansion : RBAssemblyExpansion
{
  ElasticityAssemblyExpansion(ElasticityRBConstruction & rb_sys_in) :
    A0_assembly(rb_sys_in),
    A1_assembly(rb_sys_in),
    A2_assembly(rb_sys_in),
    F0_assembly(rb_sys_in),
    F1_assembly(rb_sys_in),
    F2_assembly(rb_sys_in)
  {
    // And set up the RBAssemblyExpansion object
    attach_A_assembly(&A0_assembly);
    attach_A_assembly(&A1_assembly);
    attach_A_assembly(&A2_assembly);
    attach_F_assembly(&F0_assembly);
    attach_F_assembly(&F1_assembly);
    attach_F_assembly(&F2_assembly);
    attach_F_assembly(&point_load_assembly_x);
    attach_F_assembly(&point_load_assembly_y);
    attach_F_assembly(&point_load_assembly_z);
  }

  // The ElemAssembly objects
  AssemblyA0 A0_assembly;
  AssemblyA1 A1_assembly;
  AssemblyA2 A2_assembly;
  AssemblyF0 F0_assembly;
  AssemblyF1 F1_assembly;
  AssemblyF2 F2_assembly;
  AssemblyPointLoadX point_load_assembly_x;
  AssemblyPointLoadY point_load_assembly_y;
  AssemblyPointLoadZ point_load_assembly_z;
};

#endif