optimum_selector.h

// This file is part of Hermes2D.
//
// Hermes2D is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// Hermes2D is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Hermes2D.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __H2D_REFINEMENT_OPTIMUM_SELECTOR_H
#define __H2D_REFINEMENT_OPTIMUM_SELECTOR_H

#include <ostream>
#include "selector.h"
#include "../shapeset/shapeset.h"
#include "candidates.h"

namespace Hermes
{
  namespace Hermes2D
  {
    namespace RefinementSelectors
    {

      template<typename Scalar>
      class HERMES_API OptimumSelector : public Selector < Scalar >
      {
      public:
        virtual ~OptimumSelector();

        void set_dof_score_exponent(double exponent);

      protected:

        OptimumSelector(CandList cand_list, int max_order, Shapeset* shapeset, const Range& vertex_order, const Range& edge_bubble_order);

        //candidates
        struct CandsInfo
        {
          bool uniform_orders;
          int min_quad_order;
          int max_quad_order;

          CandsInfo() : uniform_orders(true), min_quad_order(-1), max_quad_order(-1) {};


          bool is_empty() const { return (min_quad_order < 0 || max_quad_order < 0); };
        };

        CandList cand_list;


        void update_cands_info(std::vector<Cand>& candidates, CandsInfo& info_h, CandsInfo& info_p, CandsInfo& info_aniso) const;


        void append_candidates_split(std::vector<Cand>& candidates, const int start_quad_order, const int last_order, const RefinementType split, bool iso_p);


        virtual std::vector<Cand> create_candidates(Element* e, int quad_order);


        void evaluate_candidates(std::vector<Cand>& candidates, Element* e, MeshFunction<Scalar>* rsln);


        virtual void select_best_candidate(std::vector<Cand>& candidates, Element* e, Cand*& best_candidate, Cand* best_candidates_specific_type[4]);


        virtual void evaluate_cands_error(std::vector<Cand>& candidates, Element* e, MeshFunction<Scalar>* rsln) = 0;


        virtual void evaluate_cands_dof(std::vector<Cand>& candidates, Element* e, MeshFunction<Scalar>* rsln);


        virtual void evaluate_cands_score(std::vector<Cand>& candidates, Element* e);

        int ****num_shapes;


        static bool compare_cand_score(const Cand& a, const Cand& b);

        //orders and their range

        virtual void get_current_order_range(Element* element, int& min_order, int& max_order) = 0;

        //shape functions
        enum ShapeType {
          H2DST_VERTEX = 0x01, 
          H2DST_HORIZ_EDGE = 0x02, 
          H2DST_VERT_EDGE = 0x04, 
          H2DST_TRI_EDGE = 0x08, 
          H2DST_BUBBLE = 0x10 
        };

        enum ShapeTypeInt {
          H2DSI_VERTEX,
          H2DSI_HORIZ_EDGE,
          H2DSI_VERT_EDGE,
          H2DSI_TRI_EDGE,
          H2DSI_BUBBLE,
          H2DSI_ANY
        };


        struct ShapeInx {
          int order_h;
          int order_v;
          int inx;
          ShapeType type;


          ShapeInx(int order_h, int order_v, int inx, ShapeType type) : order_h(order_h), order_v(order_v), inx(inx), type(type) {};
        };

        Shapeset *shapeset;

        std::vector<ShapeInx> shape_indices[H2D_NUM_MODES];
        int max_shape_inx[H2D_NUM_MODES];
        int next_order_shape[H2D_NUM_MODES][H2DRS_MAX_ORDER + 1];
        bool has_vertex_shape[H2D_NUM_MODES];
        bool has_edge_shape[H2D_NUM_MODES];
        bool has_bubble_shape[H2D_NUM_MODES];


        void add_bubble_shape_index(int order_h, int order_v, std::map<int, bool>& used_shape_index, std::vector<ShapeInx>& indices, ElementMode2D mode);


        void build_shape_indices(const ElementMode2D mode, const Range& vertex_order, const Range& edge_bubble_order);


        int calc_num_shapes(int mode, int order_h, int order_v, int allowed_type_mask);


        virtual bool select_refinement(Element* element, int quad_order, MeshFunction<Scalar>* rsln, ElementToRefine& refinement);

        double dof_score_exponent;
      };
    }
  }
}

#endif