space.hh

Go to the documentation of this file.

 
#ifndef bemSpace_hh
#define bemSpace_hh
 
#include <stack>
 
#include "basics/output.hh"
#include "toolbox/dynArray.hh"
#include "toolbox/scannerConnectors.hh"
#include "geometry/mesh.hh"
#include "space/space.hh"
#include "bem/element.hh"
 
namespace bem {
 
  // *************************************************************** Dirac3d **
 
  template <class F = concepts::Real>
  class Dirac3d : public concepts::Space<F> {
    uint dim_;
    uint nelm_;
    concepts::Joiner<concepts::Element<F>*, 1>* elm_;
 
    void constructor_(concepts::Triangle3d* cell, uint lvl,
          concepts::DynArray<uint>& map);
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  public:
    Dirac3d(concepts::Mesh2& msh, uint lvl);
    virtual ~Dirac3d();
 
    inline uint dim() const {return dim_;}
    inline uint nelm() const {return nelm_;}
    inline concepts::Scan<concepts::Element<F> >* scan() const;
  };
 
  template <class F>
  inline std::ostream& Dirac3d<F>::info(std::ostream& os) const {
    os << typeOf(*this) << "(dim = " << dim_ << ", nelm = " << nelm_ << ')';
    return os;
  }
 
  template <class F>
  inline concepts::Scan<concepts::Element<F> >* Dirac3d<F>::scan() const {
    return new concepts::PListScan<concepts::Element<F> >(*elm_);
  }
 
  // ************************************************************** Linear3d **
 
  template <class F = concepts::Real>
  class Linear3d : public concepts::Space<F> {
    uint dim_;
    uint nelm_;
    concepts::Joiner<concepts::Element<F>*, 1>* elm_;
 
    void constructor_(concepts::Triangle3d* cell, uint lvl,
          concepts::DynArray<uint>& map);
 
  protected:
    std::ostream& info(std::ostream& os) const {return info(os, 0);}
 
  public:
    Linear3d(concepts::Mesh2& msh, uint lvl);
    virtual ~Linear3d();
 
    inline uint dim() const {return dim_;}
    inline uint nelm() const {return nelm_;}
    inline concepts::Scan<concepts::Element<F> >* scan() const;
    std::ostream& info(std::ostream& os, uint mode = 0) const;
  };
 
  template <class F>
  inline concepts::Scan<concepts::Element<F> >* Linear3d<F>::scan() const {
    return new concepts::PListScan<concepts::Element<F> >(*elm_);
  }
 
  // ************************************************************ Constant3d **
 
  template <class F = concepts::Real>
  class Constant3d : public concepts::Space<F> {
    uint dim_;
    uint nelm_;
    uint elmType_;
    concepts::Joiner<concepts::Element<F>*, 1>* elm_;
 
    void constructor_(concepts::Triangle3d* cell, uint lvl);
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  public:
    Constant3d(concepts::Mesh2& msh, uint lvl, uint elmType = 0);
    virtual ~Constant3d();
 
    uint dim() const {return dim_;}
    uint nelm() const {return nelm_;}
    inline concepts::Scan<concepts::Element<F> >* scan() const;
  };
 
  template <class F>
  inline concepts::Scan<concepts::Element<F> >* Constant3d<F>::scan() const {
    return new concepts::PListScan<concepts::Element<F> >(*elm_);
  }
 
  template <class F>
  inline std::ostream& Constant3d<F>::info(std::ostream& os) const {
    os << "Constant3d(dim = " << dim_ << ", nelm = " << nelm_ << ')';
    return os;
  }
 
  // ******************************************************** AdaptiveAdjust **
 
  struct AdaptiveAdjust {
    short l_;
 
    AdaptiveAdjust() : l_(0) {}
    AdaptiveAdjust(short l) : l_(l) {}
 
    AdaptiveAdjust& operator=(const AdaptiveAdjust& adj) {
      if (this != &adj)  l_ = adj.l_;
      return *this;
    }
  };
 
  std::ostream& operator<<(std::ostream& os, const AdaptiveAdjust& adj);
 
  // ********************************************************* AdaptiveSpace **
 
  template<class F = concepts::Real>
  class AdaptiveSpace : 
    public concepts::SpaceOnCells<F>, 
    public concepts::AdaptiveSpace<F, AdaptiveAdjust> {
  protected:
    std::ostream& info(std::ostream& os) const {
      return os << "bem::" << typeOf(*this) ;
    }
  };
 
  // ******************************************************* AdaptConst3d000 **
 
  template<class F = concepts::Real>
  class AdaptConst3d000 : public AdaptiveSpace<F> {
    uint dim_;
    uint nelm_;
    concepts::Joiner<concepts::ElementWithCell<F>*, 1>* elm_;
 
