space/smatrix.hh

Go to the documentation of this file.

/* S Matrix
 * An S matrix changes a T matrix according to a refinement to handle
 * hanging nodes
 */

#ifndef smatrix_hh
#define smatrix_hh

#include "basics/outputOperator.hh"
#include "basics/typedefs.hh"
#include "toolbox/array.hh"

namespace concepts {

  // forward declaration
  template<class F>
  class TColumn;

  template<class F>
  class ShapeFunction1D;

  // *********************************************************** SMatrixBase **

  template<class F>
  class SMatrixBase : public OutputOperator {
  public:
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const = 0;

    virtual uint size() const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };

  // ************************************************************* SMatrix1D **

  class SMatrix1D : public SMatrixBase<Real> {
  public:
    SMatrix1D(const ShapeFunction1D<Real>& small,
        const ShapeFunction1D<Real>& left,
        const ShapeFunction1D<Real>& right);

    SMatrix1D(const SMatrix1D& s, const bool flip = false);
    virtual void operator()(const TColumn<Real>& src,
          TColumn<Real>& dest) const;
    void scale(const Real factor);
    virtual uint size() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const uint n_;

    Array<Real> data_;

    Real* left_;

    Real* right_;
  };

  // ********************************************************* SMatrixTensor **

  template<class F, int dim>
  class SMatrixTensor : public SMatrixBase<F> {
  public:
    SMatrixTensor(const SMatrixBase<F>& matrix, const uint position);
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const;
    virtual uint size() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const SMatrixBase<Real>& matrix_;
    const uint position_;
  };

  // ******************************************************** SMatrixCompose **

  template<class F>
  class SMatrixCompose : public SMatrixBase<F> {
  public:
    inline SMatrixCompose(const SMatrixBase<F>& A, const SMatrixBase<F>& B,
        const SMatrixBase<F>* C = 0) : A_(A), B_(B), C_(C) {}
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const;
    virtual uint size() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const SMatrixBase<F>& A_;
    const SMatrixBase<F>& B_;
    const SMatrixBase<F>* C_;
  };


  // ************************************************** SMatrixGeneralTensor **

  template<class F, int dim>
  class SMatrixGeneralTensor : public SMatrixBase<F> {
  public:
    SMatrixGeneralTensor(const SMatrixBase<F>& matrix, const uint* n,
       const uint position);
    SMatrixGeneralTensor(const SMatrixBase<F>& matrix, const uint position);
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const;
    virtual uint size() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const SMatrixBase<Real>& matrix_;
    uint n_[dim];
    const uint position_;
  };


  // ********************************************************** SMatrixBlock **

  template<class F, int dim>
  class SMatrixBlock : public SMatrixBase<F> {
  public:
    SMatrixBlock(const SMatrixBase<F>& A, const SMatrixBase<F>& B,
     const SMatrixBase<F>* C = 0);
    virtual void operator()(const TColumn<F>& src, TColumn<F>& dest) const;
    inline uint size() const { return size_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const SMatrixBase<F>& A_;
    const SMatrixBase<F>& B_;
    const SMatrixBase<F>* C_;
    uint* n_;
    uint size_;
  };

} // namespace concepts

#endif // smatrix_hh