oomph::Hijacked< ELEMENT > Class Template Reference

#include <hijacked_elements.h>

Inheritance diagram for oomph::Hijacked< ELEMENT >:

Public Member Functions
	Hijacked ()
	Constructor, call the constructors of the base elements. More...
	Hijacked (FiniteElement *const &element_pt, const int &face_index)
	Constructor used for hijacking face elements. More...
	Hijacked (FiniteElement *const &element_pt, const int &face_index, const unsigned &id=0)
Data *	hijack_internal_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
Data *	hijack_external_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
Data *	hijack_nodal_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
Data *	hijack_nodal_position_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
Data *	hijack_nodal_spine_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
void	assign_local_eqn_numbers (const bool &store_local_dof_pt)
void	get_residuals (Vector< double > &residuals)
void	get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
Public Member Functions inherited from oomph::HijackedElementBase
	HijackedElementBase ()
virtual	~HijackedElementBase ()
	Destructor, destroy the storage for the equation numbers. More...
void	unhijack_all_data ()
const double &	residual_multiplier () const
	Return the value of the residual multiplier. More...
double *&	residual_multiplier_pt ()
	Return the pointer to the residual multiplier. More...

Additional Inherited Members
Protected Member Functions inherited from oomph::HijackedElementBase
void	hijack_global_eqn (long *const &global_eqn_pt)
void	unhijack_global_eqn (long *const &global_eqn_pt)
Protected Attributes inherited from oomph::HijackedElementBase
std::set< long * > *	Hijacked_global_eqn_number_pt
Vector< int > *	Hijacked_local_eqn_number_pt
double *	Residual_multiplier_pt
Static Protected Attributes inherited from oomph::HijackedElementBase
static double	Default_residual_multiplier = 0.0

Detailed Description

template<class ELEMENT>
class oomph::Hijacked< ELEMENT >

Hijacked elements are elements in which one or more Data values that affect the element's residuals, are determined by another element – the data values are then said to have been hijacked by another element. The main functionality added by the Hijacked element class is that it wipes out those entries in the element's residual vector and those rows in the element's Jacobian matrix that are determined by the "other" elements that have hijacked the values. Note that for continuation in homotopy parameters, it may be desriable to multiply the residuals and corresponding jacobian entries by a "homotopy parameter". The value of this parameter can be set by assigning residual_multiplier_pt() which has a default value of zero. Note: it would be possible to extend the functionality so that different residuals are multiplied by different values, but will this ever be required?

Constructor & Destructor Documentation

Hijacked() [1/3]

template<class ELEMENT >

oomph::Hijacked< ELEMENT >::Hijacked ( )

inline

Constructor, call the constructors of the base elements.

: ELEMENT(), HijackedElementBase() {}

Hijacked() [2/3]

template<class ELEMENT >

oomph::Hijacked< ELEMENT >::Hijacked ( FiniteElement *const &  element_pt, const int &  face_index  )

inline

Constructor used for hijacking face elements.

      : ELEMENT(element_pt, face_index), HijackedElementBase()
    {
    }

Hijacked() [3/3]

template<class ELEMENT >

oomph::Hijacked< ELEMENT >::Hijacked ( FiniteElement *const &  element_pt, const int &  face_index, const unsigned &  id = 0  )

inline

Constructor used for hijacking face elements with specification of ID of additional variables

      : ELEMENT(element_pt, face_index, id), HijackedElementBase()
    {
    }

Member Function Documentation

assign_local_eqn_numbers()

template<class ELEMENT >

void oomph::Hijacked< ELEMENT >::assign_local_eqn_numbers ( const bool &  store_local_dof_pt )

inline

Set up the local equation numbers for the underlying element, then set up the local arrays to hold the hijacked variables. If the boolean argument is true then pointers to the associated degrees of freedom are stored in the array Dof_pt

    {
      // If things have already been allocated,
      // clear the local hijacked array, so that if the equation numbers
      // are reassigned after changes in the boundary conditions, the
      // correct terms will be in the array.
      if (Hijacked_local_eqn_number_pt != 0)
      {
        Hijacked_local_eqn_number_pt->clear();
      }
      // Otherwise allocate it
      else
      {
        Hijacked_local_eqn_number_pt = new Vector<int>;
      }
 
 
      // Call the hijacked element's assign_local_eqn_numbers
      ELEMENT::assign_local_eqn_numbers(store_local_dof_pt);
 
      // If any values have been hijacked, we need to find the corresponding
      // local equation numbers
      if (Hijacked_global_eqn_number_pt != 0)
      {
        // Now loop over the local array that stores GLOBAL equation numbers
        // to check if any of the local values have in fact been hijacked
        // by "somebody"
        unsigned n_dof = this->ndof();
        for (unsigned i = 0; i < n_dof; i++)
        {
          // Loop over *all* hijacked data
          for (std::set<long*>::iterator it =
                 Hijacked_global_eqn_number_pt->begin();
               it != Hijacked_global_eqn_number_pt->end();
               ++it)
          {
            // If the hijacked (global!) equation is not pinned
            if (*(*it) >= 0)
            {
              // Get the (unsigned) global equation number:
              // Note that it is only unsigned AFTER the test above.
              unsigned long hijacked_eqn_number = *(*it);
 
              // If a GLOBAL variable used by this element is hijacked add the
              // variable's LOCAL index to the array
              if (hijacked_eqn_number == this->eqn_number(i))
              {
                Hijacked_local_eqn_number_pt->push_back(i);
                break;
              }
            }
          }
        }
      }
    }

