IntegrandBase.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _INTEGRAND_BASE_H
#define _INTEGRAND_BASE_H
 
#include "Integrand.h"
#include "ASMenums.h"
#include "LinAlgenums.h"
#include "MatVec.h"
#include <map>
 
class ASMbase;
class NormBase;
class ForceBase;
class GlobalIntegral;
class AnaSol;
class VTF;
class Field;
class Fields;
class VecFunc;
class TensorFunc;
class STensorFunc;
namespace tinyxml2 { class XMLElement; }
 
 
class IntegrandBase : public Integrand
{
protected:
  explicit IntegrandBase(unsigned short int n) : nsd(n), npv(1), myTime(0.0),
                                                 m_mode(SIM::INIT) {}
 
public:
  virtual bool parse(const tinyxml2::XMLElement*) { return false; }
 
  virtual void printLog() const {}
 
 
  // Global initialization interface
  // ===============================
 
  virtual void setMode(SIM::SolutionMode mode);
  SIM::SolutionMode getMode(bool = false) const override { return m_mode; }
  virtual void setIntegrationPrm(unsigned short int, double) {}
  virtual double getIntegrationPrm(unsigned short int) const { return 0.0; }
  virtual void initIntegration(size_t, size_t) {}
  virtual void initIntegration(const TimeDomain&, const Vector&, bool = false){}
  virtual void initLHSbuffers(size_t) {}
  virtual void initMatrixBuffers(size_t, size_t ielMax)
  { this->initLHSbuffers(ielMax); }
  virtual void initResultPoints(double time, char = 0) { myTime = time; }
  virtual void initNodeMap(const std::vector<int>&) {}
  virtual void setSecondaryInt(GlobalIntegral* = nullptr) {}
  virtual GlobalIntegral& getGlobalInt(GlobalIntegral* gq) const;
  virtual void initForPatch(const ASMbase*) {}
 
 
  // Element-level initialization interface
  // ======================================
 
  using Integrand::getLocalIntegral;
  LocalIntegral* getLocalIntegral(size_t nen, size_t iEl,
                                  bool neumann) const override;
 
protected:
  bool initElement1(const std::vector<int>& MNPC, Vectors& elmVec,
                    size_t nskip = 0) const;
  bool initElement2(const std::vector<int>& MNPC, Vectors& elmVec,
                    size_t nskip = 0) const;
 
public:
  bool initElement(const std::vector<int>& MNPC,
                   LocalIntegral& elmInt) override;
  bool initElement(const std::vector<int>& MNPC,
                   const FiniteElement& fe,
                   const Vec3& X0, size_t nPt, LocalIntegral& elmInt) override;
  bool initElement(const std::vector<int>& MNPC,
                   const std::vector<size_t>& elem_sizes,
                   const std::vector<size_t>& basis_sizes,
                   LocalIntegral& elmInt) override;
  bool initElement(const std::vector<int>& MNPC,
                   const MxFiniteElement& fe,
                   const std::vector<size_t>& elem_sizes,
                   const std::vector<size_t>& basis_sizes,
                   LocalIntegral& elmInt) override;
 
  bool initElementBou(const std::vector<int>& MNPC,
                      LocalIntegral& elmInt) override;
  bool initElementBou(const std::vector<int>& MNPC,
                      const std::vector<size_t>& elem_sizes,
                      const std::vector<size_t>& basis_sizes,
                      LocalIntegral& elmInt) override;
 
  virtual bool hasInteriorTerms() const { return true; }
  virtual bool hasBoundaryTerms() const { return true; }
 
  void activateElmGroup(const std::vector<int>& elms = {}) { elmGrp = elms; }
  bool inActive(int iel) const;
 
 
  // Secondary solution field evaluation interface
  // =============================================
 
  bool evalSol1(Vector& s, const FiniteElement& fe, const Vec3& X,
                const std::vector<int>& MNPC, size_t nskip = 0) const;
 
  virtual bool evalSol2(Vector& s, const Vectors& elmVec,
                        const FiniteElement& fe, const Vec3& X) const;
 
  virtual bool evalSol(Vector& s, const FiniteElement& fe, const Vec3& X,
                       const std::vector<int>& MNPC) const;
 
  virtual bool evalSol(Vector& s, const MxFiniteElement& fe, const Vec3& X,
                       const std::vector<int>& MNPC,
                       const std::vector<size_t>& elem_sizes,
                       const std::vector<size_t>& basis_sizes) const;
 
