ASMs2D.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ASM_S2D_H
#define _ASM_S2D_H
 
#include "ASMstruct.h"
#include "ASM2D.h"
#include "BasisFunctionCache.h"
#include "Interface.h"
#include "ThreadGroups.h"
 
namespace utl {
  class Point;
}
 
namespace Go {
  class SplineCurve;
  class SplineSurface;
}
 
 
class ASMs2D : public ASMstruct, public ASM2D
{
  struct IJ
  {
    int I = 0; 
    int J = 0; 
  };
 
  using IndexVec = std::vector<IJ>; 
 
  struct Edge
  {
    int icnod = 0; 
    int incr  = 0; 
    int next();    
  };
 
protected:
  class BasisFunctionCache : public ::BasisFunctionCache<2>
  {
  public:
    BasisFunctionCache(const ASMs2D& pch);
 
    BasisFunctionCache(const BasisFunctionCache& cache, int b);
 
    const std::array<size_t,2>& noElms() const { return nel; }
 
  protected:
    bool internalInit() override;
 
    BasisFunctionVals calculatePt(size_t el, size_t gp,
                                  bool reduced) const override;
 
    void calculateAll() override;
 
    size_t index(size_t el, size_t gp, bool reduced) const override;
 
    virtual void setupParameters();
 
    bool setupQuadrature();
 
    const ASMs2D& patch; 
 
    std::array<size_t,2> nel{}; 
 
  private:
    std::array<size_t,2> elmIndex(size_t el) const;
  };
 
public:
  struct BlockNodes
  {
    int  ibnod[4]; 
    Edge edges[4]; 
    int  iinod;    
    int  inc[2];   
    int  nnodI;    
    int  indxI;    
 
    BlockNodes()
    {
      memset(ibnod,0,4*sizeof(int));
      iinod = inc[0] = inc[1] = nnodI = 0;
      indxI = 1;
    }
    int next();
  };
 
private:
  struct DirichletEdge
  {
    Go::SplineCurve*   curve; 
    int                dof;   
    int                code;  
    std::vector<Ipair> nodes; 
 
    DirichletEdge(Go::SplineCurve* sc = nullptr, int d = 0, int c = 0)
    : curve(sc), dof(d), code(c) {}
  };
 
public:
  class InterfaceChecker : public ASM::InterfaceChecker
  {
  protected:
    const ASMs2D& myPatch; 
  public:
    explicit InterfaceChecker(const ASMs2D& pch) : myPatch(pch) {}
    virtual short int hasContribution(int, int I, int J, int = -1) const;
  };
 
  ASMs2D(unsigned char n_s = 2, unsigned char n_f = 2);
  ASMs2D(const ASMs2D& patch, unsigned char n_f);
  ASMs2D(const ASMs2D& patch);
  virtual ~ASMs2D();
 
  virtual Go::SplineCurve* getBoundary(int dir, int = 1);
  virtual Go::SplineSurface* getBasis(int basis = 1);
  virtual const Go::SplineSurface* getBasis(int basis = 1) const;
  virtual void copyParameterDomain(const ASMbase* other);
 
 
  // Methods for model generation
  // ============================
 
  virtual bool read(std::istream&);
  virtual bool write(std::ostream&, int) const;
 
  virtual bool generateFEMTopology();
 
  virtual void clear(bool retainGeometry = false);
 
  virtual bool addXElms(short int dim, short int item,
                        size_t nXn, IntVec& nodes);
 
  bool addInterfaceElms(const ASM::InterfaceChecker& iChk);
 
  virtual size_t getNodeIndex(int globalNum, bool noAddedNodes = false) const;
  virtual int getNodeID(size_t inod, bool noAddedNodes = false) const;
 
  virtual bool getElementCoordinates(Matrix& X, int iel,
                                     bool forceItg = false) const;
 
  virtual void getNodalCoordinates(Matrix& X, bool geo = false) const;
 
  virtual Vec3 getCoord(size_t inod) const;
 
  virtual Vec3 getElementCenter(int iel) const;
 
  virtual bool updateCoords(const Vector& displ);
 
  virtual void getBoundaryNodes(int lIndex, IntVec& nodes,
                                int basis, int thick = 1,
                                int = 0, bool local = false) const;
 