References oomph::HijackedElementBase::Hijacked_global_eqn_number_pt, oomph::HijackedElementBase::Hijacked_local_eqn_number_pt, and i.

get_jacobian()

template<class ELEMENT >

void oomph::Hijacked< ELEMENT >::get_jacobian ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian  )

inline

Get the residuals and Jacobian matrix from the underlying element, but then wipe the entries in the residual vector and the rows in the Jacobian matrix that correspond to hijacked values – they will be computed by other elements.

    {
      // Call the element's get jacobian function
      ELEMENT::get_jacobian(residuals, jacobian);
      // Wipe any hijacked dofs
      unsigned n_hijacked = Hijacked_local_eqn_number_pt->size();
      unsigned n_dof = this->ndof();
      for (unsigned i = 0; i < n_hijacked; i++)
      {
        // Multiply any hijacked dofs by the residual multiplier
        //(default value is zero)
        residuals[(*Hijacked_local_eqn_number_pt)[i]] *= residual_multiplier();
        // Multiply the row in the Jacobian matrix by the residual
        // multiplier for consistency
        for (unsigned j = 0; j < n_dof; j++)
        {
          jacobian((*Hijacked_local_eqn_number_pt)[i], j) *=
            residual_multiplier();
        }
      }
    }

References oomph::HijackedElementBase::Hijacked_local_eqn_number_pt, i, j, and oomph::HijackedElementBase::residual_multiplier().

get_residuals()

template<class ELEMENT >

void oomph::Hijacked< ELEMENT >::get_residuals ( Vector< double > &  residuals )

inline

Get the residuals from the underlying element, but then wipe the entries in the residual vector that correspond to hijacked values – they will be computed by other elements.

    {
      // Get parent redisuals
      ELEMENT::get_residuals(residuals);
      // Multiply any hijacked dofs by the residual multiplier
      //(default value is zero)
      unsigned n_hijacked = Hijacked_local_eqn_number_pt->size();
      for (unsigned i = 0; i < n_hijacked; i++)
      {
        residuals[(*Hijacked_local_eqn_number_pt)[i]] *= residual_multiplier();
      }
    }

References GlobalFct::get_residuals(), oomph::HijackedElementBase::Hijacked_local_eqn_number_pt, i, and oomph::HijackedElementBase::residual_multiplier().

hijack_external_value()

template<class ELEMENT >

Data* oomph::Hijacked< ELEMENT >::hijack_external_value ( const unsigned &  n, const unsigned &  i, const bool &  return_data = true  )

inline

Hijack the i-th value stored at external data n. Optionally return a custom-made (copied) data object that contains only the hijacked value. Note that the calling program assumes responsibility for this data object and must clean it up. The default is that the data object is returned

    {
      // Initialise pointer to zero
      Data* temp_data_pt = 0;
      // If desired
      // create a new Data object containing only the value that is to be
      // hijacked
      if (return_data)
      {
        temp_data_pt = new HijackedData(i, this->external_data_pt(n));
      }
 
      // Mark the value as hijacked
      hijack_global_eqn(this->external_data_pt(n)->eqn_number_pt(i));
 
      // Return the pointer to the data
      return temp_data_pt;
    }

References oomph::HijackedElementBase::hijack_global_eqn(), i, and n.

hijack_internal_value()

template<class ELEMENT >

Data* oomph::Hijacked< ELEMENT >::hijack_internal_value ( const unsigned &  n, const unsigned &  i, const bool &  return_data = true  )

inline

Hijack the i-th value stored at internal data n. Optionally return a custom-made (copied) data object that contains only the hijacked value. This can be used as the input to other elements. Note that the calling program assumes responsibility for this data object and must clean it up. The default is that the data object is returned

    {
      // Initialise pointer to zero
      Data* temp_data_pt = 0;
 
      // If desired,
      // Create a new Data object containing only the value that is to be
      // hijacked
      if (return_data)
      {
        temp_data_pt = new HijackedData(i, this->internal_data_pt(n));
      }
 
      // Mark the value as hijacked
      hijack_global_eqn(this->internal_data_pt(n)->eqn_number_pt(i));
 
      // Return the pointer to the data
      return temp_data_pt;
    }

