oomph::BoundaryNode< NODE_TYPE > Class Template Reference

#include <nodes.h>

Inheritance diagram for oomph::BoundaryNode< NODE_TYPE >:

Public Member Functions
void	clear_copied_pointers ()
	BoundaryNode ()
	Default Constructor. More...
	BoundaryNode (const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_n_value)
	BoundaryNode (TimeStepper *const &time_stepper_pt, const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_n_value)
	BoundaryNode (const unsigned &n_lagrangian, const unsigned &n_lagrangian_type, const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_n_value)
	BoundaryNode (TimeStepper *const &time_stepper_pt, const unsigned &n_lagrangian, const unsigned &n_lagrangian_type, const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_n_value)
	~BoundaryNode ()
	Destructor resets pointers if. More...
	BoundaryNode (const BoundaryNode< NODE_TYPE > &node)=delete
	Broken copy constructor. More...
void	operator= (const BoundaryNode< NODE_TYPE > &)=delete
	Broken assignment operator. More...
bool	boundary_coordinates_have_been_set_up ()
	Have boundary coordinates been set up? More...
void	get_boundaries_pt (std::set< unsigned > *&boundaries_pt)
bool	is_on_boundary () const
bool	is_on_boundary (const unsigned &b) const
void	add_to_boundary (const unsigned &b)
	Add the node to mesh boundary b, final overload. More...
void	remove_from_boundary (const unsigned &b)
	Remover the node from mesh boundary b, final overload. More...
unsigned	ncoordinates_on_boundary (const unsigned &b)
	Get the number of boundary coordinates on mesh boundary b. More...
void	get_coordinates_on_boundary (const unsigned &b, Vector< double > &boundary_zeta)
void	set_coordinates_on_boundary (const unsigned &b, const Vector< double > &boundary_zeta)
void	get_coordinates_on_boundary (const unsigned &b, const unsigned &k, Vector< double > &boundary_zeta)
void	set_coordinates_on_boundary (const unsigned &b, const unsigned &k, const Vector< double > &boundary_zeta)
unsigned	nvalue_assigned_by_face_element (const unsigned &face_id=0) const
void	assign_additional_values_with_face_id (const unsigned &n_additional_value, const unsigned &face_id=0)
void	make_periodic (Node *const &node_pt)
	Make the node periodic. More...
void	make_periodic_nodes (const Vector< Node * > &periodic_nodes_pt)
bool	is_a_copy () const
bool	is_a_copy (const unsigned &i) const
Node *	copied_node_pt () const
void	assign_eqn_numbers (unsigned long &global_ndof, Vector< double * > &dof_pt)
	Overload the equation assignment operation. More...
void	resize (const unsigned &n_value)
	Resize the number of equations. More...
void	make_periodic (Node *const &node_pt)
	Make the node periodic. More...
Public Member Functions inherited from oomph::BoundaryNodeBase
std::map< unsigned, unsigned > *&	index_of_first_value_assigned_by_face_element_pt ()
unsigned	index_of_first_value_assigned_by_face_element (const unsigned &face_id=0) const
unsigned	index_of_first_value_assigned_by_face_element (const bool &throw_if_no_value_assigned_by_face_element, const bool &throw_quietly, const unsigned &face_id=0) const
	BoundaryNodeBase ()
	Default constructor, set the pointers to the storage to NULL. More...
virtual	~BoundaryNodeBase ()
	Destructor, clean up any allocated storage for the boundaries. More...
	BoundaryNodeBase (const BoundaryNodeBase &boundary_node_base)=delete
	Broken copy constructor. More...
void	operator= (const BoundaryNodeBase &)=delete
	Broken assignment operator. More...
bool	boundary_coordinates_have_been_set_up ()
	Have boundary coordinates been set up? More...
void	get_boundaries_pt (std::set< unsigned > *&boundaries_pt)
void	add_to_boundary (const unsigned &b)
	Add the node to the mesh boundary b. More...
void	remove_from_boundary (const unsigned &b)
	Remove the node from the mesh boundary b. More...
bool	is_on_boundary () const
	Test whether the node lies on a boundary. More...