  virtual int getCorner(int I, int J, int basis) const;
 
  bool assignNodeNumbers(BlockNodes& nodes, int basis = 0);
 
  virtual bool checkRightHandSystem();
 
  virtual bool refine(int dir, const RealArray& xi, double scale = 1.0);
  virtual bool uniformRefine(int dir, int nInsert);
  virtual bool raiseOrder(int ru, int rv);
 
  virtual bool createProjectionBasis(bool init);
 
  virtual bool separateProjectionBasis() const;
 
 
  // Various methods for preprocessing of boundary conditions and patch topology
  // ===========================================================================
 
  virtual void constrainEdge(int dir, bool open, int dof, int code, char basis);
  virtual size_t constrainEdgeLocal(int dir, bool open, int dof, int code,
                                    bool project = false);
 
  virtual void constrainCorner(int I, int J, int dof,
                               int code = 0, char basis = 1);
  virtual void constrainNode(double xi, double eta, int dof, int code = 0);
 
  virtual bool connectPatch(int edge, ASM2D& neighbor, int nedge, bool revers,
                            int = 0, bool coordCheck = true, int thick = 1);
 
  virtual void closeBoundaries(int dir, int basis, int master);
 
  virtual bool collapseEdge(int dir, int basis = 1);
 
  virtual bool addRigidCpl(int lindx, int ldim, int basis,
                           int& gMaster, const Vec3& Xmaster, bool extraPt);
 
  virtual void setNodeNumbers(const IntVec& nodes);
 
  virtual bool updateDirichlet(const std::map<int,RealFunc*>& func,
                               const std::map<int,VecFunc*>& vfunc, double time,
                               const std::map<int,int>* g2l, bool tangent);
 
  virtual bool selfInterconnect(const std::vector<Ipair>& nodes, double xtol);
 
 
  // 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 integrate(Integrand& integrand,
                         GlobalIntegral& glbInt, const TimeDomain& time,
                         const ASM::InterfaceChecker& iChk);
 
protected:
  bool integrate(Integrand& integrand, GlobalIntegral& glbInt,
                 const TimeDomain& time, const Real3DMat& itgPts);
 
public:
 
  // Post-processing methods
  // =======================
 
  virtual int evalPoint(const double* xi, double* param, Vec3& X) const;
 
  virtual int findElementContaining(const double* param) const;
 
  virtual double findPoint(Vec3& X, double* param) const;
 
  virtual bool getGridParameters(RealArray& prm, int dir, int nSegSpan) const;
 
  virtual bool tesselate(ElementBlock& grid, const int* npe) const;
 
  virtual bool evalSolution(Matrix& sField, const Vector& locSol,
                            const int* npe, int n_f, bool piola) const;
 
  virtual bool evalSolution(Matrix& sField, const Vector& locSol,
                            const RealArray* gpar, bool regular = true,
                            int deriv = 0, int = 0) const;
 
  virtual bool evalProjSolution(Matrix& sField, const Vector& locSol,
                                const int* npe, int n_f) const;
 
  virtual bool evaluate(const ASMbase* basis, const Vector& locVec,
                        RealArray& vec, int basisNum) const;
 
  virtual bool evaluate(const Field* field, RealArray& vec, int basisNum) const;
 
  virtual bool evaluate(const FunctionBase* func, RealArray& vec,
                        int basisNum, double time) const;
 
  virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,
                            const int* npe = nullptr, char project = 0) const;
 
private:
  Go::SplineSurface* projectSolution(const IntegrandBase& integrand) const;
 
  Go::SplineSurface* scRecovery(const IntegrandBase&) const;
 
  Go::SplineSurface* projectSolutionLocal(const IntegrandBase&) const;
 
  Go::SplineSurface* projectSolutionLocalApprox(const IntegrandBase&) const;
 
  Go::SplineSurface* projectSolutionLeastSquare(const IntegrandBase&) const;
 
public:
  virtual Go::GeomObject* evalSolution(const IntegrandBase& integrand) const;
 
  virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,
                            const RealArray* gpar, bool regular = true) const;
 
