Integrand.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _INTEGRAND_H
#define _INTEGRAND_H
 
#include "SIMenums.h"
#include <vector>
#include <string>
 
struct TimeDomain;
class LocalIntegral;
class FiniteElement;
class MxFiniteElement;
class Vec3;
 
 
class Integrand
{
protected:
  Integrand() {}
 
public:
  virtual ~Integrand() {}
 
  virtual void setNeumannOrder(char) {}
 
  virtual void initPatch(size_t) {}
 
 
  // Element-level initialization interface
  // ======================================
 
  virtual LocalIntegral* getLocalIntegral(size_t nen, size_t iEl,
                                          bool neumann = false) const = 0;
  virtual LocalIntegral* getLocalIntegral(const std::vector<size_t>& nen,
                                          size_t iEl,
                                          bool neumann = false) const
  {
    return this->getLocalIntegral(nen.front(),iEl,neumann);
  }
 
  virtual bool initElement(const std::vector<int>& MNPC,
                           const FiniteElement& fe,
                           const Vec3& X0, size_t nPt,
                           LocalIntegral& elmInt) = 0;
  virtual bool initElement(const std::vector<int>& MNPC,
                           LocalIntegral& elmInt) = 0;
  virtual bool initElement(const std::vector<int>& MNPC,
                           const std::vector<size_t>& elem_sizes,
                           const std::vector<size_t>& basis_sizes,
                           LocalIntegral& elmInt) = 0;
  virtual bool initElement(const std::vector<int>& MNPC,
                           const MxFiniteElement& fe,
                           const std::vector<size_t>& elem_sizes,
                           const std::vector<size_t>& basis_sizes,
                           LocalIntegral& elmInt) = 0;
 
  virtual bool initElementBou(const std::vector<int>& MNPC,
                              LocalIntegral& elmInt) = 0;
  virtual bool initElementBou(const std::vector<int>& MNPC,
                              const std::vector<size_t>& elem_sizes,
                              const std::vector<size_t>& basis_sizes,
                              LocalIntegral& elmInt) = 0;
 
 
  // Integrand evaluation interface
  // ==============================
 
  enum Traits {
    STANDARD           = 0, 
    NO_DERIVATIVES     = 1, 
    SECOND_DERIVATIVES = 1<< 1, 
    THIRD_DERIVATIVES  = 1<< 2, 
    AVERAGE            = 1<< 3, 
    ELEMENT_CORNERS    = 1<< 4, 
    ELEMENT_CENTER     = 1<< 5, 
    G_MATRIX           = 1<< 6, 
    NODAL_ROTATIONS    = 1<< 7, 
    XO_ELEMENTS        = 1<< 8, 
    INTERFACE_TERMS    = 1<< 9, 
    NORMAL_DERIVS      = 1<<10, 
    UPDATED_NODES      = 1<<11, 
    PIOLA_MAPPING      = 1<<12, 
    POINT_DEFORMATION  = 1<<13, 
  };
 
  virtual SIM::SolutionMode getMode(bool = false) const = 0;
  virtual int getIntegrandType() const { return STANDARD; }
  virtual int getReducedIntegration(int) const { return 0; }
  virtual int getBouIntegrationPoints(int nGP) const { return nGP; }
 
  virtual bool reducedInt(LocalIntegral& elmInt,
                          const FiniteElement& fe, const Vec3& X) const
  {
    return false;
  }
 
  virtual bool evalInt(LocalIntegral& elmInt, const FiniteElement& fe,
                       const TimeDomain& time, const Vec3& X) const
  {
    return this->evalInt(elmInt,fe,X);
  }
 
  virtual bool evalIntMx(LocalIntegral& elmInt, const MxFiniteElement& fe,
                         const TimeDomain& time, const Vec3& X) const
  {
    return this->evalIntMx(elmInt,fe,X);
  }
 
  virtual bool evalInt(LocalIntegral& elmInt, const FiniteElement& fe,
                       const TimeDomain& time,
                       const Vec3& X, const Vec3& normal) const
  {
    return this->evalInt(elmInt,fe,X,normal);
  }
 
  virtual bool evalIntMx(LocalIntegral& elmInt, const MxFiniteElement& fe,
                         const TimeDomain& time,
                         const Vec3& X, const Vec3& normal) const
  {
    return this->evalIntMx(elmInt,fe,X,normal);
  }
 
  virtual bool evalPoint(LocalIntegral& elmInt, const FiniteElement& fe,
                         const Vec3& pval) { return false; }
 
  virtual bool finalizeElement(LocalIntegral& elmInt, const FiniteElement& fe,
                               const TimeDomain& time, size_t iGP = 0)
  {
    return this->finalizeElement(elmInt,time,iGP);
  }
 
  virtual bool finalizeElementBou(LocalIntegral& elmInt,
                                  const FiniteElement& fe,
                                  const TimeDomain& time)
  {
    return true;
  }
 
  virtual bool evalBou(LocalIntegral& elmInt, const FiniteElement& fe,
                       const TimeDomain& time,
                       const Vec3& X, const Vec3& normal) const
  {
    return this->evalBou(elmInt,fe,X,normal);
  }
 
  virtual bool evalBouMx(LocalIntegral& elmInt, const MxFiniteElement& fe,
                         const TimeDomain& time,
                         const Vec3& X, const Vec3& normal) const
  {
    return this->evalBouMx(elmInt,fe,X,normal);
  }
 
protected:
  virtual bool evalInt(LocalIntegral&, const FiniteElement& fe,
                       const Vec3&) const { return false; }
  virtual bool evalIntMx(LocalIntegral&, const MxFiniteElement& fe,
                         const Vec3&) const { return false; }
  virtual bool evalInt(LocalIntegral&, const FiniteElement& fe,
                       const Vec3&, const Vec3&) const { return false; }
  virtual bool evalIntMx(LocalIntegral&, const MxFiniteElement& fe,
                         const Vec3&, const Vec3&) const { return false; }
 
  virtual bool evalBou(LocalIntegral&, const FiniteElement&,
                       const Vec3&, const Vec3&) const { return false; }
  virtual bool evalBouMx(LocalIntegral&, const MxFiniteElement&,
                         const Vec3&, const Vec3&) const { return false; }
 
  virtual bool finalizeElement(LocalIntegral& elmInt, const TimeDomain&, size_t)
  {
    return this->finalizeElement(elmInt);
  }
  virtual bool finalizeElement(LocalIntegral&) { return true; }
 
public:
  virtual void setParam(const std::string&, double) {}
  virtual void setParam(const std::string&, const Vec3&) {}
};
 
#endif