oomph::BoundaryNodeBase Class Reference

#include <nodes.h>

Inheritance diagram for oomph::BoundaryNodeBase:

Public Member Functions
virtual void	assign_additional_values_with_face_id (const unsigned &n_additional_value, const unsigned &face_id=0)=0
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
virtual unsigned	nvalue_assigned_by_face_element (const unsigned &face_id=0) const =0
	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)

Protected Member Functions
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
std::map< unsigned, unsigned > *	Index_of_first_value_assigned_by_face_element_pt
Node *	Copied_node_pt

Private Attributes
std::map< unsigned, DenseMatrix< double > * > *	Boundary_coordinates_pt
std::set< unsigned > *	Boundaries_pt

Detailed Description

A class that contains the information required by Nodes that are located on Mesh boundaries. A BoundaryNode of a particular type is obtained by combining a given Node with this class. By differentiating between Nodes and BoundaryNodes we avoid a lot of un-necessary storage in the bulk Nodes.

Constructor & Destructor Documentation

BoundaryNodeBase() [1/2]

oomph::BoundaryNodeBase::BoundaryNodeBase ( )

inline

Default constructor, set the pointers to the storage to NULL.

      : Boundary_coordinates_pt(0),
        Boundaries_pt(0),
        Index_of_first_value_assigned_by_face_element_pt(0),
        Copied_node_pt(0)
    {
    }

~BoundaryNodeBase()

oomph::BoundaryNodeBase::~BoundaryNodeBase ( )

virtual

Destructor, clean up any allocated storage for the boundaries.

Destructor to clean up any memory that might have been allocated.

  {
    // Delete the set of boundaries on which the Node lies
    delete Boundaries_pt;
    Boundaries_pt = 0;
 
    // If the Boundary coordinates have been set then delete them
    if (Boundary_coordinates_pt != 0)
    {
      // Loop over the boundary coordinate entries and delete them
      for (std::map<unsigned, DenseMatrix<double>*>::iterator it =
             Boundary_coordinates_pt->begin();
           it != Boundary_coordinates_pt->end();
           ++it)
      {
        // Delete the vectors that have been allocated for the storage
        // of the boundary coordinates
        delete it->second;
      }
 
      // Now delete the Boundary coordinates map itself
      delete Boundary_coordinates_pt;
      // Set the pointer to null to be on the safe side
      Boundary_coordinates_pt = 0;
    }
 
    // Delete the map of face element's first value
    delete Index_of_first_value_assigned_by_face_element_pt;
    Index_of_first_value_assigned_by_face_element_pt = 0;
  }

References Boundaries_pt, Boundary_coordinates_pt, and Index_of_first_value_assigned_by_face_element_pt.

BoundaryNodeBase() [2/2]

oomph::BoundaryNodeBase::BoundaryNodeBase ( const BoundaryNodeBase &  boundary_node_base )

delete

Broken copy constructor.

Member Function Documentation

add_to_boundary()

void oomph::BoundaryNodeBase::add_to_boundary

(

const unsigned &

b

)

Add the node to the mesh boundary b.

  {
    // If there is not storage then create storage and set the entry
    // to be the boundary b
    if (Boundaries_pt == 0)
    {
      Boundaries_pt = new std::set<unsigned>;
    }
 
    //  //If the boundary is already stored in the node issue a warning
    //  if(find(Boundaries_pt->begin(),Boundaries_pt->end(),b) !=
    //     Boundaries_pt->end())
    //   {
    // // MH: who cares?
    // //    oomph_info << std::endl <<
    // "============================================"
    // //         << std::endl << "Warning in Node::add_to_boundary()          "
    // //         << std::endl << "Node is already marked as being on boundary "
    // << b
    // //         << std::endl << "============================================"
    // //         << std::endl << std::endl;
    //   }
    //  else
    //   {
 
    Boundaries_pt->insert(b);
 
    //   }
  }

References b, and Boundaries_pt.

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

assign_additional_values_with_face_id()

virtual void oomph::BoundaryNodeBase::assign_additional_values_with_face_id ( const unsigned &  n_additional_value, const unsigned &  face_id = 0  )

