space/space.hh

Go to the documentation of this file.

/* Abstract classes for a space and an adaptive space
 */

#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 OutputOperator {
  public:
    typedef Scan<Element<F> > Scanner;

    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 Scan<ElementWithCell<F> > Scanner;

    virtual Scanner* scan() 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);
    bool operator==(uint i) const;
    bool operator==(const IndexRange& i) const;
    bool operator<(const IndexRange& i) const;
    uint dim() const { return idx_[1] - idx_[0] + 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 = struct AdaptiveAdjust<1> >
  class Adaptivity {
  public:
    virtual ~Adaptivity() { }
    virtual void adjust(const F& cell, const Tadj& a) = 0;
  };

  // ********************************************************* AdaptiveSpace **

  template<class F, class Tadj = struct 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 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::auto_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