bool	is_on_boundary (const unsigned &b) const
	Test whether the node lies on mesh boundary b. More...
unsigned	ncoordinates_on_boundary (const unsigned &b)
	Get the number of boundary coordinates on mesh boundary b. More...
void	get_coordinates_on_boundary (const unsigned &b, Vector< double > &boundary_zeta)
	Return the vector of boundary coordinates on mesh boundary b. More...
void	set_coordinates_on_boundary (const unsigned &b, const Vector< double > &boundary_zeta)
	Set the vector of boundary coordinates on mesh boundary b. More...
void	get_coordinates_on_boundary (const unsigned &b, const unsigned &k, Vector< double > &boundary_zeta)
void	set_coordinates_on_boundary (const unsigned &b, const unsigned &k, const Vector< double > &boundary_zeta)

Private Member Functions
void	reset_copied_pointers ()
	Set pointers to the copied data used when we have periodic nodes. More...
void	clear_additional_copied_pointers ()

Additional Inherited Members
Protected Member Functions inherited from oomph::BoundaryNodeBase
void	make_node_periodic (Node *const &node_pt, Node *const &original_node_pt)
void	make_nodes_periodic (Node *const &node_pt, Vector< Node * > const &periodic_copies_pt)
Protected Attributes inherited from oomph::BoundaryNodeBase
std::map< unsigned, unsigned > *	Index_of_first_value_assigned_by_face_element_pt
Node *	Copied_node_pt

Detailed Description

template<class NODE_TYPE>
class oomph::BoundaryNode< NODE_TYPE >

A template Class for BoundaryNodes; that is Nodes that MAY live on the boundary of a Mesh. The class is formed by a simple composition of the template parameter NODE_TYPE, which must be a Node class and the BoundaryNodeBase class. Final overloading of functions is always in favour of the BoundaryNodeBase implementation; i.e. these nodes can live on boundaries.

Constructor & Destructor Documentation

BoundaryNode() [1/6]

template<class NODE_TYPE >

oomph::BoundaryNode< NODE_TYPE >::BoundaryNode ( )

inline

Default Constructor.

: NODE_TYPE(), BoundaryNodeBase() {}

BoundaryNode() [2/6]

template<class NODE_TYPE >

oomph::BoundaryNode< NODE_TYPE >::BoundaryNode ( const unsigned &  n_dim, const unsigned &  n_position_type, const unsigned &  initial_n_value  )

inline

Steady constructor, for a BoundaryNode of spatial dimension n_dim. Simply passes all arguments through to the underlying Node constructor which allocates storage for initial_n_value values. NPosition_type is the number of coordinate types needed in the mapping between local and global coordinates (e.g. 1 for Lagrange-type elements; 2 for 1D Hermite elements; 4 for 2D Hermite elements, etc).

      : NODE_TYPE(n_dim, n_position_type, initial_n_value), BoundaryNodeBase()
    {
    }

BoundaryNode() [3/6]

template<class NODE_TYPE >

oomph::BoundaryNode< NODE_TYPE >::BoundaryNode ( TimeStepper *const &  time_stepper_pt, const unsigned &  n_dim, const unsigned &  n_position_type, const unsigned &  initial_n_value  )

inline

Unsteady constructor for a BoundaryNode of spatial dimension n_dim. Simply passes all arguments through to the underlygin Node constructor which allocates storage for initial_n_value values with history values as required by the timestepper. n_position_type: # of coordinate types needed in the mapping between local and global coordinates (e.g. 1 for Lagrange-type elements; 2 for 1D Hermite elements; 4 for 2D Hermite elements).

      : NODE_TYPE(time_stepper_pt, n_dim, n_position_type, initial_n_value),
        BoundaryNodeBase()
    {
    }

BoundaryNode() [4/6]

template<class NODE_TYPE >

oomph::BoundaryNode< NODE_TYPE >::BoundaryNode ( const unsigned &  n_lagrangian, const unsigned &  n_lagrangian_type, const unsigned &  n_dim, const unsigned &  n_position_type, const unsigned &  initial_n_value  )

inline

