space/hpMethod.hh

Go to the documentation of this file.

/* control structures for high order methods
 */

#ifndef hpMethod_hh
#define hpMethod_hh

#include <cstring>
#include "basics/level.hh"
#include "toolbox/array.hh"
#include "space.hh"
#include "postProcess.hh"

namespace concepts {

  // ****************************************************** AdaptiveControlP **

  template<int dim, class F = uint>
  struct AdaptiveControlP : public AdaptiveControl<F> {
    ushort p_[dim];

    AdaptiveControlP() : AdaptiveControl<F>() {
      std::memset(p_, 0, dim*sizeof(ushort));
    }

    bool operator!=(const AdaptiveControlP<dim,F>& a) { return this != &a; }

    std::ostream& info(std::ostream& os) const;
  };

  template<int dim, class F>
  std::ostream& operator<<(std::ostream& os, const AdaptiveControlP<dim, F>& a)
  {
    return a.info(os);
  }

  // ******************************************************* AdaptiveAdjustP **

  template<int dim>
  class AdaptiveAdjustP : public AdaptiveAdjust<dim> {
  public:
    short p_[dim];
    
    AdaptiveAdjustP() : AdaptiveAdjust<dim>() {
      std::memset(p_, 0, dim*sizeof(short));
    }
    AdaptiveAdjustP(short l, int* p) :
      AdaptiveAdjust<dim>(l) {
      for (int i = 0; i < dim; ++i) p_[i] = p[i];
    }
    AdaptiveAdjustP(short l, const int p) :
      AdaptiveAdjust<dim>(l) {
      for (int i = 0; i < dim; ++i) p_[i] = p;
    }
    AdaptiveAdjustP(short l, const Array<int> p) :
      AdaptiveAdjust<dim>(l) {
      conceptsAssert(p.size() == dim, Assertion());
      for (int i = 0; i < dim; ++i) p_[i] = p[i];
    }
    AdaptiveAdjustP(const Level<dim>& l, const int p) {
      this->level_ = l;
      for (int i = 0; i < dim; ++i) p_[i] = p;
    }
    AdaptiveAdjustP(const Level<dim>& l, const int* p) {
      this->level_ = l;
      for (int i = 0; i < dim; ++i) p_[i] = p[i];
    }
    AdaptiveAdjustP(const Level<dim>& l, const Array<int> p) {
      conceptsAssert(p.size() == dim, Assertion());
      this->level_ = l;
      for (int i = 0; i < dim; ++i) p_[i] = p[i];
    }
    
    AdaptiveAdjustP<dim>& operator=(const AdaptiveAdjustP<dim>& a);

    std::ostream& info(std::ostream& os) const;
  };
  
  template<int dim>
  std::ostream& operator<<(std::ostream& os, const AdaptiveAdjustP<dim>& a) {
    return a.info(os);
  }

  // *********************************************************** HRefinement **

  template<typename F, int dim>
  class HRefinement : public CellPostprocess<F> {
  public:
    HRefinement(AdaptiveSpace<F, AdaptiveAdjustP<dim> >& spc) : spc_(spc) {}
    virtual void operator() (const Element<F>& elm) throw(MissingFeature);
    virtual void operator() (const Cell& cell) throw(MissingFeature) {}
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    AdaptiveSpace<F, AdaptiveAdjustP<dim> >& spc_;
  };

  // *********************************************************** PRefinement **

  template<typename F, int dim>
  class PRefinement : public CellPostprocess<F> {
  public:
    PRefinement(AdaptiveSpace<F, AdaptiveAdjustP<dim> >& spc) : spc_(spc) {}
    virtual void operator() (const Element<F>& elm) throw(MissingFeature);
    virtual void operator() (const Cell& cell) throw(MissingFeature) {}
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    AdaptiveSpace<F, AdaptiveAdjustP<dim> >& spc_;
  };

} // namespace concepts

#endif // hpMethod_hh