GlbL2projector.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _GLB_L2_PROJECTOR_H
#define _GLB_L2_PROJECTOR_H
 
#include "Integrand.h"
#include "LinAlgenums.h"
#include "MatVec.h"
 
class ASMbase;
class IntegrandBase;
class FunctionBase;
class LinSolParams;
class SparseMatrix;
class StdVector;
class ProcessAdm;
 
typedef std::vector<int>           IntVec;      
typedef std::vector<size_t>        uIntVec;     
typedef std::vector<FunctionBase*> FunctionVec; 
 
 
class L2Integrand
{
public:
  L2Integrand(const ASMbase& patch, const ProcessAdm& adm)
    : m_patch(patch), m_adm(adm) {}
 
  virtual bool evaluate(Matrix& sField, const RealArray* gpar) const = 0;
 
  virtual size_t dim() const = 0;
 
  const ProcessAdm& getAdm() const { return m_adm; }
 
protected:
  const ASMbase& m_patch; 
  const ProcessAdm& m_adm; 
};
 
 
class L2ProbIntegrand : public L2Integrand
{
public:
  L2ProbIntegrand(const ASMbase& patch,
                  const IntegrandBase& itg,
                  const ProcessAdm& adm);
 
  bool evaluate(Matrix& sField, const RealArray* gpar) const override;
 
  size_t dim() const override;
 
private:
  const IntegrandBase& m_itg; 
};
 
 
class L2FuncIntegrand : public L2Integrand
{
public:
  L2FuncIntegrand(const ASMbase& patch,
                  const FunctionBase& func,
                  const ProcessAdm& adm);
 
  bool evaluate(Matrix& sField, const RealArray* gpar) const override;
 
  size_t dim() const override;
 
private:
  const FunctionBase& m_func; 
};
 
 
class GlbL2 : public Integrand
{
public:
  static LinAlg::MatrixType MatrixType;   
  static LinSolParams*      SolverParams; 
 
  GlbL2(IntegrandBase* p, size_t n);
  GlbL2(FunctionBase* f, size_t n);
  GlbL2(const FunctionVec& f, size_t n);
  virtual ~GlbL2();
 
  virtual SIM::SolutionMode getMode(bool) const { return SIM::RECOVERY; }
  virtual int getIntegrandType() const;
 
  using Integrand::getLocalIntegral;
  virtual LocalIntegral* getLocalIntegral(size_t nen, size_t iEl,
                                          bool neumann) const;
 
  virtual bool initElement(const IntVec& MNPC, const FiniteElement& fe,
                           const Vec3& X0, size_t nPt,
                           LocalIntegral& elmInt);
  virtual bool initElement(const IntVec& MNPC1,
                           const MxFiniteElement& fe,
                           const uIntVec& elem_sizes,
                           const uIntVec& basis_sizes,
                           LocalIntegral& elmInt);
 
  virtual bool initElement(const IntVec& MNPC1,
                           const uIntVec& elem_sizes,
                           const uIntVec& basis_sizes,
                           LocalIntegral& elmInt) { return false; }
  virtual bool initElement(const IntVec&, LocalIntegral&) { return false; }
  virtual bool initElementBou(const IntVec&, LocalIntegral&) { return false; }
  virtual bool initElementBou(const IntVec&, const uIntVec&, const uIntVec&,
                              LocalIntegral&) { return false; }
 
  using Integrand::evalInt;
  virtual bool evalInt(LocalIntegral& elmInt,
                       const FiniteElement& fe, const Vec3& X) const;
 
  using Integrand::evalIntMx;
  virtual bool evalIntMx(LocalIntegral& elmInt, const MxFiniteElement& fe,
                         const Vec3& X) const;
 
  void preAssemble(const std::vector<IntVec>& MMNPC, size_t nel);
 
  bool solve(Matrix& sField);
  bool solve(const std::vector<Matrix*>& sField);
 
private:
  void allocate(size_t n);
 
public:
  mutable SparseMatrix* pA; 
  mutable StdVector*    pB; 
 
private:
  IntegrandBase* problem; 
  FunctionVec  functions; 
  size_t            nrhs; 
};
 
#endif