EntityRefiner.cpp

Go to the documentation of this file.

#include "EntityRefiner.hpp"

#include "EdgeSizeEvaluator.hpp"
#include "moab/Interface.hpp"

namespace moab {

EntityRefiner::EntityRefiner()
{  
  this->mesh_in = 0;
  this->edge_size_evaluator = 0;
  this->output_functor = 0;
  // By default, allow at most one subdivision per edge
  this->minimum_number_of_subdivisions = 0;
  this->maximum_number_of_subdivisions = 1;
}

EntityRefiner::~EntityRefiner()
{
  if ( this->edge_size_evaluator )
    delete this->edge_size_evaluator;
}

bool EntityRefiner::prepare( RefinerTagManager* tmgr, EntityRefinerOutputFunctor* ofunc )
{
  bool rval = true;
  if ( this->edge_size_evaluator )
    {
    this->edge_size_evaluator->set_tag_manager( tmgr );
    }
  else
    {
    rval = false;
    }
  this->set_output_functor( ofunc );
  this->mesh_in = tmgr->get_input_mesh();
  this->update_heap_size();
  return rval;
}

bool EntityRefiner::set_edge_size_evaluator( EdgeSizeEvaluator* ese )
{
  if ( ! ese || ese == this->edge_size_evaluator )
    return false;

  if ( this->edge_size_evaluator )
    {
    delete this->edge_size_evaluator;
    }
  this->edge_size_evaluator = ese;

  return true;
}

bool EntityRefiner::set_output_functor( EntityRefinerOutputFunctor* func_obj )
{
  if ( ! func_obj || func_obj == this->output_functor )
    return false;

  if ( this->output_functor )
    {
    delete this->output_functor;
    }
  this->output_functor = func_obj;
  return true;
}

bool EntityRefiner::set_minimum_number_of_subdivisions( int mn )
{
  if ( mn < 0 || mn == this->minimum_number_of_subdivisions )
    {
    return false;
    }

  this->minimum_number_of_subdivisions = mn;
  return true;
}

bool EntityRefiner::set_maximum_number_of_subdivisions( int mx )
{
  if ( mx < 0 || mx == this->maximum_number_of_subdivisions )
    {
    return false;
    }

  this->maximum_number_of_subdivisions = mx;
  this->update_heap_size();
  return true;
}

void EntityRefiner::update_heap_size()
{
  unsigned long n = this->get_heap_size_bound( this->maximum_number_of_subdivisions );
  this->coord_heap.resize( 6 * n );
  if ( this->edge_size_evaluator )
    {
    unsigned long m = this->edge_size_evaluator->get_tag_manager()->get_vertex_tag_size();
    this->tag_heap.resize( m * n );
    }
}

void EntityRefiner::reset_heap_pointers()
{
  this->current_coord = this->coord_heap.begin();
  this->current_tag = this->tag_heap.begin();
}

double* EntityRefiner::heap_coord_storage()
{
  double* rval;
  if ( this->current_coord != this->coord_heap.end() )
    {
    rval = &(*this->current_coord);
    this->current_coord += 6;
    }
  else
    {
    rval = 0;
    }
  return rval;
}

void* EntityRefiner::heap_tag_storage()
{
  void* rval;
  if ( this->edge_size_evaluator && this->current_tag != this->tag_heap.end() )
    {
    rval = (void*) &(*this->current_tag);
    this->current_tag += this->edge_size_evaluator->get_tag_manager()->get_vertex_tag_size();
    }
  else
    {
    rval = 0;
    }
  return rval;
}

} // namespace moab