ASMu2Dmx.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ASM_U2D_MX_H
#define _ASM_U2D_MX_H
 
#include "ASMu2D.h"
#include "ASMmxBase.h"
 
 
class ASMu2Dmx : public ASMu2D, private ASMmxBase
{
public:
  ASMu2Dmx(unsigned char n_s, const CharVec& n_f);
  ASMu2Dmx(const ASMu2Dmx& patch, const CharVec& n_f = CharVec(2,0));
  virtual ~ASMu2Dmx() {}
 
  virtual const LR::LRSplineSurface* getBasis(int basis = 1) const;
  virtual LR::LRSplineSurface* getBasis(int basis = 1);
 
  // Methods for model generation
  // ============================
 
  virtual bool readBasis(std::istream& is, size_t basis);
 
  virtual bool generateFEMTopology();
 
  virtual void clear(bool retainGeometry);
 
  virtual size_t getNoBasis() const { return m_basis.size(); }
  virtual size_t getNoNodes(int basis) const;
  virtual unsigned char getNoFields(int basis) const;
  virtual unsigned char getNodalDOFs(size_t inod) const;
  virtual char getNodeType(size_t inod) const;
  virtual Vec3 getCoord(size_t inod) const;
 
  virtual void initMADOF(const int* sysMadof);
 
  // 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);
 
 
  // Post-processing methods
  // =======================
 
  virtual bool getSolution(Matrix& sField, const Vector& locSol,
                           const IntVec& nodes) const;
 
  using ASMu2D::evalSolution;
  virtual bool evalSolution(Matrix& sField, const Vector& locSol,
                            const RealArray* gpar, bool,
                            int deriv, int nf) const;
 
  virtual bool evalSolutionPiola(Matrix& sField, const Vector& locSol,
                                 const RealArray* gpar, bool regular) const;
 
  virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,
                            const RealArray* gpar, bool) const;
 
  virtual void extractNodeVec(const RealArray& globVec, RealArray& nodeVec,
                              unsigned char, int basis) const;
 
  virtual bool injectNodeVec(const RealArray& nodeVec, RealArray& globVec,
                             unsigned char, int basis) const;
 
  virtual size_t getNoRefineNodes() const;
 
  virtual size_t getNoRefineElms() const;
 
  using ASMu2D::refine;
  virtual bool refine(const LR::RefineData& prm, Vectors& sol);
 
  virtual void storeMesh(const std::string& fName, int fType) const;
 
  virtual bool connectPatch(int edge, ASM2D& neighbor, int nedge, bool revers,
                            int basis, bool coordCheck, int thick);
 
  virtual void getBoundaryNodes(int lIndex, IntVec& nodes,
                                int basis, int thick, int orient, bool local) const;
 
  virtual void remapErrors(RealArray& errors,
                           const RealArray& origErr, bool elemErrors) const;
 
  virtual bool separateProjectionBasis() const;
 
  bool usePiola() const { return piola; }
 
private:
  void getElementsAt(const RealArray& param,
                     std::vector<int>& elms,
                     std::vector<size_t>* sizes = nullptr) const;
 
protected:
  using ASMu2D::generateThreadGroups;
  void generateThreadGroups(const Integrand& integrand, bool silence,
                            bool ignoreGlobalLM);
 
private:
  using SplinePtr = std::shared_ptr<LR::LRSplineSurface>; 
 
  std::vector<SplinePtr> m_basis;      
  LR::LRSplineSurface*   threadBasis;  
};
 
#endif