References oomph::HijackedElementBase::hijack_global_eqn(), i, and n.

hijack_nodal_position_value()

template<class ELEMENT >

Data* oomph::Hijacked< ELEMENT >::hijack_nodal_position_value ( const unsigned &  n, const unsigned &  i, const bool &  return_data = true  )

inline

Hijack the i-th positional value stored at node n. Optionaly return a custom-made (copied) data object that contains only the hijacked value. Again, responsibility for the memory allocated lies with the calling function. The default is that the data object is returned

    {
      // Can we do the casting?
      SolidNode* solid_node_pt = dynamic_cast<SolidNode*>(this->node_pt(n));
      if (solid_node_pt == 0)
      {
        std::string error_message = "Failed to cast to SolidNode\n ";
        error_message += "You may be trying to hijack a non-elastic element\n";
 
        throw OomphLibError(
          error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
 
      // Initialise pointer to zero
      Data* temp_data_pt = 0;
      // If desired
      // create a new Data object containing only the value that is to be
      // hijacked
      if (return_data)
      {
        temp_data_pt =
          new HijackedData(i, solid_node_pt->variable_position_pt());
      }
 
      // Mark the value as hijacked
      hijack_global_eqn(
        solid_node_pt->variable_position_pt()->eqn_number_pt(i));
 
      // Return the pointer to the data
      return temp_data_pt;
    }

References oomph::Data::eqn_number_pt(), oomph::HijackedElementBase::hijack_global_eqn(), i, n, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Global_string_for_annotation::string(), and oomph::SolidNode::variable_position_pt().

hijack_nodal_spine_value()

template<class ELEMENT >

Data* oomph::Hijacked< ELEMENT >::hijack_nodal_spine_value ( const unsigned &  n, const unsigned &  i, const bool &  return_data = true  )

inline

Hijack the i-th value stored at the spine that affects local node n. Optionally return a custom-made (copied) data object that contains only the hijacked value. Deletion must be handled at the higher level The default is that the data object is returned

    {
      // Can we actually do this casting
      SpineNode* spine_node_pt = dynamic_cast<SpineNode*>(this->node_pt(n));
      if (spine_node_pt == 0)
      {
        std::string error_message = "Failed to cast to SpineNode\n ";
        error_message += "You may be trying to hijack a non-spine element\n";
 
        throw OomphLibError(
          error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
 
      // Initialise pointer to zero
      Data* temp_data_pt = 0;
      // If desired
      // create a new Data object containing only the value that is to be
      // hijacked
      if (return_data)
      {
        temp_data_pt =
          new HijackedData(i, spine_node_pt->spine_pt()->spine_height_pt());
      }
 
      // Mark the data as hijacked
      hijack_global_eqn(
        spine_node_pt->spine_pt()->spine_height_pt()->eqn_number_pt(i));
 
      // Return the pointer to the data
      return temp_data_pt;
    }

References oomph::Data::eqn_number_pt(), oomph::HijackedElementBase::hijack_global_eqn(), i, n, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Spine::spine_height_pt(), oomph::SpineNode::spine_pt(), and oomph::Global_string_for_annotation::string().

hijack_nodal_value()

template<class ELEMENT >

Data* oomph::Hijacked< ELEMENT >::hijack_nodal_value ( const unsigned &  n, const unsigned &  i, const bool &  return_data = true  )

inline

Hijack the i-th value stored at node n. Optionally return a custom-made (copied) data object that contains only the hijacked value. Once again, the calling program must clean up the allocated Data object. The default is that the data object is returned

    {
      // Initialise pointer to zero
      Data* temp_data_pt = 0;
      // If desired
      // create a new Data object containing only the value that is to be
      // hijacked
      if (return_data)
      {
        temp_data_pt = new HijackedData(i, this->node_pt(n));
      }
 
      // Mark the value as hijacked
      hijack_global_eqn(this->node_pt(n)->eqn_number_pt(i));
 
      // Return the pointer to the data, which may be null
      return temp_data_pt;
    }

References oomph::HijackedElementBase::hijack_global_eqn(), i, and n.

Referenced by AirwayReopeningProblem< ELEMENT >::AirwayReopeningProblem(), oomph::BiharmonicFluidProblem< DIM >::impose_traction_free_edge(), and ThreeDimBethertonProblem< ELEMENT >::ThreeDimBethertonProblem().

---

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

• hijacked_elements.h