oomph::DummyErrorEstimator Class Reference

#include <error_estimator.h>

Inheritance diagram for oomph::DummyErrorEstimator:

Public Member Functions
	DummyErrorEstimator (Mesh *mesh_pt, const Vector< unsigned > &elements_to_refine, const unsigned &central_node_number, const bool &use_lagrangian_coordinates=false)
	DummyErrorEstimator (Mesh *mesh_pt, const Vector< double > &lower_left, const Vector< double > &upper_right, const unsigned &central_node_number, const bool &use_lagrangian_coordinates=false)
	DummyErrorEstimator (const DummyErrorEstimator &)=delete
	Broken copy constructor. More...
void	operator= (const DummyErrorEstimator &)=delete
	Broken assignment operator. More...
virtual	~DummyErrorEstimator ()
	Empty virtual destructor. More...
virtual void	get_element_errors (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info)
Public Member Functions inherited from oomph::ErrorEstimator
	ErrorEstimator ()
	Default empty constructor. More...
	ErrorEstimator (const ErrorEstimator &)=delete
	Broken copy constructor. More...
void	operator= (const ErrorEstimator &)=delete
	Broken assignment operator. More...
virtual	~ErrorEstimator ()
	Empty virtual destructor. More...
void	get_element_errors (Mesh *&mesh_pt, Vector< double > &elemental_error)

Private Attributes
bool	Use_lagrangian_coordinates
unsigned	Central_node_number
Vector< Vector< double > >	Region_upp_bound
	Upper bounds for the coordinates of the refinement regions. More...
Vector< Vector< double > >	Region_low_bound
	Lower bounds for the coordinates of the refinement regions. More...

Detailed Description

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Dummy error estimator, allows manual specification of refinement pattern by forcing refinement in regions defined by elements in a reference mesh.

Constructor & Destructor Documentation

DummyErrorEstimator() [1/3]

oomph::DummyErrorEstimator::DummyErrorEstimator ( Mesh *  mesh_pt, const Vector< unsigned > &  elements_to_refine, const unsigned &  central_node_number, const bool &  use_lagrangian_coordinates = false  )

inline

