hp2D/aprioriRef2D.hh

Go to the documentation of this file.

#ifndef APRIORIRef2D_hh
#define APRIORIRef2D_hh

#include "basics/typedefs.hh"
#include "basics/exceptions.hh"
#include "basics/level.hh"
#include "toolbox/set.hh"
#include "geometry/connector.hh"
#include "space/postProcess.hh"
#include "space/hpMethod.hh"

// forward declaration
namespace concepts {
  class Quad;
}

namespace hp2D {

  using concepts::Real;

  // ***************************************************** APrioriRefinement **

  class APrioriRefinement : public concepts::CellPostprocess<Real> {
  public:
    enum subdivTypes { NONE = 0, X = 1, Y = 2};
    static const short MAXSHORT = 32767;
    APrioriRefinement
    (concepts::AdaptiveSpace<Real, concepts::AdaptiveAdjustP<2> >& spc,
     concepts::Attribute attribVtx, concepts::Attribute attribEdge,
     const int* const p, const uint subdiv = X | Y,
     const concepts::Attribute attribCell = 0) :
      spc_(&spc), attribVtx_(attribVtx), attribEdge_(attribEdge), 
      attribCell_(0), p_(p),
      subdiv_(subdiv), level_(MAXSHORT) {
      if (attribCell) attribCell_.reset(new concepts::Attribute(attribCell));
    }
    APrioriRefinement
    (concepts::AdaptiveSpace<Real, concepts::AdaptiveAdjustP<2> >& spc,
     const int* const p, const uint subdiv = X | Y,
     const concepts::Level<2> level = MAXSHORT) :
      spc_(&spc), adj_(0), attribVtx_(0), attribEdge_(0), attribCell_(0), 
      p_(p), subdiv_(subdiv), level_(level) {}
    APrioriRefinement(concepts::Adaptivity<concepts::Connector,
          concepts::AdaptiveAdjustP<2> >& adj,
          concepts::Attribute attribVtx,
          concepts::Attribute attribEdge,
          const int* const p, const uint subdiv = X | Y) :
      spc_(0), adj_(&adj), attribVtx_(attribVtx), attribEdge_(attribEdge),
      attribCell_(0), p_(p), subdiv_(subdiv), level_(MAXSHORT) {}

    virtual void operator() (const concepts::Element<Real>& elm)
      throw(concepts::MissingFeature);
    virtual void operator() (const concepts::Cell& cell)
      throw(concepts::MissingFeature);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    concepts::AdaptiveSpace<Real, concepts::AdaptiveAdjustP<2> >* spc_;
    concepts::Adaptivity<concepts::Connector,
       concepts::AdaptiveAdjustP<2> >* adj_;
    concepts::Attribute attribVtx_, attribEdge_;
    std::auto_ptr<concepts::Attribute> attribCell_;
    const int* const p_;
    const uint subdiv_;
    const concepts::Level<2> level_;
    concepts::AdaptiveAdjustP<2>
    computeRef_(const concepts::Quad& q, concepts::Level<2> level) const;
  };

  // ************************************************* APrioriRefinementRule **

  class APrioriRefinementRule : public concepts::OutputOperator {
  public:
    enum subdivTypes { NONE = 0, X = 1, Y = 2};
    static const short MAXSHORT = 32767;

    virtual concepts::AdaptiveAdjustP<2> operator()
      (const concepts::Connector2& q) const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };

  // ******************************************** APrioriGeometricRefinement **

  class APrioriGeometricRefinement : public APrioriRefinementRule {
  public:
    APrioriGeometricRefinement(concepts::Attribute attribVtx,
                               concepts::Attribute attribEdge,
                               const int* const p, const uint subdiv = X | Y);
    APrioriGeometricRefinement(const APrioriGeometricRefinement& rule) :
      attribVtx_(rule.attribVtx_), attribEdge_(rule.attribEdge_),
      p_(rule.p_), subdiv_(rule.subdiv_) {}
    concepts::Set<concepts::Attribute>& attribVtx() { return attribVtx_; }
    concepts::Set<concepts::Attribute>& attribEdge() { return attribEdge_; }

    virtual concepts::AdaptiveAdjustP<2> operator()
      (const concepts::Connector2& q) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    concepts::Set<concepts::Attribute> attribVtx_, attribEdge_;
    const int* const p_;
    const uint subdiv_;
  };

  // ********************************************** APrioriRegularRefinement **

  class APrioriRegularRefinement : public APrioriRefinementRule {
  public:
    APrioriRegularRefinement(const int* const p, const uint subdiv = X | Y) :
      p_(p), subdiv_(subdiv) {}
    APrioriRegularRefinement(const APrioriRegularRefinement& rule) :
      p_(rule.p_), subdiv_(rule.subdiv_) {}
    virtual concepts::AdaptiveAdjustP<2> operator()
      (const concepts::Connector2& q) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const int* const p_;
    const uint subdiv_;
  };

  // ************************************************** APrioriRefinementNew **

  class APrioriRefinementNew : public concepts::CellPostprocess<Real> {
  public:
    APrioriRefinementNew(concepts::Adaptivity<concepts::Connector,
                         concepts::AdaptiveAdjustP<2> >& adj,
                         APrioriRefinementRule* rule = 0) : 
      adj_(&adj), rule_(rule) {}
    void add(concepts::Attribute attrib, APrioriRefinementRule* rule) {
      if (rule)
        rules_[attrib] = rule;
      else {
        std::map<uint, APrioriRefinementRule*>::
          iterator i = rules_.find(attrib);
        if (i != rules_.end()) rules_.erase(i);
      }
    }
    virtual void operator() (const concepts::Element<Real>& elm)
      throw(concepts::MissingFeature);
    virtual void operator() (const concepts::Cell& cell)
      throw(concepts::MissingFeature);
  private:
    concepts::Adaptivity<concepts::Connector,
                         concepts::AdaptiveAdjustP<2> >* adj_;
    APrioriRefinementRule* rule_;
    std::map<uint, APrioriRefinementRule*> rules_;
  };

} // namespace hp2D

#endif // APRIORIRef2D_hh