    concepts::Mesh2& msh_;
    uint maxlvl_;
    uint minlvl_;
    concepts::DynArray<concepts::AdaptiveControl<> > ctrl_;
    concepts::DynArray<AdaptiveAdjust> adj_;
    bool rebuild_;
 
    void rebuild0_(concepts::Connector2& cntr, int l, int& L);
    void rebuild1_(concepts::Triangle3d& cell, uint l);
 
  protected:
    std::ostream& info(std::ostream& os) const {return info(os, 0);}
 
  public:
    AdaptConst3d000(concepts::Mesh2& msh, uint lvl);
    ~AdaptConst3d000();
 
    uint dim() const;
    uint dim();
    uint nelm() const;
    uint nelm();
    uint maxlevel();
    uint minlevel();
    concepts::Scan<concepts::ElementWithCell<F> >* scan() const;
    concepts::Scan<concepts::ElementWithCell<F> >* scan();
    short l(Constant3d001<F>& elm) {
      AdaptiveAdjust& adj(adj_[elm.support().key()]);
      return adj.l_;
    }
    void adjust(const concepts::Element<F>& elm,const AdaptiveAdjust& a);
    void adjust(const Constant3d001<F>& elm, const AdaptiveAdjust& a);
    void rebuild();
    std::ostream& info(std::ostream& os, uint mode = 0) const;
  };
 