Steady constructor for Solid-type boundary nodes. The node has n_lagrangian Lagrangian coordinates of n_lagrangian_type types (1 for Lagrange elements, 2 for 1D Hermite etc.). The Eulerian dimension of the Node is n_dim and we have n_position_type (generalised) Eulerian coordinates. There are initial_n_value values stored at this node.

      : NODE_TYPE(n_lagrangian,
                  n_lagrangian_type,
                  n_dim,
                  n_position_type,
                  initial_n_value),
        BoundaryNodeBase()
    {
    }

BoundaryNode() [5/6]

template<class NODE_TYPE >

oomph::BoundaryNode< NODE_TYPE >::BoundaryNode ( TimeStepper *const &  time_stepper_pt, const unsigned &  n_lagrangian, const unsigned &  n_lagrangian_type, const unsigned &  n_dim, const unsigned &  n_position_type, const unsigned &  initial_n_value  )

inline

Unsteady constructor for Solid-type boundary nodes Allocates storage for initial_n_value nodal values with history values as required by timestepper. The node has n_lagrangian Lagrangian coordinates of n_lagrangian_type types (1 for Lagrange elements, 2 for 1D Hermite etc.)/ The Eulerian dimension of the Node is n_dim and we have n_position_type generalised Eulerian coordinates.

      : NODE_TYPE(time_stepper_pt,
                  n_lagrangian,
                  n_lagrangian_type,
                  n_dim,
                  n_position_type,
                  initial_n_value),
        BoundaryNodeBase()
    {
    }

~BoundaryNode()

template<class NODE_TYPE >

oomph::BoundaryNode< NODE_TYPE >::~BoundaryNode ( )

inline

Destructor resets pointers if.

    {
      // If there are any copies of this Node
      // then we need to clear their pointers to information stored in
      // this BoundaryNode
      // at this level because once we are down to the Node's destructor
      // the information no longer exists.
      for (unsigned i = 0; i < this->Ncopies; i++)
      {
        // Is the copied node a boundary node (it should be)
        BoundaryNode<NODE_TYPE>* cast_node_pt =
          dynamic_cast<BoundaryNode<NODE_TYPE>*>(this->Copy_of_data_pt[i]);
        // We can only do this if the node is a boundary node
        if (cast_node_pt != 0)
        {
          // This is required to clear out any pointers to the additional
          // data assigned by face elements
          cast_node_pt->clear_additional_copied_pointers();
        }
        // Otherwise there is a problem if it's not Hijacked Data
#ifdef PARANOID
        else
        {
          if (dynamic_cast<HijackedData*>(this->Copy_of_data_pt[i]) == 0)
          {
            OomphLibError(
              "Copy of a BoundaryNode is not a BoundaryNode or HijackedData",
              "BoundaryNode::~BoundaryNode",
              OOMPH_EXCEPTION_LOCATION);
          }
        }
#endif
      }
 
      // If the node was periodic then clear the pointers before deleting
      if (Copied_node_pt)
      {
        // Inform the node that the copy is being deleted
        // If the original has been deleted Copied_node_pt will be NULL
        Copied_node_pt->remove_copy(this);
        Copied_node_pt = 0;
        this->Value = 0;
        this->Eqn_number = 0;
        // Remove the information about the boundary node storage scheme
        this->Index_of_first_value_assigned_by_face_element_pt = 0;
      }
    }

References oomph::BoundaryNode< NODE_TYPE >::clear_additional_copied_pointers(), oomph::BoundaryNodeBase::Copied_node_pt, i, oomph::BoundaryNodeBase::Index_of_first_value_assigned_by_face_element_pt, OOMPH_EXCEPTION_LOCATION, and oomph::Data::remove_copy().

BoundaryNode() [6/6]

template<class NODE_TYPE >

oomph::BoundaryNode< NODE_TYPE >::BoundaryNode ( const BoundaryNode< NODE_TYPE > &  node )

delete

Broken copy constructor.

Member Function Documentation

add_to_boundary()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::add_to_boundary ( const unsigned &  b )

inline

Add the node to mesh boundary b, final overload.

    {
      BoundaryNodeBase::add_to_boundary(b);
    }

References oomph::BoundaryNodeBase::add_to_boundary(), and b.

