oomph::AlgebraicElementBase Class Reference

#include <algebraic_elements.h>

Inheritance diagram for oomph::AlgebraicElementBase:

Public Member Functions
	AlgebraicElementBase ()
	Empty constructor. More...
	AlgebraicElementBase (const AlgebraicElementBase &)=delete
	Broken copy constructor. More...
void	operator= (const AlgebraicElementBase &)=delete
	Broken assignment operator. More...
void	setup_algebraic_node_update (Node *&node_pt, const Vector< double > &s_father, FiniteElement *father_el_pt) const

Detailed Description

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Base class for algebraic elements.

Constructor & Destructor Documentation

AlgebraicElementBase() [1/2]

oomph::AlgebraicElementBase::AlgebraicElementBase ( )

inline

Empty constructor.

{}

AlgebraicElementBase() [2/2]

oomph::AlgebraicElementBase::AlgebraicElementBase ( const AlgebraicElementBase &  )

delete

Broken copy constructor.

Member Function Documentation

operator=()

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

delete

Broken assignment operator.

setup_algebraic_node_update()

void oomph::AlgebraicElementBase::setup_algebraic_node_update	(	Node *&	node_pt,
		const Vector< double > &	s_father,
		FiniteElement *	father_el_pt
	)		const

Set up node update info for (newly created) algebraic node: I.e. work out its node update information by interpolation from the father element. Pass pointer to father element and the newly created node's local coordinate in the father element.

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Set up node update info for (newly created) algebraic node: Work out its node update information by interpolation from its father element, based on pointer to father element and its local coordinate in the father element. We're creating the node update info for update functions that are shared by all nodes in the father element.

Now loop over the ids and check if they appear in all nodes

  {
    // Turn node into algebraic node
    AlgebraicNode* alg_node_pt = dynamic_cast<AlgebraicNode*>(node_pt);
 
    // Get number of nodes in father element
    unsigned nnod_father = father_el_pt->nnode();
 
    // Create map that stores the number of times a node update fct id
    // has been encountered
    std::map<int, unsigned> id_count;
 
    // Loop over all nodes in father element to extract node update ids
    Vector<int> id;
    for (unsigned j = 0; j < nnod_father; j++)
    {
      // Get vector of ids and add them to map
      dynamic_cast<AlgebraicNode*>(father_el_pt->node_pt(j))
        ->node_update_fct_id(id);
      unsigned n_id = id.size();
      for (unsigned i = 0; i < n_id; i++)
      {
        id_count[id[i]]++;
      }
    }
 
    Vector<int> shared_ids;
    typedef std::map<int, unsigned>::iterator IT;
    for (IT it = id_count.begin(); it != id_count.end(); it++)
    {
      if (it->second == nnod_father)
      {
        shared_ids.push_back(it->first);
      }
    }
 
 
    // How many update functions we have?
    unsigned n_update_id = shared_ids.size();
 
    // Loop over all node udate functions -- since it's shared by
    // nodes we may as well read the required data  from the first
    // node in the father.
    AlgebraicNode* father_node_pt =
      dynamic_cast<AlgebraicNode*>(father_el_pt->node_pt(0));
    for (unsigned i = 0; i < n_update_id; i++)
    {
      // Actual id:
      int id = shared_ids[i];
 
      // Is this a real update fct or the default dummy one?
      if (id >= 0)
      {
        // Get vector of geometric objects involved in specified node update
        // function (create vector by copy operation)
        Vector<GeomObject*> geom_obj_pt(
          father_node_pt->vector_geom_object_pt(id));
 
        // Loop over reference values and obtain the
        // ones for the current (son) element by interpolation from
        // the father
 
        // Number of reference values for this udpate function
        unsigned nvalue = father_node_pt->nref_value(id);
        Vector<double> ref_value(nvalue);
 
        // Set up the shape functions in father element
        Shape psi(nnod_father);
 
        // Get shape functions in father element
        father_el_pt->shape(s_father, psi);
 
        // Initialise reference values
        for (unsigned ivalue = 0; ivalue < nvalue; ivalue++)
        {
          ref_value[ivalue] = 0.0;
        }
 
        // Loop over all nodes in father element for
        // interpolation of nodes -- don't need to
        // worry about hanging nodes here as reference values
        // are only assigned once and then in a consistent way
        for (unsigned j_father = 0; j_father < nnod_father; j_father++)
        {
          // Get reference values at node in father by copy operation
          Vector<double> father_ref_value(
            dynamic_cast<AlgebraicNode*>(father_el_pt->node_pt(j_father))
              ->vector_ref_value(id));
 
          // Loop over reference values
          for (unsigned ivalue = 0; ivalue < nvalue; ivalue++)
          {
            ref_value[ivalue] += father_ref_value[ivalue] * psi(j_father);
          }
        }
 
        // Get mesh that implements the update operation
        AlgebraicMesh* mesh_pt = father_node_pt->mesh_pt(id);
 
 
        // Setup node update info for node
        alg_node_pt->add_node_update_info(id, // id
                                          mesh_pt, // mesh
                                          geom_obj_pt, // vector of geom objects
                                          ref_value); // vector of ref. values
 
        // Update the geometric references (e.g. in FSI) if required
        mesh_pt->update_node_update(alg_node_pt);
 
      } // endif for real vs. default dummy node update fct
 
    } // end of loop over different update fcts
 
    // Update the node at its current and previous positions
    bool update_all_time_levels_for_new_node = true;
    alg_node_pt->node_update(update_all_time_levels_for_new_node);
  }

References oomph::AlgebraicNode::add_node_update_info(), i, j, oomph::AlgebraicNode::mesh_pt(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), oomph::AlgebraicNode::node_update(), oomph::AlgebraicNode::nref_value(), oomph::FiniteElement::shape(), oomph::AlgebraicMesh::update_node_update(), oomph::AlgebraicNode::vector_geom_object_pt(), and oomph::AlgebraicNode::vector_ref_value().

Referenced by oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 1 >::build(), oomph::RefineableQElement< 2 >::build(), oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), and oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine().

---

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

• algebraic_elements.h
• algebraic_elements.cc