protected:
 
  // Internal utility methods
  // ========================
 
  virtual void findBoundaryElms(IntVec& elms, int lIndex, int = 0) const;
 
  virtual bool assembleL2matrices(SystemMatrix& A, SystemVector& B,
                                  const L2Integrand& integrand,
                                  bool continuous) const;
 
  bool connectBasis(int edge, ASMs2D& neighbor, int nedge, bool revers,
                    int basis = 1, int slave = 0, int master = 0,
                    bool coordCheck = true, int thick = 1);
 
  void getGaussPointParameters(RealArray& uGP, int dir,
                               int nGauss, const double* xi) const;
 
  bool getGrevilleParameters(RealArray& prm, int dir, int basisNum = 1) const;
 
  bool getQuasiInterplParameters(RealArray& prm, int dir) const;
 
  double getParametricArea(int iel) const;
  double getParametricLength(int iel, int dir) const;
 
  bool getElementCoordinatesPrm(Matrix& X, double u, double v) const;
 
  void getElementBorders(int i1, int i2, double* u, double* v) const;
  virtual void getElementBorders(int iel, double* u) const;
 
  double getElementCorners(int i1, int i2, std::vector<Vec3>& XC,
                           RealArray* uC = nullptr) const;
  void getCornerPoints(int i1, int i2, std::vector<utl::Point>& XC) const;
 
  using ASMbase::generateThreadGroups;
  virtual void generateThreadGroups(const Integrand& integrand, bool silence,
                                    bool ignoreGlobalLM);
 
  virtual void changeNumThreads();
 
  void generateThreadGroups(size_t strip1, size_t strip2,
                            bool silence, bool ignoreGlobalLM);
 
  virtual void generateThreadGroupsFromElms(const IntVec& elms);
 
  virtual void generateProjThreadGroupsFromElms(const IntVec& elms);
 
  virtual bool validateThreadGroups(const SAM* sam) const;
 
  virtual int getFirstItgElmNode() const { return 0; }
  virtual int getLastItgElmNode() const;
 
public:
  static void scatterInd(int n1, int n2, int p1, int p2,
                         const int* start, IntVec& index);
 
private:
  bool getOrder(int& p1, int& p2) const;
 
public:
  virtual bool getOrder(int& p1, int& p2, int& p3) const;
 
  virtual bool getSize(int& n1, int& n2, int basis = 0) const;
 
  virtual bool getSize(int& n1, int& n2, int& n3, int basis) const;
 
  virtual bool getNoStructElms(int& n1, int& n2, int& n3) const;
 
  virtual void getElmConnectivities(IntMat& neigh,
                                    int basis = ASM::INTEGRATION_BASIS) const;
 
  virtual IntMat getElmNodes(int basis) const;
 
  virtual size_t getNoBoundaryElms(char lIndex, char ldim) const;
 
  virtual size_t getNoNodes(int basis = 0) const;
  virtual size_t getNoProjectionNodes() const;
 
  virtual bool getParameterDomain(Real2DMat& u, IntVec* corners) const;
 
  virtual void evaluateBasis(double u, double v, double, Vector& N) const;
 
  void extractBasis(double u, double v, Vector& N, Matrix& dNdu,
                    bool fromRight = true) const;
  void extractBasis(double u, double v, Vector& N,
                    Matrix& dNdu, Matrix3D& d2Ndu2,
                    bool fromRight = true) const;
  void extractBasis(double u, double v, int dir, int p, Vector& dN,
                    bool fromRight = true) const;
 
  virtual Field* getProjectedField(const Vector& coefs) const;
 
  virtual Fields* getProjectedFields(const Vector& coefs, size_t = 0) const;
 
private:
  int coeffInd(size_t inod) const;
 
  static void createMNPC(const Go::SplineSurface* srf, IntMat& MNPC);
 
protected:
  std::shared_ptr<Go::SplineSurface> surf; 
  Go::SplineCurve* bou[4]; 
  bool              swapV; 
 
  const IndexVec& nodeInd; 
  IndexVec      myNodeInd; 
 
  std::map<size_t,size_t> xnMap; 
  std::map<size_t,size_t> nxMap; 
 
  std::vector<DirichletEdge> dirich;
 
  ThreadGroups threadGroups;
 
  std::vector<std::unique_ptr<BasisFunctionCache>> myCache;
};
 
#endif