Generic data and function interfaces associated with refinement are defined in this class.
In addition, there are a number of interfaces that specify element-specific tasks. These should be overloaded in RefineableElements of particular geometric types and perform the following tasks:
In mixed element different sets of nodes are used to interpolate different unknowns. Interfaces are provided for functions that can be used to find the position of the nodes that interpolate the different unknowns. These functions are used to setup hanging node information automatically in particular elements, e.g. Taylor Hood Navier--Stokes. The default implementation assumes that the elements are isoparameteric.
|
Public Member Functions |
| | RefineableElement () |
| | Constructor, calls the FiniteElement constructor and initialises the member data.
|
| virtual | ~RefineableElement () |
| | RefineableElement (const RefineableElement &) |
| | Broken copy constructor.
|
| void | operator= (const RefineableElement &) |
| | Broken assignment operator.
|
| Tree * | tree_pt () |
| | Access function: Pointer to quadtree representation of this element.
|
| void | set_tree_pt (Tree *my_tree_pt) |
| | Set pointer to quadtree representation of this element.
|
| virtual unsigned | required_nsons () const |
| | Set the number of sons that can be constructed by the element The default is none.
|
| template<class ELEMENT> |
| void | split (Vector< ELEMENT * > &son_pt) const |
| | Split the element into the number of sons to be constructed and return a vector of pointers to the sons. Elements are allocated, but they are not given any properties. The refinement level of the sons is one higher than that of the father elemern.
|
| virtual void | build (Mesh *&mesh_pt, Vector< Node * > &new_node_pt, bool &was_already_built, std::ofstream &new_nodes_file)=0 |
| | Interface to function that builds the element: i.e. construct the nodes, assign their positions,.
|
| void | set_refinement_level (const int &refine_level) |
| | Set the refinement level.
|
| unsigned | refinement_level () const |
| | Return the Refinement level.
|
| void | select_for_refinement () |
| | Select the element for refinement.
|
| void | deselect_for_refinement () |
| | Deselect the element for refinement.
|
| void | select_sons_for_unrefinement () |
| | Unrefinement will be performed by merging the four sons of this element.
|
| void | deselect_sons_for_unrefinement () |
| | No unrefinement will be performed by merging the four sons of this element.
|
| bool | to_be_refined () |
| | Has the element been selected for refinement?
|
| bool | sons_to_be_unrefined () |
| | Has the element been selected for unrefinement?
|
| virtual void | rebuild_from_sons (Mesh *&mesh_pt)=0 |
| | Rebuild the element, e.g. set internal values in line with those of the sons that have now merged.
|
| virtual void | unbuild () |
| | Unbuild the element, i.e. mark the nodes that were created during its creation for possible deletion.
|
| virtual void | deactivate_element () |
| | Final operations that must be performed when the element is no longer active in the mesh, but still resident in the QuadTree.
|
| virtual bool | nodes_built () |
| | Return true if all the nodes have been built, false if not.
|
| long | number () const |
| | Element number (for debugging/plotting).
|
| void | set_number (const long &mynumber) |
| | Set element number (for debugging/plotting).
|
| virtual unsigned | ncont_interpolated_values () const =0 |
| | Number of continuously interpolated values. Note: We assume that they are located at the beginning of the value_pt Vector! (Used for interpolation to son elements, for integrity check and post-processing -- we can only expect the continously interpolated values to be continous across element boundaries).
|
| virtual void | get_interpolated_values (const Vector< double > &s, Vector< double > &values)=0 |
| | Get all continously interpolated function values in this element as a Vector. Note: Vector sets is own size to ensure that that this function can be used in black-box fashion.
|
| virtual void | get_interpolated_values (const unsigned &t, const Vector< double > &s, Vector< double > &values)=0 |
| | Get all continously interpolated function values at previous timestep in this element as a Vector. (t=0: present; t>0: prev. timestep) Note: Vector sets is own size to ensure that that this function can be used in black-box fashion.
|
| virtual Node * | interpolating_node_pt (const unsigned &n, const int &value_id) |
| | In mixed elements, different sets of nodes are used to interpolate different unknowns. This function returns the n-th node that interpolates the value_id-th unknown. Default implementation is that all variables use the positional nodes, i.e. isoparametric elements. Note that any overloaded versions of this function MUST provide a set of nodes for the position, which always has the value_id -1.
|
| virtual double | local_one_d_fraction_of_interpolating_node (const unsigned &n1d, const unsigned &i, const int &value_id) |
| | Return the local one dimensional fraction of the n1d-th node in the direction of the local coordinate s[i] that is used to interpolate the value_id-th continuously interpolated unknown. Default assumes isoparametric interpolation for all unknowns.
|
| virtual Node * | get_interpolating_node_at_local_coordinate (const Vector< double > &s, const int &value_id) |
| | Return a pointer to the node that interpolates the value-id-th unknown at local coordinate s. If there is not a node at that position, then return 0.
|
| virtual unsigned | ninterpolating_node (const int &value_id) |
| | Return the number of nodes that are used to interpolate the value_id-th unknown. Default is to assume isoparametric elements.
|
| virtual unsigned | ninterpolating_node_1d (const int &value_id) |
| | Return the number of nodes in a one_d direction that are used to interpolate the value_id-th unknown. Default is to assume an isoparametric mapping.
|
| virtual void | interpolating_basis (const Vector< double > &s, Shape &psi, const int &value_id) const |
| | Return the basis functions that are used to interpolate the value_id-th unknown. By default assume isoparameteric interpolation.
|
| virtual void | check_integrity (double &max_error)=0 |
| | Check the integrity of the element: Continuity of positions values, etc. Essentially, check that the approximation of the functions is consistent when viewed from both sides of the element boundaries Must be overloaded for each different geometric element.
|
| void | identify_field_data_for_interactions (std::set< std::pair< Data *, unsigned > > &paired_field_data) |
| | The purpose of this function is to identify all possible.
|
| void | assign_nodal_local_eqn_numbers () |
| | Overload the function that assigns local equation numbers for the Data stored at the nodes so that hanging data is taken into account.
|
| virtual RefineableElement * | root_element_pt () |
| | Setup the local equation numbering schemes: Pointer to the root element in refinement hierarchy (must be implemented in specific elements that do refinement via tree-like refinement structure. Here we provide a default implementation that is appropriate for cases where tree-like refinement doesn't exist or if the element doesn't have root in that tree (i.e. if it's a root itself): We return "this".
|
| virtual RefineableElement * | father_element_pt () const |
| | Return a pointer to the father element.
|
| void | get_father_at_refinement_level (unsigned &refinement_level, RefineableElement *&father_at_reflevel_pt) |
| | Return a pointer to the "father" element at the specified refinement level.
|
| virtual void | further_build () |
| | Further build: e.g. deal with interpolation of internal values.
|
| virtual void | setup_hanging_nodes (Vector< std::ofstream * > &output_stream) |
| | Mark up any hanging nodes that arise as a result of non-uniform refinement. Any hanging nodes will be documented in files addressed by the streams in the vector output_stream, if the streams are open.
|
| virtual void | further_setup_hanging_nodes () |
| | Perform additional hanging node procedures for variables that are not interpolated by all nodes (e.g. lower order interpolations for the pressure in Taylor Hood).
|
| void | get_dresidual_dnodal_coordinates (RankThreeTensor< double > &dresidual_dnodal_coordinates) |
| | Compute derivatives of elemental residual vector with respect to nodal coordinates. Default implementation by FD can be overwritten for specific elements. dresidual_dnodal_coordinates(l,i,j) = d res(l) / dX_{ij} This version is overloaded from the version in FiniteElement and takes hanging nodes into account -- j in the above loop loops over all the nodes that actively control the shape of the element (i.e. they are non-hanging or master nodes of hanging nodes in this element).
|
| unsigned | nshape_controlling_nodes () |
| | Number of shape-controlling nodes = the number of non-hanging nodes plus the number of master nodes associated with hanging nodes.
|
| std::map< Node *, unsigned > | shape_controlling_node_lookup () |
| | Return lookup scheme for unique number associated with any of the nodes that actively control the shape of the element (i.e. they are either non-hanging nodes of this element or master nodes of hanging nodes.
|
Static Public Member Functions |
| static double | max_integrity_tolerance () |
| | Max. allowed discrepancy in element integrity check.
|
Protected Member Functions |
| void | assemble_local_to_eulerian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const |
| | Assemble the jacobian matrix for the mapping from local.
|
| void | assemble_local_to_eulerian_jacobian2 (const DShape &d2psids, DenseMatrix< double > &jacobian2) const |
| | Assemble the the "jacobian" matrix of second derivatives of the mapping from local to Eulerian coordinates, given the second derivatives of the shape functions w.r.t. local coordinates. Overload the standard version to use the hanging information for the Eulerian coordinates.
|
| void | assemble_eulerian_base_vectors (const DShape &dpsids, DenseMatrix< double > &interpolated_G) const |
| | Assemble the covariant Eulerian base vectors, assuming that the derivatives of the shape functions with respect to the local coordinates have already been constructed. Overload the standard version to account for hanging nodes.
|
| double | local_to_eulerian_mapping_diagonal (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const |
| | Calculate the mapping from local to Eulerian coordinates given the derivatives of the shape functions w.r.t the local coordinates. assuming that the coordinates are aligned in the direction of the local coordinates, i.e. there are no cross terms and the jacobian is diagonal. This funciton returns the determinant of the jacobian, the jacobian and the inverse jacobian. Overload the standard version to take hanging info into account.
|
| int | local_hang_eqn (Node *const &node_pt, const unsigned &i) |
| | Access function that returns the local equation number for the hanging node variables (values stored at master nodes). The local equation number corresponds to the i-th unknown stored at the node addressed by node_pt.
|
| void | assign_hanging_local_eqn_numbers () |
| | Assign the local hang eqn.
|
| virtual void | fill_in_jacobian_from_nodal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian) |
| | Calculate the contributions to the jacobian from the nodal degrees of freedom using finite differences. This version is overloaded to take hanging node information into account.
|
Static Protected Member Functions |
| static void | check_value_id (const int &n_continuously_interpolated_values, const int &value_id) |
| | Static helper function that is used to check that the value_id is in range.
|
Protected Attributes |
| Tree * | Tree_pt |
| | A pointer to a general tree object.
|
| unsigned | Refine_level |
| | Refinement level.
|
| bool | To_be_refined |
| | Flag for refinement.
|
| bool | Sons_to_be_unrefined |
| | Flag for unrefinement.
|
| long | Number |
| | Global element number -- for plotting/validation purposes.
|
Static Protected Attributes |
| static double | Max_integrity_tolerance = 1.0e-8 |
| | Max. allowed discrepancy in element integrity check.
|
Private Attributes |
| std::map< Node *, int > * | Local_hang_eqn |
| | Storage for local equation numbers of hanging node variables (values stored at master nodes). It is essential that these are indexed by a Node pointer because the Node may be internal or external to the element. local equation number = Local_hang_eqn(master_node_pt,ival).
|
| std::map< Node *, unsigned > | Shape_controlling_node_lookup |
| | Lookup scheme for unique number associated with any of the nodes that actively control the shape of the element (i.e. they are either non-hanging nodes of this element or master nodes of hanging nodes.
|