Constructor. Provide mesh and number of the elements that define the regions within which elements are to be refined subsequently. Also specify the node number of a central node within elements – it's used to determine if an element is in the region where refinement is supposed to take place. Optional boolean flag (defaulting to false) indicates that refinement decision is based on Lagrangian coordinates – only applicable to solid meshes.

      : Use_lagrangian_coordinates(use_lagrangian_coordinates),
        Central_node_number(central_node_number)
    {
#ifdef PARANOID
#ifdef OOMPH_HAS_MPI
      if (mesh_pt->is_mesh_distributed())
      {
        throw OomphLibError(
          "Can't use this error estimator on distributed meshes!",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
#endif
#endif
 
#ifdef PARANOID
      if (mesh_pt->nelement() == 0)
      {
        throw OomphLibError(
          "Can't build error estimator if there are no elements in mesh\n",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      unsigned dim = mesh_pt->finite_element_pt(0)->node_pt(0)->ndim();
      if (use_lagrangian_coordinates)
      {
        SolidNode* solid_nod_pt =
          dynamic_cast<SolidNode*>(mesh_pt->finite_element_pt(0)->node_pt(0));
        if (solid_nod_pt != 0)
        {
          dim = solid_nod_pt->nlagrangian();
        }
      }
      unsigned nregion = elements_to_refine.size();
      Region_low_bound.resize(nregion);
      Region_upp_bound.resize(nregion);
      for (unsigned e = 0; e < nregion; e++)
      {
        Region_low_bound[e].resize(dim, 1.0e20);
        Region_upp_bound[e].resize(dim, -1.0e20);
        FiniteElement* el_pt =
          mesh_pt->finite_element_pt(elements_to_refine[e]);
        unsigned nnod = el_pt->nnode();
        for (unsigned j = 0; j < nnod; j++)
        {
          Node* nod_pt = el_pt->node_pt(j);
          for (unsigned i = 0; i < dim; i++)
          {
            double x = nod_pt->x(i);
            if (use_lagrangian_coordinates)
            {
              SolidNode* solid_nod_pt = dynamic_cast<SolidNode*>(nod_pt);
              if (solid_nod_pt != 0)
              {
                x = solid_nod_pt->xi(i);
              }
            }
            if (x < Region_low_bound[e][i])
            {
              Region_low_bound[e][i] = x;
            }
            if (x > Region_upp_bound[e][i])
            {
              Region_upp_bound[e][i] = x;
            }
          }
        }
      }
    }

References e(), oomph::Mesh::finite_element_pt(), i, oomph::Mesh::is_mesh_distributed(), j, oomph::Node::ndim(), oomph::Mesh::nelement(), oomph::SolidNode::nlagrangian(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Region_low_bound, Region_upp_bound, plotDoE::x, oomph::Node::x(), and oomph::SolidNode::xi().

DummyErrorEstimator() [2/3]

oomph::DummyErrorEstimator::DummyErrorEstimator ( Mesh *  mesh_pt, const Vector< double > &  lower_left, const Vector< double > &  upper_right, const unsigned &  central_node_number, const bool &  use_lagrangian_coordinates = false  )

inline

Constructor. Provide vectors to "lower left" and "upper right" vertices of refinement region Also specify the node number of a central node within elements – it's used to determine if an element is in the region where refinement is supposed to take place. Optional boolean flag (defaulting to false) indicates that refinement decision is based on Lagrangian coordinates – only applicable to solid meshes.

      : Use_lagrangian_coordinates(use_lagrangian_coordinates),
        Central_node_number(central_node_number)
    {
#ifdef PARANOID
      if (mesh_pt->nelement() == 0)
      {
        throw OomphLibError(
          "Can't build error estimator if there are no elements in mesh\n",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      unsigned nregion = 1;
      Region_low_bound.resize(nregion);
      Region_upp_bound.resize(nregion);
      Region_low_bound[0] = lower_left;
      Region_upp_bound[0] = upper_right;
    }

References oomph::Mesh::nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Region_low_bound, and Region_upp_bound.

DummyErrorEstimator() [3/3]

oomph::DummyErrorEstimator::DummyErrorEstimator ( const DummyErrorEstimator &  )

delete

Broken copy constructor.

~DummyErrorEstimator()

virtual oomph::DummyErrorEstimator::~DummyErrorEstimator ( )

inlinevirtual

Empty virtual destructor.

{}

Member Function Documentation

get_element_errors()

virtual void oomph::DummyErrorEstimator::get_element_errors ( Mesh *&  mesh_pt, Vector< double > &  elemental_error, DocInfo &  doc_info  )

inlinevirtual

Compute the elemental error measures for a given mesh and store them in a vector. Doc errors etc.

Implements oomph::ErrorEstimator.

    {
#ifdef PARANOID
      if (doc_info.is_doc_enabled())
      {
        std::ostringstream warning_stream;
        warning_stream
          << "No output defined in DummyErrorEstimator::get_element_errors()\n"
          << "Ignoring doc_info flag.\n";
        OomphLibWarning(warning_stream.str(),
                        "DummyErrorEstimator::get_element_errors()",
                        OOMPH_EXCEPTION_LOCATION);
      }
#endif
      unsigned nregion = Region_low_bound.size();
      unsigned nelem = mesh_pt->nelement();
      for (unsigned e = 0; e < nelem; e++)
      {
        elemental_error[e] = 0.0;
 
        // Check if element is in the regions to be refined
        // (based on coords of its central node)
        Node* nod_pt =
          mesh_pt->finite_element_pt(e)->node_pt(Central_node_number);
        for (unsigned r = 0; r < nregion; r++)
        {
          bool is_inside = true;
          unsigned dim = Region_low_bound[r].size();
          for (unsigned i = 0; i < dim; i++)
          {
            double x = nod_pt->x(i);
            if (Use_lagrangian_coordinates)
            {
              SolidNode* solid_nod_pt = dynamic_cast<SolidNode*>(nod_pt);
              if (solid_nod_pt != 0)
              {
                x = solid_nod_pt->xi(i);
              }
            }
            if (x < Region_low_bound[r][i])
            {
              is_inside = false;
              break;
            }
            if (x > Region_upp_bound[r][i])
            {
              is_inside = false;
              break;
            }
          }
          if (is_inside)
          {
            elemental_error[e] = 1.0;
            break;
          }
        }
      }
    }

References Central_node_number, e(), oomph::Mesh::finite_element_pt(), i, oomph::DocInfo::is_doc_enabled(), oomph::Mesh::nelement(), oomph::FiniteElement::node_pt(), OOMPH_EXCEPTION_LOCATION, UniformPSDSelfTest::r, Region_low_bound, Region_upp_bound, Use_lagrangian_coordinates, plotDoE::x, oomph::Node::x(), and oomph::SolidNode::xi().

operator=()

void oomph::DummyErrorEstimator::operator= ( const DummyErrorEstimator &  )

delete

Broken assignment operator.

Member Data Documentation

Central_node_number

unsigned oomph::DummyErrorEstimator::Central_node_number

private

Number of local node that is used to identify if an element is located in the refinement region

Referenced by get_element_errors().

Region_low_bound

Vector<Vector<double> > oomph::DummyErrorEstimator::Region_low_bound

private

Lower bounds for the coordinates of the refinement regions.

Referenced by DummyErrorEstimator(), and get_element_errors().

Region_upp_bound

Vector<Vector<double> > oomph::DummyErrorEstimator::Region_upp_bound

private

Upper bounds for the coordinates of the refinement regions.

Referenced by DummyErrorEstimator(), and get_element_errors().

Use_lagrangian_coordinates

bool oomph::DummyErrorEstimator::Use_lagrangian_coordinates

private

Use Lagrangian coordinates to decide which element is to be refined

Referenced by get_element_errors().

---

The documentation for this class was generated from the following file:

• error_estimator.h