space.hh

Go to the documentation of this file.

 
#ifndef spcSpace_hh
#define spcSpace_hh
 
#include <cstring>
#include <climits>
#include <set>
#include <map>
#include "basics/outputOperator.hh"
#include "basics/typedefs.hh"
#include "basics/exceptions.hh"
#include "basics/level.hh"
#include "toolbox/scannerConnectors.hh"
#include "geometry/connector.hh"
#include "space/element.hh"
 
namespace concepts {
 
  // ********************************************************* SpaceNotBuilt **
 
  class SpaceNotBuilt : public ExceptionBase {};
 
  // ***************************************************************** Space **
 
  template<class F>
  class Space : public virtual OutputOperator {
  public:
    typedef Element<F> type;
    typedef Scan<Element<F> > Scanner;
 
    virtual uint getOutputDimension() const{
      return 1u;
    };
 
    virtual uint dim() const = 0;
 
    virtual uint nelm() const = 0;
 
    virtual Scanner* scan() const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
  };
 
  // ********************************************** Scan<ElementWithCell<F> > **
 
  template<class F>
  class Scan<ElementWithCell<F> > : public Scan<Element<F> > {
  public:  
    virtual ElementWithCell<F>& operator++(int) = 0;
  };
 
  // ***************************************************************** Space **
 
  template<class F>
  class SpaceOnCells : public Space<F> {
  public:
    typedef ElementWithCell<F> type;
    typedef Scan<ElementWithCell<F> > Scanner;
 
    virtual Scanner* scan() const = 0;
 
    virtual uint dim() const = 0;
 
    virtual uint nelm() const = 0;
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
 
 
 
  template<uint dimC> class CellType;
 
  template<> class CellType<1>{
    public:
    typedef concepts::Cell1 cell;
  };
 
  template<> class CellType<2>{
    public:
    typedef concepts::Cell2 cell;
  };
 
  template<> class CellType<3>{
  public:
    typedef concepts::Cell3 cell;
  };
 
 
  template<uint dimC, class F>
  class SpaceOnCoarseCells : public SpaceOnCells<F>{
 
  public:
    virtual const std::set<typename CellType<dimC>::cell * > allCells() const = 0;
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
  };
 
  // **************************************************** AdaptiveControlTag **
 
  struct AdaptiveControlTag {
    enum tagInfo { NO_TAG = 0, MEMBER = 1, PASSIVE = 2, VLD_IDX = 4, VLD_P = 8 };
    uchar data_;
 
    AdaptiveControlTag(uchar t = 0) : data_(t) {}
 
    uchar operator=(const uchar& t) { return data_ = t; }
 
    bool isMember() const { return (data_ & MEMBER); }
    void takeIn() { data_ |= MEMBER; }
    void takeOut() { data_ &= ~MEMBER; }
 
    bool isActive() const { return !(data_ & PASSIVE); }
    bool isPassive() const { return (data_ & PASSIVE); }
    void activate() { data_ &= ~PASSIVE; }
    void deactivate() { data_ |= PASSIVE; }
 
    bool idxValid() const { return (data_ & VLD_IDX); }
    void validateIdx() { data_ |= VLD_IDX; }
    void invalidateIdx() { data_ &= ~VLD_IDX; }
 
    bool pValid() const { return (data_ & VLD_P); }
    void validateP() { data_ |= VLD_P; }
    void invalidateP() { data_ &= ~VLD_P; }
  };
 
  std::ostream& operator<<(std::ostream& os, const AdaptiveControlTag& c);
 
  // ************************************************************ IndexRange **
 
  struct IndexRange {
    uint idx_[2];
 
    IndexRange() { idx_[0] = idx_[1] = 0; }
    IndexRange(uint idx);
    IndexRange(uint idxBegin, uint idxEnd);
    std::set<uint> operator()();
    IndexRange& operator=(uint i);
    IndexRange& operator=(const IndexRange& i);
    IndexRange& operator=(IndexRange& i);
    IndexRange& operator+=(uint i);
    bool operator==(uint i) const;
    bool operator==(const IndexRange& i) const;
    bool operator<(const IndexRange& i) const;
    inline uint dim() const { return idx_[1] - idx_[0] + 1; }
    inline bool exist(uint i) const {
      return (i >= idx_[0] && i <= idx_[1]);
    }
  };
 
  std::ostream& operator<<(std::ostream& os, const IndexRange& i);
 
  std::ostream& operator<<(std::ostream& os,
      const std::map<uint, IndexRange>& map);
 
  // ******************************************************* AdaptiveControl **
 
  template<class F = uint>
    struct AdaptiveControl {
      AdaptiveControlTag tag_;
      F idx_;
 
      AdaptiveControl();
    };
 
  template<class F>
    std::ostream& operator<<(std::ostream& os, const AdaptiveControl<F>& c);
 
  // ******************************************************** AdaptiveAdjust **
 
  template<uint levelDim = 1>
  class AdaptiveAdjust {
  public:
    Level<levelDim> level_;
    short& l_;
    
    AdaptiveAdjust() : level_(), l_(level_.l_[0]) {}
    AdaptiveAdjust(short l) : level_(l), l_(level_.l_[0]) {}
  };
  
  template<uint levelDim>
    std::ostream& operator<<(std::ostream& os,
        const AdaptiveAdjust<levelDim>& a);
 
  // ************************************************************ Adaptivity **
 
  template<class F = Connector, class Tadj = class AdaptiveAdjust<1> >
  class Adaptivity {
  public:
    virtual ~Adaptivity() { }
    virtual void adjust(const F& cell, const Tadj& a) = 0;
  };
 
  // ********************************************************* AdaptiveSpace **
 
  template<class F, class Tadj = class AdaptiveAdjust<1> >
  class AdaptiveSpace { 
  public:
    virtual void adjust(const Element<F>& elm, const Tadj& a) = 0;
 
    virtual ~AdaptiveSpace() { }
  };
 
  // ************************************************************ DummySpace **
 
  template<typename F>
    class DummySpace : public Space<F> {
      public:
        typedef concepts::Scan<concepts::Element<F> > Scan;
        DummySpace(uint dim) : dim_(dim) {}
        virtual uint dim() const { return dim_; }
        virtual uint nelm() const { return 0; }
        virtual Scan* scan() const { return 0; }
      protected:
        virtual std::ostream& info(std::ostream& os) const {
          return os << "DummySpace<" << number<F>::name()
            << ">(dim = " << dim_ << ')'; }
      private:
        uint dim_;
    };
 
  // ************************************************************** Subspace **
 
  class Subspace {
    public:
      virtual uint& lastIdx() = 0;
      virtual uint offset() const = 0;
      virtual ~Subspace() {}
  };
 
  // ************************************************************ SpaceDebug **
  template<typename F = Real>
    class SpaceDebug : public virtual OutputOperator {
      public:
        SpaceDebug(const Space<F>& spc) : spc_(spc) {}
      protected:
        virtual std::ostream& info(std::ostream& os) const;
      private:
        const Space<F>& spc_;
    };
 
  template<typename F>
    std::ostream& SpaceDebug<F>::info(std::ostream& os) const {
      os << spc_ << std::endl;
      std::unique_ptr<typename Space<F>::Scanner> sc(spc_.scan());
      uint i = 1;
      while (*sc) {
        const Element<F>& elm = (*sc)++;
        os << i++ << ". element = " << elm << std::endl;
      }
      return os;
    }
 
} // namespace concepts
 
#endif // spcSpace_hh