  virtual bool evalSol(Vector& s,
                       const TensorFunc& asol, const Vec3& X) const;
 
  virtual bool evalSol(Vector& s,
                       const STensorFunc& asol, const Vec3& X) const;
 
  virtual bool evalSol(Vector& s,
                       const VecFunc& asol, const Vec3& X) const;
 
  virtual bool getPrincipalDir(Matrix&, size_t, size_t) const { return false; }
 
  virtual size_t getNo2ndSolPerLine() const { return 999; }
 
  virtual void primaryScalarFields(Matrix&) {}
 
 
  // Various service methods
  // =======================
 
  virtual int derivativeOrder() const { return 1; }
 
  virtual bool writeGlvT(VTF*, int, int&, int&) const { return true; }
 
  virtual bool hasTractionValues() const { return false; }
 
  virtual bool diverged(size_t = 0) const { return false; }
 
  virtual NormBase* getNormIntegrand(AnaSol* = nullptr) const
  { return nullptr; }
  virtual ForceBase* getForceIntegrand(const Vec3*, AnaSol* = nullptr) const
  { return nullptr; }
  virtual ForceBase* getForceIntegrand() const { return nullptr; }
 
  size_t getNoSpaceDim() const { return nsd; }
  virtual size_t getNoFields(int = 2) const { return 0; }
  virtual size_t getNoElmFields() const { return 0; }
  virtual size_t getNoGLMs() const { return 0; }
 
  virtual std::string getField1Name(size_t idx, const char* prefix = 0) const;
  virtual std::string getField2Name(size_t idx, const char* prefix = 0) const;
  virtual std::string getEFieldName(size_t idx) const;
  virtual bool suppressOutput(size_t, ASM::ResultClass) const { return false; }
 
  virtual size_t getNoSolutions(bool = true) const { return primsol.size(); }
 
  virtual Vector* getExtractionField(size_t = 1) { return nullptr; }
  Vector& getSolution(size_t n = 0) { return primsol[n]; }
  Vectors& getSolutions() { return primsol; }
 
  void resetSolution();
 
  void printSolution(std::ostream& os, int pindx);
 
  virtual void setNamedField(const std::string&, Field*);
  virtual void setNamedFields(const std::string&, Fields*);
 
  Vector* getNamedVector(const std::string& name) const;
 
  virtual LinAlg::LinearSystemType getLinearSystemType() const
  {
    return LinAlg::GENERAL_MATRIX;
  }
 
  void registerVector(const std::string& name, Vector* vec);
 
  virtual void getNodalDofTypes(std::vector<char>&) const {}
 
  double getTimeLevel() const { return myTime; }
 
private:
  std::map<std::string,Vector*> myFields; 
 
protected:
  unsigned short int nsd;     
  unsigned short int npv;     
  double             myTime;  
  SIM::SolutionMode  m_mode;  
  std::vector<int>   elmGrp;  
  Vectors            primsol; 
};
 
 
using LintegralVec = std::vector<LocalIntegral*>; 
 
 
class NormBase : public Integrand
{
protected:
  explicit NormBase(IntegrandBase& p) : myProblem(p), projBou(false), nrcmp(0),
                                        lints(nullptr), finalOp(ASM::SQRT) {}
 
public:
  virtual ~NormBase();
 
  virtual void initIntegration(size_t, size_t) {}
  void initProjection(size_t nproj);
  void setLocalIntegrals(LintegralVec* elementNorms) { lints = elementNorms; }
  virtual void initForPatch(const ASMbase*) {}
 
  using Integrand::getLocalIntegral;
  LocalIntegral* getLocalIntegral(size_t, size_t iEl, bool) const override;
 
  bool initElement(const std::vector<int>& MNPC,
                   LocalIntegral& elmInt) override;
  bool initElement(const std::vector<int>& MNPC,
                   const FiniteElement& fe, const Vec3& X0, size_t nPt,
                   LocalIntegral& elmInt) override;
  bool initElement(const std::vector<int>& MNPC,
                   const std::vector<size_t>& elem_sizes,
                   const std::vector<size_t>& basis_sizes,
                   LocalIntegral& elmInt) override;
  bool initElement(const std::vector<int>& MNPC,
                   const MxFiniteElement&,
                   const std::vector<size_t>& elem_sizes,
                   const std::vector<size_t>& basis_sizes,
                   LocalIntegral& elmInt) override
  { return this->initElement(MNPC,elem_sizes,basis_sizes,elmInt); }
 
 
  bool initElementBou(const std::vector<int>& MNPC,
                      LocalIntegral& elmInt) override;
  bool initElementBou(const std::vector<int>& MNPC,
                      const std::vector<size_t>& elem_sizes,
                      const std::vector<size_t>& basis_sizes,
                      LocalIntegral& elmInt) override;
 
