ASMs2DmxLag.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ASM_S2D_MX_LAG_H
#define _ASM_S2D_MX_LAG_H
 
#include "ASMs2DLag.h"
#include "ASMmxBase.h"
#include <array>
 
 
class ASMs2DmxLag : public ASMs2DLag, private ASMmxBase
{
protected:
  class BasisFunctionCache : public ASMs2DLag::BasisFunctionCache
  {
  public:
    BasisFunctionCache(const ASMs2DLag& pch);
 
    BasisFunctionCache(const ASMs2D::BasisFunctionCache& cache, int b);
 
    virtual ~BasisFunctionCache() = default;
 
  protected:
    BasisFunctionVals calculatePt(size_t, size_t gp, bool red) const override;
 
    void calculateAll() override;
  };
 
public:
  ASMs2DmxLag(unsigned char n_s, const CharVec& n_f);
  ASMs2DmxLag(const ASMs2DmxLag& patch, const CharVec& n_f = CharVec(2,0));
  virtual ~ASMs2DmxLag() {}
 
 
  // Methods for model generation
  // ============================
 
  virtual bool generateFEMTopology();
 
  virtual void clear(bool retainGeometry);
 
  virtual size_t getNoBasis() const { return 2; }
  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 void initMADOF(const int* sysMadof);
 
  virtual bool connectPatch(int edge, ASM2D& neighbor, int nedge, bool revers,
                            int basis, bool coordCheck, int thick);
 
  virtual void closeBoundaries(int dir, int, int);
 
 
  // 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 bool getSolution(Matrix& sField, const Vector& locSol,
                           const IntVec& nodes) const;
 
  using ASMs2DLag::evalSolution;
  virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,
                            const int*, char = 0) const;
 
  virtual bool evalSolution(Matrix& sField, const Vector& locSol,
                            const RealArray*, bool, int, int nf) 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;
 
protected:
 
  // Internal utility methods
  // ========================
 
  using ASMs2DLag::getSize;
  virtual bool getSize(int& n1, int& n2, int basis) const;
 
private:
  std::vector<size_t> nxx; 
  std::vector<size_t> nyx; 
 
  std::vector< std::array<size_t,2> > elem_sizes; 
};
 
#endif