ASMs2DLag.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ASM_S2D_LAG_H
#define _ASM_S2D_LAG_H
 
#include "ASMs2D.h"
#include "ASMLagBase.h"
 
 
class ASMs2DLag : public ASMs2D, protected ASMLagBase
{
protected:
  class BasisFunctionCache : public ASMs2D::BasisFunctionCache
  {
  public:
    BasisFunctionCache(const ASMs2DLag& pch);
 
    BasisFunctionCache(const ASMs2D::BasisFunctionCache& cache, int b);
 
    virtual ~BasisFunctionCache() = default;
 
    double getParam(int dir, size_t el, size_t gp, bool reduced) const override;
 
  protected:
    bool internalInit() override;
 
    size_t index(size_t, size_t gp, bool) const override { return gp; }
 
    BasisFunctionVals calculatePt(size_t, size_t gp, bool red) const override;
 
    void calculateAll() override;
 
    void setupParameters() override;
  };
 
public:
  explicit ASMs2DLag(unsigned char n_s = 2, unsigned char n_f = 2);
  ASMs2DLag(const ASMs2DLag& patch, unsigned char n_f);
  ASMs2DLag(const ASMs2DLag& patch);
  virtual ~ASMs2DLag() {}
 
 
  // Methods for model generation
  // ============================
 
  virtual bool write(std::ostream& os, int = 0) const;
 
  virtual bool generateFEMTopology();
 
  virtual void clear(bool retainGeometry = false);
 
  virtual bool addXElms(short int dim, short int item,
                        size_t nXn, IntVec& nodes);
 
  virtual bool getElementCoordinates(Matrix& X, int iel, bool = true) const;
 
  virtual void getNodalCoordinates(Matrix& X, bool = false) const;
 
  virtual Vec3 getCoord(size_t inod) const;
 
  virtual Vec3 getElementCenter(int iel) const;
 
  virtual void constrainEdge(int dir, bool open, int dof, int code, char basis);
 
  virtual size_t getNoProjectionNodes() const;
 
  virtual bool assembleL2matrices(SystemMatrix& A, SystemVector& B,
                                  const L2Integrand& integrand,
                                  bool continuous) const;
 
protected:
  void setCoord(size_t inod, const Vec3& Xnod);
 
  virtual void findBoundaryElms(IntVec& elms, int lIndex, int = 0) const;
 
  int findElement(double u, double v,
                  double* xi = nullptr, double* eta = nullptr) const;
 
  bool integrateElm(Integrand& integrand, GlobalIntegral& glbInt, int iel,
                    ASMs2D::BasisFunctionCache& cache, const TimeDomain& time);
 
public:
  virtual bool updateCoords(const Vector& displ);
 
 
  // Methods for integration of finite element quantities.
  // These are the main computational methods of the ASM class hierarchy.
  // ====================================================================
 
  virtual bool integrate(Integrand& integrand,
                         GlobalIntegral& glbInt, const TimeDomain& time);
 
  virtual bool integrate(Integrand& integrand, int lIndex,
                         GlobalIntegral& glbInt, const TimeDomain& time);
 
 
  // Post-processing methods
  // =======================
 
  virtual int evalPoint(const double* xi, double* param, Vec3& X) const;
 
  virtual bool tesselate(ElementBlock& grid, const int*) const;
 
  using ASMs2D::evalSolution;
  virtual bool evalSolution(Matrix& sField, const Vector& locSol,
                            const int*, int n_f, bool) const;
 
  virtual bool evalSolution(Matrix& sField, const Vector& locSol,
                            const RealArray* gpar, bool regular,
                            int, int) const;
 
  virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,
                            const int*, char) const;
 
  virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,
                            const RealArray* gpar, bool regular) const;
 
  virtual bool evaluate(const ASMbase* basis, const Vector& locVec,
                        RealArray& vec, int basisNum) const;
 
  virtual bool getOrder(int& pu, int& pv, int& pw) const;
 
  using ASMs2D::getSize;
  virtual bool getSize(int& n1, int& n2, int = 0) const;
 
  using ASMs2D::generateThreadGroups;
  virtual void generateThreadGroups(const Integrand&, bool, bool);
 
  virtual IntMat getElmNodes(int basis) const;
 
  virtual size_t getNoBoundaryElms(char lIndex, char ldim) const;
 
private:
  static void createMNPC(size_t nx, size_t ny, int p1, int p2, IntMat& MNPC);
 
protected:
  virtual bool evalSolPt(int iel, double xi, double eta,
                         size_t nCmp, const Vector& pchSol,
                         RealArray& ptSol, RealArray& N) const;
 
  size_t nx; 
  size_t ny; 
  int    p1; 
  int    p2; 
};
 
#endif