We also provide interfaces for functions that compute the element's Jacobian matrix and/or the Vector of residuals. In addition, an interface that returns a mass matrix --- the matrix of terms that multiply any time derivatives in the problem --- is also provided to permit explicit time-stepping and the solution of the generalised eigenproblems. Object size: 28 bytes (32-bit), 56 bytes (64-bit)
|
Public Member Functions |
| | GeneralisedElement () |
| | Constructor: Initialise all pointers and all values to zero.
|
| virtual | ~GeneralisedElement () |
| | Virtual destructor to clean up any memory allocated by the object.
|
| | GeneralisedElement (const GeneralisedElement &) |
| | Broken copy constructor.
|
| void | operator= (const GeneralisedElement &) |
| | Broken assignment operator.
|
| Time *& | time_pt () |
| | Retun the pointer to the global time.
|
| Time *const & | time_pt () const |
| | Return the pointer to the global time (const version).
|
| double | time () const |
| | Return the global time, accessed via the time pointer.
|
| Data *& | internal_data_pt (const unsigned &i) |
| | Return a pointer to i-th internal data object.
|
| Data *const & | internal_data_pt (const unsigned &i) const |
| | Return a pointer to i-th internal data object (const version).
|
| Data *& | external_data_pt (const unsigned &i) |
| | Return a pointer to i-th external data object.
|
| Data *const & | external_data_pt (const unsigned &i) const |
| | Return a pointer to i-th external data object (const version).
|
| unsigned long | eqn_number (const unsigned &ieqn_local) |
| | Return the global equation number corresponding to the ieqn_local-th local equation number.
|
| int | local_eqn_number (const unsigned long &ieqn_global) |
| | Return the local equation number corresponding to the ieqn_global-th global equation number. Returns minus one (-1) if there is no local degree of freedom corresponding to the chosen global equation number.
|
| unsigned | add_external_data (Data *const &data_pt, const bool &fd=true) |
| bool | external_data_fd (const unsigned &i) const |
| | Return the status of the boolean flag indicating whether the external data is included in the finite difference loop.
|
| void | exclude_external_data_fd (const unsigned &i) |
| | Set the boolean flag to exclude the external datum from the the finite difference loop when computing the jacobian matrix.
|
| void | include_external_data_fd (const unsigned &i) |
| | Set the boolean flag to include the external datum in the the finite difference loop when computing the jacobian matrix.
|
| void | flush_external_data () |
| | Flush all external data.
|
| void | flush_external_data (Data *const &data_pt) |
| | Flush the object addressed by data_pt from the external data array.
|
| unsigned | ninternal_data () const |
| | Return the number of internal data objects.
|
| unsigned | nexternal_data () const |
| | Return the number of external data objects.
|
| unsigned | ndof () const |
| | Return the number of equations/dofs in the element.
|
| void | assign_internal_eqn_numbers (unsigned long &global_number, Vector< double * > &Dof_pt) |
| | Assign the global equation numbers to the internal Data. The arguments are the current highest global equation number (which will be incremented) and a Vector of pointers to the global variables (to which any unpinned values in the internal Data are added).
|
| virtual void | assign_local_eqn_numbers () |
| | Setup the arrays of local equation numbers for the element.
|
| virtual void | complete_setup_of_dependencies () |
| | Complete the setup of any additional dependencies that the element may have. Empty virtual function that may be overloaded for specific derived elements. Used, e.g., for elements with algebraic node update functions to determine the "geometric Data", i.e. the Data that affects the element's shape. This function is called (for all elements) at the very beginning of the equation numbering procedure to ensure that all dependencies are accounted for.
|
| virtual void | get_residuals (Vector< double > &residuals) |
| | Calculate the vector of residuals of the equations in the element. By default initialise the vector to zero and then call the fill_in_contribution_to_residuals() function. Note that this entire function can be overloaded if desired.
|
| virtual void | get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian) |
| | Calculate the elemental Jacobian matrix "d equation / d variable".
|
| virtual void | get_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix) |
| | Calculate the residuals and the elemental "mass" matrix, the matrix that multiplies the time derivative terms in a problem.
|
| virtual void | get_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix) |
| | Calculate the residuals and jacobian and elemental "mass" matrix, the matrix that multiplies the time derivative terms.
|
| virtual unsigned | self_test () |
| | Self-test: Have all internal values been classified as pinned/unpinned? Return 0 if OK.
|
| virtual unsigned | ndof_types () |
| | The number of types of degrees of freedom in this element are sub-divided into.
|
| virtual void | get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned > > &block_lookup_list) |
| | Create a list of pairs for the unknowns that this element is "in charge of" -- ignore any unknowns associated with external Data. The first entry in each pair must contain the global equation number of the unknown, while the second one contains the number of the DOF that this unknown is associated with. (The function can obviously only be called if the equation numbering scheme has been set up.).
|
Static Public Attributes |
| static bool | Suppress_warning_about_repeated_internal_data = false |
| | Static boolean to suppress warnings about repeated internal data. Defaults to false.
|
| static bool | Suppress_warning_about_repeated_external_data = true |
| | Static boolean to suppress warnings about repeated external data. Defaults to true.
|
| static double | Default_fd_jacobian_step = 1.0e-8 |
| | Double used for the default finite difference step in elemental jacobian calculations.
|
Protected Member Functions |
| unsigned | add_internal_data (Data *const &data_pt, const bool &fd=true) |
| | Add a (pointer to an) internal data object to the element and return the index required to obtain it from the access function internal_data_pt(). The boolean indicates whether the datum should be included in the general finite-difference loop when calculating the jacobian. The default value is true, i.e. the data will be included in the finite differencing.
|
| bool | internal_data_fd (const unsigned &i) const |
| | Return the status of the boolean flag indicating whether the internal data is included in the finite difference loop.
|
| void | exclude_internal_data_fd (const unsigned &i) |
| | Set the boolean flag to exclude the internal datum from the finite difference loop when computing the jacobian matrix.
|
| void | include_internal_data_fd (const unsigned &i) |
| | Set the boolean flag to include the internal datum in the finite difference loop when computing the jacobian matrix.
|
| void | clear_global_eqn_numbers () |
| | Clear the storage for the global equation numbers.
|
| void | add_global_eqn_numbers (std::deque< unsigned long > const &global_eqn_numbers) |
| | Add the contents of the queue global_eqn_numbers to the local storage for the local-to-global translation scheme. It is essential that the entries in the queue are added IN ORDER i.e. from the front.
|
| virtual void | assign_internal_and_external_local_eqn_numbers () |
| | Assign the local equation numbers for the internal and external Data This must be called after the global equation numbers have all been assigned. It is virtual so that it can be overloaded by ElementWithExternalElements so that any external data from the external elements in included in the numbering scheme.
|
| virtual void | assign_all_generic_local_eqn_numbers () |
| | Assign all the local equation numbering schemes that can be applied generically for the element. In most cases, this is the function that will be overloaded by inherited classes. It is required to ensure that assign_additional_local_eqn_numbers() can always be called after ALL other local equation numbering has been performed. The default for the GeneralisedElement is simply to call internal and external local equation numbering.
|
| virtual void | assign_additional_local_eqn_numbers () |
| | Setup any additional look-up schemes for local equation numbers. Examples of use include using local storage to refer to explicit degrees of freedom. The additional memory cost of such storage may or may not be offset by fast local access.
|
| int | internal_local_eqn (const unsigned &i, const unsigned &j) |
| | Return the local equation number corresponding to the j-th value stored at the i-th internal data.
|
| int | external_local_eqn (const unsigned &i, const unsigned &j) |
| | Return the local equation number corresponding to the j-th value stored at the i-th external data.
|
| virtual void | fill_in_contribution_to_residuals (Vector< double > &residuals) |
| | Add the elemental contribution to the residuals vector. Note that this function will NOT initialise the residuals vector. It must be called after the residuals vector has been initialised to zero.
|
| void | fill_in_jacobian_from_internal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false) |
| | Calculate the contributions to the jacobian from the internal degrees of freedom using finite differences. This version of the function assumes that the residuals vector has already been calculated. If the boolean argument is true, the finite differencing will be performed for all internal data, irrespective of the information in Data_fd. The default value (false) uses the information in Data_fd to selectively difference only certain data.
|
| void | fill_in_jacobian_from_internal_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false) |
| | Calculate the contributions to the jacobian from the internal degrees of freedom using finite differences. This version computes the residuals vector before calculating the jacobian terms. If the boolean argument is true, the finite differencing will be performed for all internal data, irrespective of the information in Data_fd. The default value (false) uses the information in Data_fd to selectively difference only certain data.
|
| void | fill_in_jacobian_from_external_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false) |
| | Calculate the contributions to the jacobian from the external degrees of freedom using finite differences. This version of the function assumes that the residuals vector has already been calculated. If the boolean argument is true, the finite differencing will be performed for all external data, irrespective of the information in Data_fd. The default value (false) uses the information in Data_fd to selectively difference only certain data.
|
| void | fill_in_jacobian_from_external_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false) |
| | Calculate the contributions to the jacobian from the external degrees of freedom using finite differences. This version computes the residuals vector before calculating the jacobian terms. If the boolean argument is true, the finite differencing will be performed for all internal data, irrespective of the information in Data_fd. The default value (false) uses the information in Data_fd to selectively difference only certain data.
|
| virtual void | update_before_internal_fd () |
| | Function that is called before the finite differencing of any internal data. This may be overloaded to update any slaved data before finite differencing takes place.
|
| virtual void | reset_after_internal_fd () |
| | Function that is call after the finite differencing of the internal data. This may be overloaded to reset any slaved variables that may have changed during the finite differencing.
|
| virtual void | update_in_internal_fd (const unsigned &i) |
| | Function called within the finite difference loop for internal data after a change in any values in the i-th internal data object.
|
| virtual void | reset_in_internal_fd (const unsigned &i) |
| | Function called within the finite difference loop for internal data after the values in the i-th external data object are reset. The default behaviour is to call the update function.
|
| virtual void | update_before_external_fd () |
| | Function that is called before the finite differencing of any external data. This may be overloaded to update any slaved data before finite differencing takes place.
|
| virtual void | reset_after_external_fd () |
| | Function that is call after the finite differencing of the external data. This may be overloaded to reset any slaved variables that may have changed during the finite differencing.
|
| virtual void | update_in_external_fd (const unsigned &i) |
| | Function called within the finite difference loop for external data after a change in any values in the i-th external data object.
|
| virtual void | reset_in_external_fd (const unsigned &i) |
| | Function called within the finite difference loop for external data after the values in the i-th external data object are reset. The default behaviour is to call the update function.
|
| virtual void | fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian) |
| | Add the elemental contribution to the jacobian matrix. and the residuals vector. Note that this function will NOT initialise the residuals vector or the jacobian matrix. It must be called after the residuals vector and jacobian matrix have been initialised to zero. The default is to use finite differences to calculate the jacobian.
|
| virtual void | fill_in_contribution_to_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix) |
| | Add the elemental contribution to the mass matrix and the residuals vector. Note that this function will NOT initialise the residuals vector or the mass matrix. It must be called after the residuals vector and jacobian matrix have been initialised to zero. The default is deliberately broken.
|
| virtual void | fill_in_contribution_to_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix) |
| | Add the elemental contribution to the jacobian matrix, mass matrix and the residuals vector. Note that this function should NOT initialise any entries. It must be called after the residuals vector and matrices have been initialised to zero. The default is deliberately broken.
|
Static Protected Attributes |
| static DenseMatrix< double > | Dummy_matrix |
| | Empty dense matrix used as a dummy argument to combined residual and jacobian functions in the case when only the residuals are being assembled.
|
Private Attributes |
| Time * | Time_pt |
| | Pointer to global time.
|
| unsigned long * | Eqn_number |
| | Storage for the global equation numbers represented by the degrees of freedom in the element.
|
| Data ** | Data_pt |
| | Storage for pointers to internal and external data. The data is of the same type and so can be addressed by a single pointer. The idea is that the array is of total size Ninternal_data + Nexternal_data. The internal data are stored at the beginning of the array and the external data are stored at the end of the array.
|
| int ** | Data_local_eqn |
| | Pointer to array storage for local equation numbers associated with internal and external data. Again, we save storage by using a single pointer to access this information. The first index of the array is of dimension Nineternal_data + Nexternal_data and the second index varies with the number of values stored at the data object. In the most general case, however, the scheme is as memory efficient as possible.
|
| unsigned | Ndof |
| | Number of degrees of freedom.
|
| unsigned | Ninternal_data |
| | Number of internal data.
|
| unsigned | Nexternal_data |
| | Number of external data.
|
| std::vector< bool > | Data_fd |
| | Storage for boolean flags of size Ninternal_data + Nexternal_data that correspond to the data used in the element. The flags indicate whether the particular internal or external data should be included in the general finite-difference loop in fill_in_jacobian_from_internal_by_fd() or fill_in_jacobian_from_external_by_fd(). The default is that all data WILL be included in the finite-difference loop, but in many circumstances it is possible to treat certain (external) data analytically. The use of an STL vector is optimal for memory use because the booleans are represented as single-bits.
|