  virtual bool hasBoundaryTerms() const { return false; }
 
  void activateElmGroup(const std::vector<int>& elms = {})
  {
    myProblem.activateElmGroup(elms);
  }
 
  void addBoundaryTerms(Vectors& gNorm, double energy) const;
 
  virtual size_t getNoFields(int group = 0) const;
 
  virtual std::string getName(size_t i, size_t j, const char* prefix = 0) const;
 
  virtual bool hasElementContributions(size_t, size_t) const { return true; }
 
  Vector& getProjection(size_t i);
 
  void setFinalOperation(ASM::FinalNormOp op) { finalOp = op; }
  ASM::FinalNormOp getFinalOperation() { return finalOp; }
 
  int getIntegrandType() const override;
  int getReducedIntegration(int n) const override;
 
  bool reducedInt(LocalIntegral& elmInt,
                  const FiniteElement& fe, const Vec3& X) const override;
 
  virtual bool hasExternalProjections() const { return false; }
 
  virtual void setProjectedFields(Fields* f, size_t idx);
 
  void setParam(const std::string& name, double value) override
  {
    myProblem.setParam(name,value);
  }
  void setParam(const std::string& name, const Vec3& value) override
  {
    myProblem.setParam(name,value);
  }
 
  SIM::SolutionMode getMode(bool) const override { return myProblem.getMode(); }
 
protected:
  bool initProjection(const std::vector<int>& MNPC, LocalIntegral& elmInt,
                      size_t nExtraNodes = 0);
 
  double applyFinalOp(double value) const;
 
  IntegrandBase& myProblem; 
 
  std::vector<Fields*> prjFld; 
 
  Vectors prjsol; 
  bool   projBou; 
 
  unsigned short int nrcmp;   
  LintegralVec*      lints;   
  ASM::FinalNormOp   finalOp; 
};
 
 
class ForceBase : public Integrand
{
protected:
  explicit ForceBase(IntegrandBase& p) : myProblem(p), eBuffer(nullptr) {}
 
public:
  virtual ~ForceBase();
 
  void initBuffer(size_t nel);
 
  void assemble(RealArray& force) const;
 
  virtual void initIntegration(size_t, size_t) {}
 
  using Integrand::getLocalIntegral;
  LocalIntegral* getLocalIntegral(size_t, size_t iEl,
                                  bool = false) const override;
 
  bool initElement(const std::vector<int>&,
                   LocalIntegral&) override { return false; }
 
  bool initElement(const std::vector<int>&,
                   const FiniteElement&, const Vec3&, size_t,
                   LocalIntegral&) override { return false; }
 
  bool initElement(const std::vector<int>&,
                   const std::vector<size_t>&,
                   const std::vector<size_t>&,
                   LocalIntegral&) override { return false; }
 
  bool initElement(const std::vector<int>&,
                   const MxFiniteElement&,
                   const std::vector<size_t>&,
                   const std::vector<size_t>&,
                   LocalIntegral&) override { return false; }
 
  bool initElementBou(const std::vector<int>& MNPC,
                      LocalIntegral& elmInt) override;
  bool initElementBou(const std::vector<int>& MNPC,
                      const std::vector<size_t>& elem_sizes,
                      const std::vector<size_t>& basis_sizes,
                      LocalIntegral& elmInt) override;
 
  virtual size_t getNoComps() const = 0;
 
  virtual bool hasInteriorTerms() const { return false; }
  virtual bool hasBoundaryTerms() const { return true; }
 
  void setParam(const std::string& name, double value) override
  {
    myProblem.setParam(name,value);
  }
  void setParam(const std::string& name, const Vec3& value) override
  {
    myProblem.setParam(name,value);
  }
 
  SIM::SolutionMode getMode(bool) const override { return myProblem.getMode(); }
 
protected:
  void clearBuffer();
 
  IntegrandBase& myProblem; 
  LintegralVec      eForce; 
  double*          eBuffer; 
};
 
#endif