  template<class F>
  inline uint AdaptConst3d000<F>::dim() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return dim_;
  }
 
  template<class F>
  inline uint AdaptConst3d000<F>::dim() {
    if (rebuild_)  rebuild();
    return dim_;
  }
 
  template<class F>
  inline uint AdaptConst3d000<F>::nelm() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return nelm_;
  }
 
  template<class F>
  inline uint AdaptConst3d000<F>::nelm() {
    if (rebuild_)  rebuild();
    return nelm_;
  }
 
  template<class F>
  inline uint AdaptConst3d000<F>::maxlevel() {
    if (rebuild_)  rebuild();
    return maxlvl_;
  }
 
  template<class F>
  inline uint AdaptConst3d000<F>::minlevel() {
    if (rebuild_)  rebuild();
    return minlvl_;
  }
 
  template<class F>
  inline concepts::Scan<concepts::ElementWithCell<F> >*
  AdaptConst3d000<F>::scan() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
  }
 
  template<class F>
  inline concepts::Scan<concepts::ElementWithCell<F> >*
  AdaptConst3d000<F>::scan() {
    if (rebuild_)  rebuild();
    return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
  }
 
  // *************************************************************** EdgeMap **
 
  class EdgeMap {
    friend std::ostream& operator<<(std::ostream& os, const EdgeMap& emp);
  public:
    inline EdgeMap() : pnl1(0), pnl2(0), lvl(0), prnt(0), tag(0) {};
    std::ostream& info(std::ostream& os) const;
 
    concepts::Connector2* pnl1;
    concepts::Connector2* pnl2;
    ushort lvl;
    EdgeMap* prnt;
    concepts::uchar tag;
  };
 
  // ******************************************************* AdaptConst3d001 **
 
  template<class F = concepts::Real>
  class AdaptConst3d001 : public AdaptiveSpace<F> {
    uint dim_;
    uint nelm_;
    concepts::Joiner<concepts::ElementWithCell<F>*, 1>* elm_;
 
    concepts::Mesh2& msh_;
    uint maxlvl_;
    uint minlvl_;
    concepts::DynArray<concepts::AdaptiveControl<> > ctrl_;
    concepts::DynArray<AdaptiveAdjust> adj_;
    bool rebuild_;
    ushort deltal_;
    concepts::DynArray<EdgeMap> edgmap_;
    std::stack<EdgeMap*> stk_;
 
    void rebuild0_(concepts::Connector2& cntr, int l, int& L);
    void rebuild1_(concepts::Connector2& cntr);
    void rebuild2_();
    void rebuild3_(concepts::Triangle3d& cell, uint l);
 
  protected:
    std::ostream& info(std::ostream& os) const {return info(os, 0);}
 
  public:
    AdaptConst3d001(concepts::Mesh2& msh, uint lvl, ushort deltal);
    ~AdaptConst3d001();
 
    uint dim() const;
    uint dim();
    uint nelm() const;
    uint nelm();
    uint maxlevel();
    uint minlevel();
    concepts::Scan<concepts::ElementWithCell<F> >* scan() const;
    concepts::Scan<concepts::ElementWithCell<F> >* scan();
    short l(Constant3d001<F>& elm) {
      AdaptiveAdjust& adj(adj_[elm.support().key()]);
      return adj.l_;
    }
    void adjust(const concepts::Element<F>& elm, const AdaptiveAdjust& a);
    void adjust(const Constant3d001<F>& elm, const AdaptiveAdjust& a);
    void rebuild();
    std::ostream& info(std::ostream& os, uint mode = 0) const;
  };
 
  template<class F>
  inline uint AdaptConst3d001<F>::dim() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return dim_;
  }
 
  template<class F>
  inline uint AdaptConst3d001<F>::dim() {
    if (rebuild_)  rebuild();
    return dim_;
  }
 
  template<class F>
  inline uint AdaptConst3d001<F>::nelm() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return nelm_;
  }
 
  template<class F>
  inline uint AdaptConst3d001<F>::nelm() {
    if (rebuild_)  rebuild();
    return nelm_;
  }
 
  template<class F>
  inline uint AdaptConst3d001<F>::maxlevel() {
    if (rebuild_)  rebuild();
    return maxlvl_;
  }
 
  template<class F>
  inline uint AdaptConst3d001<F>::minlevel() {
    if (rebuild_)  rebuild();
    return minlvl_;
  }
 
  template<class F>
  inline concepts::Scan<concepts::ElementWithCell<F> >*
  AdaptConst3d001<F>::scan() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
  }
 
  template<class F>
  inline concepts::Scan<concepts::ElementWithCell<F> >*
  AdaptConst3d001<F>::scan() {
    if (rebuild_)  rebuild();
    return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
  }
 
  // ******************************************************* AdaptConst3d002 **
 
  template<class F = concepts::Real>
  class AdaptConst3d002 : public AdaptiveSpace<F> {
    uint dim_;
    uint nelm_;
    concepts::Joiner<concepts::ElementWithCell<F>*, 1>* elm_;
 
    concepts::Mesh2& msh_;
    uint maxlvl_;
    uint minlvl_;
    concepts::DynArray<concepts::AdaptiveControl<> > ctrl_;
    concepts::DynArray<AdaptiveAdjust> adj_;
    bool rebuild_;
    ushort deltal_;
    ushort deltaL_;
    concepts::DynArray<EdgeMap> edgmap_;
    std::stack<EdgeMap*> stk_;
 
    void rebuild0_(concepts::Connector2& cntr, int l, int& L);
    void rebuild1_(concepts::Connector2& cntr, uint l);
    void rebuild2_();
    void rebuild3_(concepts::Triangle3d& cell, uint l, ushort tag);
 
  protected:
    std::ostream& info(std::ostream& os) const {return info(os, 0);}
 
  public:
    AdaptConst3d002(concepts::Mesh2& msh, uint lvl, ushort deltal,
        ushort deltaL);
    ~AdaptConst3d002();
 
    uint dim() const;
    uint dim();
    uint nelm() const;
    uint nelm();
    uint maxlevel();
    uint minlevel();
    concepts::Scan<concepts::ElementWithCell<F> >* scan() const;
    concepts::Scan<concepts::ElementWithCell<F> >* scan();
    short l(Constant3d001<F>& elm) {
      AdaptiveAdjust& adj(adj_[elm.support().key()]);
      return adj.l_;
    }
    void adjust(const concepts::Element<F>& elm, const AdaptiveAdjust& a);
    void adjust(const Constant3d001<F>& elm, const AdaptiveAdjust& a);
    void rebuild();
    std::ostream& info(std::ostream& os, uint mode = 0) const;
  };
 
  template<class F>
  inline uint AdaptConst3d002<F>::dim() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return dim_;
  }
 
  template<class F>
  inline uint AdaptConst3d002<F>::dim() {
    if (rebuild_)  rebuild();
    return dim_;
  }
 
  template<class F>
  inline uint AdaptConst3d002<F>::nelm() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return nelm_;
  }
 
  template<class F>
  inline uint AdaptConst3d002<F>::nelm() {
    if (rebuild_)  rebuild();
    return nelm_;
  }
 
  template<class F>
  inline uint AdaptConst3d002<F>::maxlevel() {
    if (rebuild_)  rebuild();
    return maxlvl_;
  }
 
  template<class F>
  inline uint AdaptConst3d002<F>::minlevel() {
    if (rebuild_)  rebuild();
    return minlvl_;
  }
 
  template<class F>
  inline concepts::Scan<concepts::ElementWithCell<F> >*
  AdaptConst3d002<F>::scan() const {
    if (rebuild_)  conceptsException(concepts::SpaceNotBuilt());
    return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
  }
 
  template<class F>
  inline concepts::Scan<concepts::ElementWithCell<F> >*
  AdaptConst3d002<F>::scan() {
    if (rebuild_)  rebuild();
    return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
  }
 
} // namespace bem
 
#endif // bemSpace_hh