pure virtual

Member function that 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

Implemented in oomph::BoundaryNode< NODE_TYPE >.

boundary_coordinates_have_been_set_up()

bool oomph::BoundaryNodeBase::boundary_coordinates_have_been_set_up ( )

inline

Have boundary coordinates been set up?

    {
      return (Boundary_coordinates_pt != 0);
    }

References Boundary_coordinates_pt.

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

get_boundaries_pt()

void oomph::BoundaryNodeBase::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

    {
      boundaries_pt = Boundaries_pt;
    }

References Boundaries_pt.

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

get_coordinates_on_boundary() [1/2]

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

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

Given the mesh boundary b, return the k-th generalised boundary coordinates of the node in the vector boundary_zeta

  {
    // Check that the node lies on a boundary
#ifdef PARANOID
    if (Boundaries_pt == 0)
    {
      throw OomphLibError("Node does not lie on any boundary",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Does the node lie on the mesh boundary b
    if (!is_on_boundary(b))
    {
      std::ostringstream error_stream;
      error_stream << "Node is not on boundary " << b << std::endl;
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
 
#ifdef PARANOID
    // Check that the boundary coordinates have been set
    if (Boundary_coordinates_pt == 0)
    {
      std::ostringstream error_stream;
      error_stream
        << "Boundary coordinates have not been set\n"
        << "[Note: In refineable problems, the boundary coordinates\n"
        << "       will only be interpolated to newly created nodes\n"
        << "       if Mesh::Boundary_coordinate_exists[...] has been\n"
        << "       set to true!]\n";
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
 
    // Find out how may coordinates there are from the map
    const unsigned nboundary_coord = (*Boundary_coordinates_pt)[b]->nrow();
#ifdef PARANOID
    if (nboundary_coord != boundary_zeta.size())
    {
      std::ostringstream error_stream;
      error_stream << "Wrong number of coordinates in the vector boundary_zeta"
                   << std::endl
                   << "There are " << nboundary_coord << " boundary coordinates"
                   << std::endl
                   << "But bounday_zeta() has size " << boundary_zeta.size()
                   << std::endl;
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Loop over and assign the coordinates
    for (unsigned i = 0; i < nboundary_coord; i++)
    {
      boundary_zeta[i] = (*(*Boundary_coordinates_pt)[b])(i, k);
    }
  }

References b, Boundaries_pt, Boundary_coordinates_pt, i, is_on_boundary(), k, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

get_coordinates_on_boundary() [2/2]

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

inline

Return the vector of boundary coordinates on mesh boundary b.

    {
      // Just return the zero-th one
      get_coordinates_on_boundary(b, 0, boundary_zeta);
    }

References b.

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

index_of_first_value_assigned_by_face_element() [1/2]

unsigned oomph::BoundaryNodeBase::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

inline

Return the index of the first value associated with the i-th face element value. If no argument id is specified we return the index associated with the first (and assumed to be only) face element attached to this node. If no values have been set by any FaceElements and throw_if_no_value_assigned_by_face_element is set to true, this is caught 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) by throwing an OomphLibError that can be caught gracefully. If throw_quietly is set to true we throw an OomphLibQuietException instead. You can catch either by catching the underlying std::runtime_error. In PARANOID mode we check regardless of the setting of throw_if_no_value_assigned_by_face_element (but respect the request for quietness). Returns UINT_MAX if error.

    {
      // Over-rule if paranoia rules
      bool local_throw_if_no_value_assigned_by_face_element =
        throw_if_no_value_assigned_by_face_element;
#ifdef PARANOID
      local_throw_if_no_value_assigned_by_face_element = true;
#endif
 
      if (local_throw_if_no_value_assigned_by_face_element)
      {
        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(...).";
 
          if (throw_quietly)
          {
            throw OomphLibQuietException();
          }
          else
          {
            throw OomphLibError(error_message.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
          }
          return UINT_MAX;
        }
      }
      return (*Index_of_first_value_assigned_by_face_element_pt)[face_id];
    }

References Index_of_first_value_assigned_by_face_element_pt, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

index_of_first_value_assigned_by_face_element() [2/2]

unsigned oomph::BoundaryNodeBase::index_of_first_value_assigned_by_face_element ( const unsigned &  face_id = 0 ) const

inline

Return the index of the first value associated with the i-th face element value. If no argument is specified we return the index 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.

    {
#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
      return (*Index_of_first_value_assigned_by_face_element_pt)[face_id];
    }

References Index_of_first_value_assigned_by_face_element_pt, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by ContactProblem< ELEMENT >::complete_problem_setup(), oomph::SurfaceMeltElement< ELEMENT >::disable_melting(), oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::disable_melting(), oomph::NonlinearSurfaceContactElement< ELEMENT >::fill_in_contribution_to_residuals_surface_contact(), oomph::LinearSurfaceContactElement< ELEMENT >::fill_in_contribution_to_residuals_surface_contact(), oomph::HeatedLinearSurfaceContactElement< ELEMENT >::fill_in_contribution_to_residuals_surface_contact(), oomph::SurfaceMeltElement< ELEMENT >::fill_in_contribution_to_residuals_surface_melt(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_generic_contribution_to_residuals_displ_lagr_multiplier(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_generic_contribution_to_residuals_fsi_displ_lagr_multiplier(), oomph::ImposeImpenetrabilityElement< ELEMENT >::fill_in_generic_contribution_to_residuals_parall_lagr_multiplier(), oomph::ImposeParallelOutflowElement< ELEMENT >::fill_in_generic_contribution_to_residuals_parall_lagr_multiplier(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::fill_in_generic_residual_contribution_axisym_poroelastic_fsi(), oomph::LinearisedFSIAxisymmetricNStNoSlipBCElementElement< FLUID_BULK_ELEMENT, SOLID_BULK_ELEMENT >::fill_in_generic_residual_contribution_fsi_no_slip_axisym(), oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::fill_in_generic_residual_contribution_ust_heat_flux(), oomph::ImposeImpenetrabilityElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::ImposeParallelOutflowElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::SurfaceContactElementBase< ELEMENT >::get_interpolated_lagrange_p(), oomph::SurfaceMeltElement< ELEMENT >::get_interpolated_lagrange_p(), oomph::HeatedLinearSurfaceContactElement< ELEMENT >::heat_flux(), oomph::SurfaceMeltElement< ELEMENT >::interpolated_melt_rate(), oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::output(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::output(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::output(), oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::plot_residual_landscape(), PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PressureWaveFSIProblem(), oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::refineable_fill_in_generic_contribution_to_residuals_displ_lagr_multiplier(), oomph::RefineableFSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::refineable_fill_in_generic_contribution_to_residuals_fsi_displ_lagr_multiplier(), oomph::NonlinearSurfaceContactElement< ELEMENT >::resulting_contact_force(), oomph::LinearSurfaceContactElement< ELEMENT >::resulting_contact_force(), oomph::SurfaceMeltElement< ELEMENT >::set_lagrange_multiplier_pressure_to_zero(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::square_of_l2_norm_of_error(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::SurfactantProblem(), and UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::UnstructuredFSIProblem().

index_of_first_value_assigned_by_face_element_pt()

std::map<unsigned, unsigned>*& oomph::BoundaryNodeBase::index_of_first_value_assigned_by_face_element_pt ( )

inline

Return pointer to the map giving the index of the first face element value.

    {
      return Index_of_first_value_assigned_by_face_element_pt;
    }

References Index_of_first_value_assigned_by_face_element_pt.

Referenced by oomph::BoundaryNode< NODE_TYPE >::clear_additional_copied_pointers(), and oomph::BoundaryNode< NODE_TYPE >::reset_copied_pointers().

is_on_boundary() [1/2]

bool oomph::BoundaryNodeBase::is_on_boundary ( ) const

inline

Test whether the node lies on a boundary.

    {
      return !(Boundaries_pt == 0);
    }

References Boundaries_pt.

Referenced by get_coordinates_on_boundary(), oomph::BoundaryNode< NODE_TYPE >::is_on_boundary(), ncoordinates_on_boundary(), PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PressureWaveFSIProblem(), remove_from_boundary(), and set_coordinates_on_boundary().

is_on_boundary() [2/2]

bool oomph::BoundaryNodeBase::is_on_boundary

(

const unsigned &

b

)

const

Test whether the node lies on mesh boundary b.

Test whether the node lies on the mesh boundary b.

  {
    // If the node lies on any boundary
    if (Boundaries_pt != 0)
    {
      if (find(Boundaries_pt->begin(), Boundaries_pt->end(), b) !=
          Boundaries_pt->end())
      {
        return true;
      }
    }
 
    // If we haven't returned yet, then the node does not lie on the boundary
    return false;
  }

References b, and Boundaries_pt.

make_node_periodic()

void oomph::BoundaryNodeBase::make_node_periodic ( Node *const &  node_pt, Node *const &  copied_node_pt  )

protected

Helper function that is used to turn BoundaryNodes into peridic boundary nodes by setting the data values of copied_node_pt to those of original_node_pt.

Helper function that is used to turn BoundaryNodes into peridic boundary nodes by setting the data values of copy_of_node_pt to those of copied_node_pt.

  {
    // Don't allow this node to already be a copy (you should clear it's
    // copied status first).
    if (node_pt->is_a_copy())
    {
      std::ostringstream error_stream;
      error_stream << "The node you are trying to make into a periodic copy is "
                      "already a copy\n.";
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    // If the node to be copied from is a copy then copy it's "copied_node_pt"
    // instead.
    if (copied_node_pt->is_a_copy())
    {
      make_node_periodic(node_pt, copied_node_pt->copied_node_pt());
    }
 
    // Otherwise just do it
    else
    {
      // Set the copied node pointer
      Copied_node_pt = copied_node_pt;
 
      // First copy the data values
      // Delete the storage allocated in the copy
      node_pt->delete_value_storage();
      // Now set the Value and Equation number pointers to be the same
      node_pt->Value = copied_node_pt->Value;
      node_pt->Eqn_number = copied_node_pt->Eqn_number;
 
      // Inform the node that it has been copied
      copied_node_pt->add_copy(node_pt);
    }
  }

References oomph::Data::add_copy(), oomph::Node::copied_node_pt(), Copied_node_pt, oomph::Data::delete_value_storage(), oomph::Data::Eqn_number, oomph::Data::is_a_copy(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Data::Value.

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

make_nodes_periodic()

void oomph::BoundaryNodeBase::make_nodes_periodic ( Node *const &  copied_node_pt, Vector< Node * > const &  periodic_copies_pt  )

protected

Helper function that is used to turn BoundaryNodes into periodic boundary nodes by setting the data values of the nodes in the vector periodic_copies_pt to be the same as those in node_pt.

////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// Helper function that is used to turn BoundaryNodes into periodic boundary nodes by setting the data values of the nodes in the vector periodic_copies_pt to be the same as those in copied_node_pt. This function should be used when making doubly periodic sets of nodes.

  {
    // Don't allow copying if the original or periodic nodes are already
    // periodic
    bool already_a_copy = false;
    already_a_copy |= copied_node_pt->is_a_copy();
    const unsigned n_periodic = periodic_copies_pt.size();
    for (unsigned n = 0; n < n_periodic; n++)
    {
      already_a_copy |= periodic_copies_pt[n]->is_a_copy();
    }
 
    // If we have a copy bail
    if (already_a_copy)
    {
      std::ostringstream error_stream;
      error_stream
        << "The nodes you are trying to make periodic are already periodic\n"
        << "Or you are trying to make a copy of another already periodic "
           "node\n";
      error_stream << "Please copy the original data if you can\n";
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    // Now we simply delete and copy over for each node
    for (unsigned n = 0; n < n_periodic; n++)
    {
      // Local cache of the node
      Node* const nod_pt = periodic_copies_pt[n];
      // Miss out the node itself if it's in the list
      if (nod_pt != copied_node_pt)
      {
        // Delete the storage allocated in the copy
        nod_pt->delete_value_storage();
        // Now set the Value and Equation number pointers to be the same
        nod_pt->Value = copied_node_pt->Value;
        nod_pt->Eqn_number = copied_node_pt->Eqn_number;
 
        // Set the copied node pointer in the copy
        BoundaryNodeBase* cast_nod_pt = dynamic_cast<BoundaryNodeBase*>(nod_pt);
        cast_nod_pt->Copied_node_pt = copied_node_pt;
        // Inform the node that it has been copied
        copied_node_pt->add_copy(nod_pt);
      }
    }
  }

References oomph::Data::add_copy(), Copied_node_pt, oomph::Data::delete_value_storage(), oomph::Data::Eqn_number, oomph::Data::is_a_copy(), n, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Data::Value.

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

ncoordinates_on_boundary()

unsigned oomph::BoundaryNodeBase::ncoordinates_on_boundary

(

const unsigned &

b

)

Get the number of boundary coordinates on mesh boundary b.

  {
    // Check that the node lies on a boundary
#ifdef PARANOID
    if (Boundaries_pt == 0)
    {
      throw OomphLibError("Node does not lie on any boundary",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
 
    // Does the node lie on the mesh boundary b
    if (!is_on_boundary(b))
    {
      std::ostringstream error_stream;
      error_stream << "Node is not on boundary " << b << std::endl;
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    // Check that the boundary coordinates have been set
    if (Boundary_coordinates_pt == 0)
    {
      std::ostringstream error_stream;
      error_stream
        << "Boundary coordinates have not been set\n"
        << "[Note: In refineable problems, the boundary coordinates\n"
        << "       will only be interpolated to newly created nodes\n"
        << "       if Mesh::Boundary_coordinate_exists[...] has been\n"
        << "       set to true!]\n";
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Find out how may coordinates there are from the map
    return (*Boundary_coordinates_pt)[b]->nrow();
  }

References b, Boundaries_pt, Boundary_coordinates_pt, is_on_boundary(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

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

nvalue_assigned_by_face_element()

virtual unsigned oomph::BoundaryNodeBase::nvalue_assigned_by_face_element ( const unsigned &  face_id = 0 ) const

pure virtual

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.

Implemented in oomph::BoundaryNode< NODE_TYPE >.

operator=()

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

delete

Broken assignment operator.

remove_from_boundary()

void oomph::BoundaryNodeBase::remove_from_boundary

(

const unsigned &

b

)

Remove the node from the mesh boundary b.

  {
#ifdef PARANOID
    if (is_on_boundary(b) == false)
    {
      std::ostringstream error_stream;
      error_stream << "Node is not on boundary " << b << std::endl;
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Remove the boundary from the set
    Boundaries_pt->erase(b);
 
    // Need to delete the equivalent entry in the Boundary coordinate
    // map, if the storage has actually been allocated
    if (Boundary_coordinates_pt != 0)
    {
      // Delete the vector storage that has been allocated
      delete (*Boundary_coordinates_pt)[b];
      // Delete the entry in the map
      Boundary_coordinates_pt->erase(b);
    }
 
    // If all entries have been removed, delete the storage
    if (Boundaries_pt->size() == 0)
    {
      delete Boundaries_pt;
      Boundaries_pt = 0;
    }
  }

References b, Boundaries_pt, Boundary_coordinates_pt, is_on_boundary(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

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

set_coordinates_on_boundary() [1/2]

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

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

Given the mesh boundary b, set the k-th generalised boundary coordinates of the node from the vector boundary_zeta

  {
    // Check that the node lies on a boundary
#ifdef PARANOID
    if (Boundaries_pt == 0)
    {
      throw OomphLibError("Node does not lie on any boundary",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Does the node lie on the mesh boundary b
    if (!is_on_boundary(b))
    {
      std::ostringstream error_stream;
      error_stream << "Node is not on boundary " << b << std::endl;
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    // If the storage has not been assigned, then assign it
    if (Boundary_coordinates_pt == 0)
    {
      Boundary_coordinates_pt = new std::map<unsigned, DenseMatrix<double>*>;
    }
 
 
    // Find the number of boundary coordinates
    const unsigned nboundary_coord = boundary_zeta.size();
 
    // Allocate the vector for the boundary coordinates, if we haven't already
    if ((*Boundary_coordinates_pt)[b] == 0)
    {
      // Need k+1 columns initially
      (*Boundary_coordinates_pt)[b] =
        new DenseMatrix<double>(nboundary_coord, k + 1);
    }
    // Otherwise resize it, in case the number of boundary coordinates
    // or the number of types has changed
    else
    {
      // Adjust number of boundary coordinates -- retain number of types
      unsigned ncol = (*Boundary_coordinates_pt)[b]->ncol();
      {
        (*Boundary_coordinates_pt)[b]->resize(nboundary_coord, ncol);
      }
 
      // Resize number of types if required
      if ((k + 1) > (*Boundary_coordinates_pt)[b]->ncol())
      {
        (*Boundary_coordinates_pt)[b]->resize(nboundary_coord, k + 1);
      }
    }
 
    // Loop over and assign the coordinates
    for (unsigned i = 0; i < nboundary_coord; i++)
    {
      (*(*Boundary_coordinates_pt)[b])(i, k) = boundary_zeta[i];
    }
  }

References b, Boundaries_pt, Boundary_coordinates_pt, i, is_on_boundary(), k, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

set_coordinates_on_boundary() [2/2]

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

inline

Set the vector of boundary coordinates on mesh boundary b.

    {
      // Just do the zero-th one
      set_coordinates_on_boundary(b, 0, boundary_zeta);
    }

References b.

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

Member Data Documentation

Boundaries_pt

std::set<unsigned>* oomph::BoundaryNodeBase::Boundaries_pt

private

Pointer to set of mesh boundaries occupied by the Node; NULL if the Node is not on any boundaries

Referenced by add_to_boundary(), get_boundaries_pt(), get_coordinates_on_boundary(), is_on_boundary(), ncoordinates_on_boundary(), remove_from_boundary(), set_coordinates_on_boundary(), and ~BoundaryNodeBase().

Boundary_coordinates_pt

std::map<unsigned, DenseMatrix<double>*>* oomph::BoundaryNodeBase::Boundary_coordinates_pt

private

Pointer to a map of pointers to intrinsic boundary coordinates of the Node, indexed by the boundary number. If the Node does not lie on a boundary this map should never be queried because unnecessary storage will then be allocated. Hence, it can only be accessed via the appropriate set and get functions.

Referenced by boundary_coordinates_have_been_set_up(), get_coordinates_on_boundary(), ncoordinates_on_boundary(), remove_from_boundary(), set_coordinates_on_boundary(), and ~BoundaryNodeBase().

Copied_node_pt

Node* oomph::BoundaryNodeBase::Copied_node_pt

protected

If the BoundaryNode is periodic, this pointer is set to the BoundaryNode whose data it shares

Referenced by oomph::BoundaryNode< NODE_TYPE >::assign_eqn_numbers(), oomph::BoundaryNode< NODE_TYPE >::clear_additional_copied_pointers(), oomph::BoundaryNode< NODE_TYPE >::clear_copied_pointers(), oomph::BoundaryNode< NODE_TYPE >::copied_node_pt(), oomph::BoundaryNode< NODE_TYPE >::is_a_copy(), make_node_periodic(), make_nodes_periodic(), oomph::BoundaryNode< NODE_TYPE >::reset_copied_pointers(), oomph::BoundaryNode< NODE_TYPE >::resize(), and oomph::BoundaryNode< NODE_TYPE >::~BoundaryNode().

Index_of_first_value_assigned_by_face_element_pt

std::map<unsigned, unsigned>* oomph::BoundaryNodeBase::Index_of_first_value_assigned_by_face_element_pt

protected

Pointer to a map, indexed by the face element identifier it returns the position of the first face element value. If the Node does not lie on a face element this map should never be queried.

Referenced by oomph::BoundaryNode< NODE_TYPE >::assign_additional_values_with_face_id(), index_of_first_value_assigned_by_face_element(), index_of_first_value_assigned_by_face_element_pt(), oomph::BoundaryNode< NODE_TYPE >::nvalue_assigned_by_face_element(), oomph::BoundaryNode< NODE_TYPE >::~BoundaryNode(), and ~BoundaryNodeBase().

---

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

• nodes.h
• nodes.cc