ASMs3DLag.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ASM_S3D_LAG_H
#define _ASM_S3D_LAG_H
 
#include "ASMs3D.h"
#include "ASMLagBase.h"
 
 
class ASMs3DLag : public ASMs3D, protected ASMLagBase
{
protected:
  class BasisFunctionCache : public ASMs3D::BasisFunctionCache
  {
  public:
    BasisFunctionCache(const ASMs3DLag& pch);
 
    BasisFunctionCache(const ASMs3D::BasisFunctionCache& cache, int b);
 
    virtual ~BasisFunctionCache() = default;
 
    double getParam(int dir, size_t el, size_t gp, bool reduced = false) 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 ASMs3DLag(unsigned char n_f = 3);
  ASMs3DLag(const ASMs3D& patch, unsigned char n_f);
  ASMs3DLag(const ASMs3DLag& patch, unsigned char n_f);
  ASMs3DLag(const ASMs3DLag& patch);
  virtual ~ASMs3DLag() {}
 
 
  // 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 bool getGridParameters(RealArray& prm, int dir, int nSegSpan) const;
 
  virtual void constrainFace(int dir, bool open, int dof,
                             int code = 0, char basis = 1);
 
  virtual void constrainEdge(int lEdge, bool open, int dof,
                             int code = 0, char basis = 1);
 
protected:
  void setCoord(size_t inod, const Vec3& Xnod);
 
  virtual void findBoundaryElms(IntVec& elms, int lIndex, int = 0) const;
 
  virtual int findElement(double u, double v, double w,
                          double* xi = nullptr, double* eta = nullptr,
                          double* zeta = nullptr) const;
 
public:
  virtual bool updateCoords(const Vector& displ);
 
  using ASMLagBase::updateOrigin;
 
 
  // 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);
 
  virtual bool integrateEdge(Integrand& integrand, int lEdge,
                             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 ASMs3D::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;
 
  virtual bool getSize(int& n1, int& n2, int& n3, int = 0) const;
 
  virtual void generateThreadGroups(const Integrand&, bool, bool);
  virtual void generateThreadGroups(char lIndex, bool, bool);
 
  virtual IntMat getElmNodes(int basis) const;
 
  virtual size_t getNoBoundaryElms(char lIndex, char ldim) const;
 
  virtual size_t getNoProjectionNodes() const;
 
  virtual bool assembleL2matrices(SystemMatrix& A, SystemVector& B,
                                  const L2Integrand& integrand,
                                  bool continuous) const;
 
private:
  static void createMNPC(size_t nx, size_t ny, size_t nz,
                         int p1, int p2, int p3, IntMat& MNPC);
 
protected:
  virtual bool evalSolPt(int iel, double xi, double eta, double zeta,
                         size_t nCmp, const Vector& pchSol,
                         RealArray& ptSol, RealArray& N) const;
 
  size_t nx; 
  size_t ny; 
  size_t nz; 
  int    p1; 
  int    p2; 
  int    p3; 
};
 
#endif