assign_additional_values_with_face_id()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::assign_additional_values_with_face_id ( const unsigned &  n_additional_value, const unsigned &  face_id = 0  )

inlinevirtual

Member function to allocates storage for a given number of additional degrees of freedom, n_additional_value, associated with a particular face_id to the Node node_pt. Needs to be filled in here so that access to the nodal values is available.

Implements oomph::BoundaryNodeBase.

    {
#ifdef PARANOID
      // If nothing is being added warn the user
      if (n_additional_value == 0)
      {
        std::ostringstream warn_message;
        warn_message
          << "No additional data values are being added to the boundary node "
          << this << "\n"
          << "by face id " << face_id << ".\n"
          << "This means that the function \n"
          << "BoundaryNode::index_of_first_value_assigned_by_face_element(id) "
             "\n"
          << "will return a value that is equal to the number of values stored "
             "at the Node.\n"
          << "Calling Node::value(...) with this index will lead to an "
             "out-of-range error.\n"
          << "The anticpated usage of a loop from the index over the number of "
             "values.\n"
          << "will not cause any problems, but if you try to do anything else, "
             "you may be surprised.\n"
          << "You have been warned!\n";
        OomphLibWarning(
          warn_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // Allocate storage if not already assigned
      if (this->Index_of_first_value_assigned_by_face_element_pt == 0)
      {
        this->Index_of_first_value_assigned_by_face_element_pt =
          new std::map<unsigned, unsigned>;
      }
 
      // Find the number of values already stored in the node
      const unsigned n_value = this->nvalue();
 
      // If this ID hasn't already been used
      if (this->Index_of_first_value_assigned_by_face_element_pt->find(
            face_id) ==
          this->Index_of_first_value_assigned_by_face_element_pt->end())
      {
        // Set the first index to by number of values
        (*Index_of_first_value_assigned_by_face_element_pt)[face_id] = n_value;
      }
      // Otherwise this ID has been used previously
      else
      {
        // Find the number of values associated with this id
        const unsigned n_value_for_id =
          this->nvalue_assigned_by_face_element(face_id);
 
        // If the number of current values is equal to the desired values
        // do nothing and return
        if (n_value_for_id == n_additional_value)
        {
          return;
        }
        // Otherwise
        else
        {
          // Safety check, are the value associated with this id
          // all at the end
          if (((*this->Index_of_first_value_assigned_by_face_element_pt)
                 [face_id] +
               n_value_for_id) != n_value)
          {
#ifdef PARANOID
            std::ostringstream warn_message;
            warn_message << "Trying to (resize) number of unknowns associated "
                            "with face id "
                         << face_id << "\n"
                         << "but previous storage for this data is not at the "
                            "end of the nodal values.\n"
                         << "The anticipated usage here is within constructors "
                            "that add additional equations\n"
                         << "to existing FaceElements in which case we will "
                            "always be at the end.\n"
                         << "If you are trying to do something else, then try "
                            "using a different id.\n"
                         << " FaceElement::add_additional_values(...)."
                         << " For consistency with earlier versions, this will "
                            "do nothing!\n";
            OomphLibWarning(warn_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
#endif
            // Just return without doing anything
            return;
          }
        } // Case when we are actually requesting additional values
      } // End case when ID has already been touched
 
      // Now finally resize the storage
      this->resize(n_value + n_additional_value);
    }

References oomph::BoundaryNodeBase::Index_of_first_value_assigned_by_face_element_pt, oomph::BoundaryNode< NODE_TYPE >::nvalue_assigned_by_face_element(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::BoundaryNode< NODE_TYPE >::resize().

assign_eqn_numbers()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::assign_eqn_numbers ( unsigned long &  global_ndof, Vector< double * > &  dof_pt  )

inline

Overload the equation assignment operation.

    {
      // If the boundary node is not periodic call the ususal
      // assign equation numbers
      if (Copied_node_pt == 0)
      {
        NODE_TYPE::assign_eqn_numbers(global_ndof, dof_pt);
      }
      // Otherwise make sure that we assign equation numbers for
      // the variable position pointer of the solid node
      else
      {
        // Is it a solid node?
        SolidNode* solid_node_pt = dynamic_cast<SolidNode*>(this);
        if (solid_node_pt)
        {
          // If so we must let the variable position pointer take care of
          // itself
          solid_node_pt->variable_position_pt()->assign_eqn_numbers(global_ndof,
                                                                    dof_pt);
        }
      }
    }

References oomph::Data::assign_eqn_numbers(), oomph::BoundaryNodeBase::Copied_node_pt, and oomph::SolidNode::variable_position_pt().

boundary_coordinates_have_been_set_up()

template<class NODE_TYPE >

bool oomph::BoundaryNode< NODE_TYPE >::boundary_coordinates_have_been_set_up ( )

inline

Have boundary coordinates been set up?

    {
      return BoundaryNodeBase::boundary_coordinates_have_been_set_up();
    }

References oomph::BoundaryNodeBase::boundary_coordinates_have_been_set_up().

clear_additional_copied_pointers()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::clear_additional_copied_pointers ( )

inlineprivate

Copy over additional information so that if the node is periodic it can remain active if the node that holds the periodic data is deleted

    {
      // Only worry about the face index if it has been assigned
      // which it will have been
      if (this->index_of_first_value_assigned_by_face_element_pt() != 0)
      {
        // Allocate new storage for the index of first value assigned by face
        // element The other storage will be deleted
        this->index_of_first_value_assigned_by_face_element_pt() =
          new std::map<unsigned, unsigned>;
 
        // Cast copied_node_pt to BoundaryNode so that we can reset the index
        BoundaryNode<NODE_TYPE>* cast_copied_node_pt =
          dynamic_cast<BoundaryNode<NODE_TYPE>*>(Copied_node_pt);
 
        // Check that dynamic cast has worked
        if (cast_copied_node_pt)
        {
          // Initialise the values in the map to be those of the original data
          // std::map<unsigned,unsigned>::const_iterator it =
          // (*(cast_copied_node_pt->
          //    index_of_first_value_assigned_by_face_element_pt())).begin();
          std::map<unsigned, unsigned>::const_iterator end =
            (*(cast_copied_node_pt
                 ->index_of_first_value_assigned_by_face_element_pt()))
              .end();
          for (std::map<unsigned, unsigned>::const_iterator it =
                 (*(cast_copied_node_pt
                      ->index_of_first_value_assigned_by_face_element_pt()))
                   .begin();
               it != end;
               it++)
          {
            (*(this->index_of_first_value_assigned_by_face_element_pt()))
              [it->first] = it->second;
          }
        }
      }
    }

References oomph::BoundaryNodeBase::Copied_node_pt, Eigen::placeholders::end, and oomph::BoundaryNodeBase::index_of_first_value_assigned_by_face_element_pt().

Referenced by oomph::BoundaryNode< NODE_TYPE >::~BoundaryNode().

clear_copied_pointers()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::clear_copied_pointers ( )

inline

Clear pointers to the copied data used when we have periodic nodes. The shallow (pointer) copy is turned into a deep copy by allocating new data and copying the actual values across.

    {
#ifdef PARANOID
      if (Copied_node_pt == 0)
      {
        throw OomphLibError("BoundaryNode has not been copied",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // Simply zeroing these will cause problems during unrefinement because
      // the original could be deleted, but the "copy" remain. Instead we
      // allocate new storage and copy values over from the original.
 
      // Get the number of values and time storage
      //(must be the same as the original)
      const unsigned n_value = this->nvalue();
      const unsigned n_tstorage = this->ntstorage();
 
      // Allocate storage for equation numbers
      this->Eqn_number = new long[n_value];
 
      // Allocate storage for the values
      this->Value = new double*[n_value];
 
      // Allocate all data values in one big array
      double* values = new double[n_value * n_tstorage];
 
      // Set the pointers to the data values and equation numbers
      for (unsigned i = 0; i < n_value; ++i)
      {
        // Set the pointers
        this->Value[i] = &values[i * n_tstorage];
        // Initialise all the values to be those of the original data
        for (unsigned t = 0; t < n_tstorage; ++t)
        {
          this->Value[i][t] = Copied_node_pt->value(t, i);
        }
 
        // Copy over the values of the equation numbers
        this->Eqn_number[i] = Copied_node_pt->eqn_number(i);
      }
 
      // The node is no longer a copy
      Copied_node_pt = 0;
    }

References oomph::BoundaryNodeBase::Copied_node_pt, oomph::Data::eqn_number(), i, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, plotPSD::t, and oomph::Node::value().

copied_node_pt()

template<class NODE_TYPE >

Node* oomph::BoundaryNode< NODE_TYPE >::copied_node_pt ( ) const

inline

Return pointer to copied node (null if the current node is not a copy)

    {
      return Copied_node_pt;
    }

References oomph::BoundaryNodeBase::Copied_node_pt.

get_boundaries_pt()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::get_boundaries_pt ( std::set< unsigned > *&  boundaries_pt )

inline

Access to pointer to set of mesh boundaries that this node occupies; NULL if the node is not on any boundary Final overload

    {
      BoundaryNodeBase::get_boundaries_pt(boundaries_pt);
    }

References oomph::BoundaryNodeBase::get_boundaries_pt().

get_coordinates_on_boundary() [1/2]

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::get_coordinates_on_boundary ( const unsigned &  b, const unsigned &  k, Vector< double > &  boundary_zeta  )

inline

Return the vector of k-th generalised boundary coordinates on mesh boundary b Final overload

    {
      BoundaryNodeBase::get_coordinates_on_boundary(b, k, boundary_zeta);
    }

References b, oomph::BoundaryNodeBase::get_coordinates_on_boundary(), and k.

get_coordinates_on_boundary() [2/2]

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::get_coordinates_on_boundary ( const unsigned &  b, Vector< double > &  boundary_zeta  )

inline

Return the vector of coordinates on mesh boundary b Final overload

    {
      BoundaryNodeBase::get_coordinates_on_boundary(b, boundary_zeta);
    }

References b, and oomph::BoundaryNodeBase::get_coordinates_on_boundary().

is_a_copy() [1/2]

template<class NODE_TYPE >

bool oomph::BoundaryNode< NODE_TYPE >::is_a_copy ( ) const

inline

Return a boolean to indicate whether the data contains any copied values. If the node is periodic all values are copied

    {
      if (Copied_node_pt)
      {
        return true;
      }
      else
      {
        return false;
      }
    }

References oomph::BoundaryNodeBase::Copied_node_pt.

is_a_copy() [2/2]

template<class NODE_TYPE >

bool oomph::BoundaryNode< NODE_TYPE >::is_a_copy ( const unsigned &  i ) const

inline

Return a boolean to indicate whether the i-th value is a copied value. If the node is periodic all values are copies

    {
      if (Copied_node_pt)
      {
        return true;
      }
      else
      {
        return false;
      }
    }

References oomph::BoundaryNodeBase::Copied_node_pt.

is_on_boundary() [1/2]

template<class NODE_TYPE >

bool oomph::BoundaryNode< NODE_TYPE >::is_on_boundary ( ) const

inline

Test whether the node lies on a boundary Final overload

    {
      return BoundaryNodeBase::is_on_boundary();
    }

References oomph::BoundaryNodeBase::is_on_boundary().

Referenced by oomph::HermiteQuadMesh< ELEMENT >::set_position_of_boundary_node().

is_on_boundary() [2/2]

template<class NODE_TYPE >

bool oomph::BoundaryNode< NODE_TYPE >::is_on_boundary ( const unsigned &  b ) const

inline

Test whether the node lies on mesh boundary b Final overload

    {
      return BoundaryNodeBase::is_on_boundary(b);
    }

References b, and oomph::BoundaryNodeBase::is_on_boundary().

make_periodic() [1/2]

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::make_periodic ( Node *const &  node_pt )

inline

Make the node periodic.

    {
      BoundaryNodeBase::make_node_periodic(this, node_pt);
    }

References oomph::BoundaryNodeBase::make_node_periodic().

make_periodic() [2/2]

void oomph::BoundaryNode< SolidNode >::make_periodic ( Node *const &  node_pt )

inline

Make the node periodic.

  {
#ifdef PARANOID
    std::ostringstream warn_message;
    warn_message << "You are trying to make a Solid Node Periodic.\n"
                 << "This action will reset pointers to stored values and "
                 << "equation numbers,\n"
                 << "meaning that all values will be shared by this Node and "
                 << "its master.\n"
                 << "Unfortunately, this does not ensure that the variable "
                 << "nodal coordinates coincide.\n"
                 << "For matching nodal coordinates the options are:\n"
                 << "(i) Introduce Lagrange multipliers,\n"
                 << "(ii) Pin one side and treat the data as dependent,\n"
                 << "(iii) Hijack the nodal coordinates on one side "
                 << "and specify an alternative equation.\n\n"
                 << "If you plan to use refineability, then the easiest\n"
                 << "option is to use Lagrange multipliers.\n"
                 << std::endl;
    OomphLibWarning(
      warn_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
#endif
 
    BoundaryNodeBase::make_node_periodic(this, node_pt);
  }

References oomph::BoundaryNodeBase::make_node_periodic(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

make_periodic_nodes()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::make_periodic_nodes ( const Vector< Node * > &  periodic_nodes_pt )

inline

Make the nodes passed in periodic_nodes periodic from this node

    {
      BoundaryNodeBase::make_nodes_periodic(this, periodic_nodes_pt);
    }

References oomph::BoundaryNodeBase::make_nodes_periodic().

ncoordinates_on_boundary()

template<class NODE_TYPE >

unsigned oomph::BoundaryNode< NODE_TYPE >::ncoordinates_on_boundary ( const unsigned &  b )

inline

Get the number of boundary coordinates on mesh boundary b.

    {
      return BoundaryNodeBase::ncoordinates_on_boundary(b);
    }

References b, and oomph::BoundaryNodeBase::ncoordinates_on_boundary().

nvalue_assigned_by_face_element()

template<class NODE_TYPE >

unsigned oomph::BoundaryNode< NODE_TYPE >::nvalue_assigned_by_face_element ( const unsigned &  face_id = 0 ) const

inlinevirtual

Return the number of values associated with the i-th face element field. If no argument is specified we return the value associated with the first (and assumed to be only) face element attached to this node. Throws error only in paranoid mode if no values have been set by any FaceElements. If you want to catch such cases gracefully in all circumstances (there are examples with complex unstructured 3D meshes where it's not clear a priori if a node has been resized by FaceElements) use alternative version (with leading bool arguments) that always checks and throws so exceptions can be caught gracefully. Returns UINT_MAX if error.

Implements oomph::BoundaryNodeBase.

    {
#ifdef PARANOID
      if (Index_of_first_value_assigned_by_face_element_pt == 0)
      {
        std::ostringstream error_message;
        error_message
          << "Index_of_first_value_assigned_by_face_element_pt==0;\n"
          << "Pointer must be set via call to: \n\n"
          << "  BoundaryNode::assign_additional_values_with_face_id(), \n\n"
          << "typically from FaceElement::add_additional_values(...).";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
        return UINT_MAX;
      }
#endif
 
      // How many values are there in total?
      unsigned nval = this->nvalue();
 
      // If ID is not present in the map then return 0
      if (Index_of_first_value_assigned_by_face_element_pt->find(face_id) ==
          Index_of_first_value_assigned_by_face_element_pt->end())
      {
        return 0;
      }
 
      // Otherwise the entry is present in the map
 
      // Single entry: Number of values is the difference between
      // number of values and first index
      else if ((*Index_of_first_value_assigned_by_face_element_pt).size() == 1)
      {
        return nval -
               (*Index_of_first_value_assigned_by_face_element_pt)[face_id];
      }
      else
      {
        // Find the next first index: Default: nvalue()
        unsigned next_first_index = nval;
        unsigned my_first_index =
          (*Index_of_first_value_assigned_by_face_element_pt)[face_id];
        for (std::map<unsigned, unsigned>::iterator it =
               (*Index_of_first_value_assigned_by_face_element_pt).begin();
             it != (*Index_of_first_value_assigned_by_face_element_pt).end();
             it++)
        {
          unsigned first_index = (*it).second;
          if ((first_index > my_first_index) &&
              (first_index < next_first_index))
          {
            next_first_index = first_index;
          }
        }
        return next_first_index - my_first_index;
      }
    }

References oomph::BoundaryNodeBase::Index_of_first_value_assigned_by_face_element_pt, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::BoundaryNode< NODE_TYPE >::assign_additional_values_with_face_id().

operator=()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::operator= ( const BoundaryNode< NODE_TYPE > &  )

delete

Broken assignment operator.

remove_from_boundary()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::remove_from_boundary ( const unsigned &  b )

inline

Remover the node from mesh boundary b, final overload.

    {
      BoundaryNodeBase::remove_from_boundary(b);
    }

References b, and oomph::BoundaryNodeBase::remove_from_boundary().

reset_copied_pointers()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::reset_copied_pointers ( )

inlineprivate

Set pointers to the copied data used when we have periodic nodes.

    {
#ifdef PARANOID
      if (Copied_node_pt == 0)
      {
        throw OomphLibError("BoundaryNode has not been copied",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // Set the number of values
      this->Nvalue = Copied_node_pt->nvalue();
      this->Value = Copied_node_pt->Value;
      this->Eqn_number = Copied_node_pt->Eqn_number;
      // We won't ever need to worry about updating position pointers
      // because periodic solid problems are handled using lagrange multipliers.
 
      // Cast Copied_node_pt to BoundaryNode to copy over the
      // Face index pointer
      BoundaryNode<NODE_TYPE>* cast_copied_node_pt =
        dynamic_cast<BoundaryNode<NODE_TYPE>*>(Copied_node_pt);
 
      // Check that dynamic cast has worked
      if (cast_copied_node_pt)
      {
        this->index_of_first_value_assigned_by_face_element_pt() =
          cast_copied_node_pt
            ->index_of_first_value_assigned_by_face_element_pt();
      }
      else
      {
        std::ostringstream error_stream;
        error_stream << "Copied_node_pt is not of type BoundaryNode*"
                     << std::endl;
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
    }

References oomph::BoundaryNodeBase::Copied_node_pt, oomph::Data::Eqn_number, oomph::BoundaryNodeBase::index_of_first_value_assigned_by_face_element_pt(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Data::Value.

resize()

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::resize ( const unsigned &  n_value )

inline

Resize the number of equations.

    {
      // If the node is periodic, warn, but do nothing
      if (Copied_node_pt)
      {
#ifdef PARANOID
        unsigned n_value_new = Copied_node_pt->nvalue();
        // Check that we have already resized the original
        if (n_value_new != n_value)
        {
          std::ostringstream error_stream;
          error_stream
            << "Call to resize copied node before original has been resized!"
            << std::endl;
          throw OomphLibError(error_stream.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
#endif
      }
      // Otherwise call the underlying function
      else
      {
        NODE_TYPE::resize(n_value);
      }
    }

References oomph::BoundaryNodeBase::Copied_node_pt, oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and resize().

Referenced by oomph::BoundaryNode< NODE_TYPE >::assign_additional_values_with_face_id().

set_coordinates_on_boundary() [1/2]

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::set_coordinates_on_boundary ( const unsigned &  b, const unsigned &  k, const Vector< double > &  boundary_zeta  )

inline

Set the vector of k-th generalised boundary coordinates on mesh boundary b. Final overload

    {
      BoundaryNodeBase::set_coordinates_on_boundary(b, k, boundary_zeta);
    }

References b, k, and oomph::BoundaryNodeBase::set_coordinates_on_boundary().

set_coordinates_on_boundary() [2/2]

template<class NODE_TYPE >

void oomph::BoundaryNode< NODE_TYPE >::set_coordinates_on_boundary ( const unsigned &  b, const Vector< double > &  boundary_zeta  )

inline

Set the vector of coordinates on mesh boundary b Final overload

    {
      BoundaryNodeBase::set_coordinates_on_boundary(b, boundary_zeta);
    }

References b, and oomph::BoundaryNodeBase::set_coordinates_on_boundary().

Referenced by oomph::HermiteQuadMesh< ELEMENT >::set_position_of_boundary_node().

---

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

• nodes.h