oomph::GeneralisedElement Class Reference

#include <elements.h>

Inheritance diagram for oomph::GeneralisedElement:

Public Member Functions
	GeneralisedElement ()
	Constructor: Initialise all pointers and all values to zero. More...
virtual	~GeneralisedElement ()
	Virtual destructor to clean up any memory allocated by the object. More...
	GeneralisedElement (const GeneralisedElement &)=delete
	Broken copy constructor. More...
void	operator= (const GeneralisedElement &)=delete
	Broken assignment operator. More...
Data *&	internal_data_pt (const unsigned &i)
	Return a pointer to i-th internal data object. More...
Data *const &	internal_data_pt (const unsigned &i) const
	Return a pointer to i-th internal data object (const version) More...
Data *&	external_data_pt (const unsigned &i)
	Return a pointer to i-th external data object. More...
Data *const &	external_data_pt (const unsigned &i) const
	Return a pointer to i-th external data object (const version) More...
unsigned long	eqn_number (const unsigned &ieqn_local) const
int	local_eqn_number (const unsigned long &ieqn_global) const
unsigned	add_external_data (Data *const &data_pt, const bool &fd=true)
bool	external_data_fd (const unsigned &i) const
void	exclude_external_data_fd (const unsigned &i)
void	include_external_data_fd (const unsigned &i)
void	flush_external_data ()
	Flush all external data. More...
void	flush_external_data (Data *const &data_pt)
	Flush the object addressed by data_pt from the external data array. More...
unsigned	ninternal_data () const
	Return the number of internal data objects. More...
unsigned	nexternal_data () const
	Return the number of external data objects. More...
unsigned	ndof () const
	Return the number of equations/dofs in the element. More...
void	dof_vector (const unsigned &t, Vector< double > &dof)
	Return the vector of dof values at time level t. More...
void	dof_pt_vector (Vector< double * > &dof_pt)
	Return the vector of pointers to dof values. More...
void	set_internal_data_time_stepper (const unsigned &i, TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
void	assign_internal_eqn_numbers (unsigned long &global_number, Vector< double * > &Dof_pt)
void	describe_dofs (std::ostream &out, const std::string &current_string) const
virtual void	describe_local_dofs (std::ostream &out, const std::string &current_string) const
void	add_internal_value_pt_to_map (std::map< unsigned, double * > &map_of_value_pt)
virtual void	assign_local_eqn_numbers (const bool &store_local_dof_pt)
virtual void	complete_setup_of_dependencies ()
virtual void	get_residuals (Vector< double > &residuals)
virtual void	get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
virtual void	get_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)
virtual void	get_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)
virtual void	get_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)
virtual void	get_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)
virtual void	get_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)
virtual void	get_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)
virtual void	get_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)
virtual void	get_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)
virtual unsigned	self_test ()
virtual void	compute_norm (Vector< double > &norm)
virtual void	compute_norm (double &norm)
virtual unsigned	ndof_types () const
virtual void	get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned >> &dof_lookup_list) const

Static Public Attributes
static bool	Suppress_warning_about_repeated_internal_data
static bool	Suppress_warning_about_repeated_external_data = true
static double	Default_fd_jacobian_step = 1.0e-8

Protected Member Functions
unsigned	add_internal_data (Data *const &data_pt, const bool &fd=true)
bool	internal_data_fd (const unsigned &i) const
void	exclude_internal_data_fd (const unsigned &i)
void	include_internal_data_fd (const unsigned &i)
void	clear_global_eqn_numbers ()
void	add_global_eqn_numbers (std::deque< unsigned long > const &global_eqn_numbers, std::deque< double * > const &global_dof_pt)
virtual void	assign_internal_and_external_local_eqn_numbers (const bool &store_local_dof_pt)
virtual void	assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)
virtual void	assign_additional_local_eqn_numbers ()
int	internal_local_eqn (const unsigned &i, const unsigned &j) const
int	external_local_eqn (const unsigned &i, const unsigned &j)
virtual void	fill_in_contribution_to_residuals (Vector< double > &residuals)
void	fill_in_jacobian_from_internal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
void	fill_in_jacobian_from_internal_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
void	fill_in_jacobian_from_external_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
void	fill_in_jacobian_from_external_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
virtual void	update_before_internal_fd ()
virtual void	reset_after_internal_fd ()
virtual void	update_in_internal_fd (const unsigned &i)
virtual void	reset_in_internal_fd (const unsigned &i)
virtual void	update_before_external_fd ()
virtual void	reset_after_external_fd ()
virtual void	update_in_external_fd (const unsigned &i)
virtual void	reset_in_external_fd (const unsigned &i)
virtual void	fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
virtual void	fill_in_contribution_to_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)
virtual void	fill_in_contribution_to_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)
virtual void	fill_in_contribution_to_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)
virtual void	fill_in_contribution_to_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)
virtual void	fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)
virtual void	fill_in_contribution_to_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)
virtual void	fill_in_contribution_to_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)
virtual void	fill_in_contribution_to_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)

Static Protected Attributes
static DenseMatrix< double >	Dummy_matrix
static std::deque< double * >	Dof_pt_deque

Private Attributes
unsigned long *	Eqn_number
double **	Dof_pt
Data **	Data_pt
int **	Data_local_eqn
unsigned	Ndof
	Number of degrees of freedom. More...
unsigned	Ninternal_data
	Number of internal data. More...
unsigned	Nexternal_data
	Number of external data. More...
std::vector< bool >	Data_fd

Detailed Description

A Generalised Element class.

The main components of a GeneralisedElement are:

• pointers to its internal and external Data, which are stored together in a single array so that we need only store one pointer. The internal Data are placed at the beginning of the array and the external Data are stored at the end.
• a pointer to a global Time
• a lookup table that establishes the relation between local and global equation numbers.

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.

Constructor & Destructor Documentation

GeneralisedElement() [1/2]

oomph::GeneralisedElement::GeneralisedElement ( )

inline

Constructor: Initialise all pointers and all values to zero.

      : Eqn_number(0),
        Dof_pt(0),
        Data_pt(0),
        Data_local_eqn(0),
        Ndof(0),
        Ninternal_data(0),
        Nexternal_data(0)
#ifdef OOMPH_HAS_MPI
        ,
        Non_halo_proc_ID(-1),
        Must_be_kept_as_halo(false)
#endif
    {
    }

~GeneralisedElement()

GeneralisedElement::~GeneralisedElement ( )

virtual

Virtual destructor to clean up any memory allocated by the object.

Destructor for generalised elements: Wipe internal data. Pointers to external data get NULLed but are not deleted because they are (generally) shared by lots of elements.

  {
    // Delete each of the objects stored as internal data
    for (unsigned i = Ninternal_data; i > 0; i--)
    {
      // The objects are stored at the beginning of the Data_pt array
      delete Data_pt[i - 1];
      Data_pt[i - 1] = 0;
    }
 
    // Now delete the storage for internal and external data
    delete[] Data_pt;
 
    // Now if we have allocated storage for the local equation for
    // the internal and external data, delete it.
    if (Data_local_eqn)
    {
      delete[] Data_local_eqn[0];
      delete[] Data_local_eqn;
    }
 
    // Delete the storage for the global equation numbers
    delete[] Eqn_number;
  }

References Data_local_eqn, Data_pt, Eqn_number, i, and Ninternal_data.

GeneralisedElement() [2/2]

oomph::GeneralisedElement::GeneralisedElement ( const GeneralisedElement &  )

delete

Broken copy constructor.

Member Function Documentation

add_external_data()

unsigned GeneralisedElement::add_external_data	(	Data *const &	data_pt,
		const bool &	fd = true
	)

Add a (pointer to an) external data object to the element and return its index (i.e. the index required to obtain it from the access function external_data_pt(...). The optional boolean flag indicates whether the data 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

Add a (pointer to an) external data object to the element and return the index required to obtain it from the access function external_data_pt()

  {
    // Find the numbers of internal and external data
    const unsigned n_internal_data = Ninternal_data;
    const unsigned n_external_data = Nexternal_data;
    // Find out whether the data is already stored in the array
 
    // Loop over the number of externals
    // The external data are stored at the end of the array Data_pt
    for (unsigned i = 0; i < n_external_data; i++)
    {
      // If the passed pointer is stored in the array
      if (external_data_pt(i) == data_pt)
      {
#ifdef PARANOID
        if (!Suppress_warning_about_repeated_external_data)
        {
          oomph_info << std::endl << std::endl;
          oomph_info
            << "---------------------------------------------------------------"
               "--"
            << std::endl
            << "Info: Data is already included in this element's external "
               "storage."
            << std::endl
            << "It's stored as entry " << i << " and I'm not adding it again"
            << std::endl
            << std::endl
            << "Note: You can suppress this message by recompiling without"
            << "\n      PARANOID or setting the boolean \n"
            << "\n      "
               "GeneralisedElement::Suppress_warning_about_repeated_external_"
               "data"
            << "\n\n      to true." << std::endl
            << "---------------------------------------------------------------"
               "--"
            << std::endl
            << std::endl;
        }
#endif
        // Return the index to the data object
        return i;
      }
    }
 
    // Allocate new storage for the pointers to data
    Data** new_data_pt = new Data*[n_internal_data + n_external_data + 1];
 
    // Copy the old internal and external values across to the new array
    for (unsigned i = 0; i < (n_internal_data + n_external_data); i++)
    {
      new_data_pt[i] = Data_pt[i];
    }
 
    // Add the new data pointer to the end of the array
    new_data_pt[n_internal_data + n_external_data] = data_pt;
 
    // Delete the storage associated with the previous values
    delete[] Data_pt;
 
    // Set the pointer to the new storage
    Data_pt = new_data_pt;
 
    // Resize the array of boolean flags
    Data_fd.resize(n_internal_data + n_external_data + 1);
    // Now add the new flag to the end of the external data
    Data_fd[n_internal_data + n_external_data] = fd;
 
    // Increase the number of externals
    ++Nexternal_data;
 
    // Return the final index to the new external data
    return n_external_data;
  }

References Data_fd, Data_pt, external_data_pt(), i, Nexternal_data, Ninternal_data, oomph::oomph_info, and Suppress_warning_about_repeated_external_data.

Referenced by oomph::NavierStokesFluxControlElement< ELEMENT >::add_pressure_data(), oomph::TemplateFreeNavierStokesFluxControlElementBase::add_pressure_data(), oomph::NavierStokesWomersleyPressureControlElement::add_pressure_data(), oomph::StefanBoltzmannRadiationBase::add_stefan_boltzmann_illumination_info(), oomph::ConstraintElement::build(), oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::complete_setup_of_dependencies(), oomph::HelmholtzDtNBoundaryElement< ELEMENT >::complete_setup_of_dependencies(), AirwayReopeningProblem< ELEMENT >::connect_walls(), oomph::DisplacementControlElement::DisplacementControlElement(), FSICollapsibleChannelProblem< ELEMENT >::FSICollapsibleChannelProblem(), oomph::HeightControlElement::HeightControlElement(), oomph::ImmersedRigidBodyElement::initialise(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::LinearisedAxisymPoroelasticBJS_FSIElement(), oomph::FixedVolumeSpineLineMarangoniFluidInterfaceElement< ELEMENT >::make_bounding_element(), oomph::NetFluxControlElement< ELEMENT >::NetFluxControlElement(), oomph::SolidICProblem::reset_original_state(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::set_boundary_shape_geom_object_pt(), HeatedCircularPenetratorElement::set_contact_element_mesh_pt(), CircularPenetratorElement::set_contact_element_mesh_pt(), oomph::ImmersedRigidBodyElement::set_drag_mesh(), oomph::LinearisedNavierStokesEquations::set_eigenfunction_normalisation_element(), oomph::NavierStokesImpedanceTractionElement< BULK_NAVIER_STOKES_ELEMENT, WOMERSLEY_ELEMENT, DIM >::set_external_data_from_navier_stokes_outflow_mesh(), oomph::FluidInterfaceElement::set_external_pressure_data(), oomph::PolarNavierStokesTractionElement< ELEMENT >::set_external_pressure_data(), oomph::YoungLaplaceEquations::set_kappa(), oomph::ElasticallySupportedRingElement::set_load_pt(), oomph::SurfaceContactElementBase< ELEMENT >::set_penetrator_pt(), oomph::FluxConstraint::set_pressure_data(), oomph::WomersleyEquations< DIM >::set_pressure_gradient_and_add_as_external_data(), oomph::PseudoBucklingRingElement::set_reference_pressure_pt(), oomph::NavierStokesSurfaceDragTorqueElement< ELEMENT >::set_translation_and_rotation(), oomph::VolumeConstraintBoundingElement::set_volume_constraint_element(), oomph::FoepplvonKarmanEquations::set_volume_constraint_pressure_data_as_external_data(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::set_wrapped_navier_stokes_element_pt(), oomph::DGFaceElement::setup_neighbour_info(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::store_reynolds_strouhal_as_external_data(), oomph::SpaceTimeNavierStokesEquations< DIM >::store_strouhal_as_external_data(), and oomph::VolumeConstraintElement::VolumeConstraintElement().

add_global_eqn_numbers()

void GeneralisedElement::add_global_eqn_numbers ( std::deque< unsigned long > const &  global_eqn_numbers, std::deque< double * > const &  global_dof_pt  )

protected

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.

Add the contents of the queue global_eqn_numbers to the local storage for the equation numbers, which represents the local-to-global translation scheme. It is essential that the entries are added in order, i.e. from the front.

  {
    // Find the number of dofs
    const unsigned n_dof = Ndof;
    // Find the number of additional dofs
    const unsigned n_additional_dof = global_eqn_numbers.size();
    // If there are none, return immediately
    if (n_additional_dof == 0)
    {
      return;
    }
 
    // Find the new total number of equation numbers
    const unsigned new_n_dof = n_dof + n_additional_dof;
    // Create storage for all equations, initialised to NULL
    unsigned long* new_eqn_number = new unsigned long[new_n_dof];
 
    // Copy over the existing values to the start new storage
    for (unsigned i = 0; i < n_dof; i++)
    {
      new_eqn_number[i] = Eqn_number[i];
    }
 
    // Set an index to the next position in the new storage
    unsigned index = n_dof;
    // Loop over the queue and add it's entries to our new storage
    for (std::deque<unsigned long>::const_iterator it =
           global_eqn_numbers.begin();
         it != global_eqn_numbers.end();
         ++it)
    {
      // Add the value to the storage
      new_eqn_number[index] = *it;
      // Increase the array index
      ++index;
    }
 
 
    // If a non-empty dof deque has been passed then do stuff
    const unsigned n_additional_dof_pt = global_dof_pt.size();
    if (n_additional_dof_pt > 0)
    {
// If it's size is not the same as the equation numbers complain
#ifdef PARANOID
      if (n_additional_dof_pt != n_additional_dof)
      {
        std::ostringstream error_stream;
        error_stream
          << "global_dof_pt is non-empty, yet it does not have the same size\n"
          << "as global_eqn_numbers.\n"
          << "There are " << n_additional_dof << " equation numbers,\n"
          << "but " << n_additional_dof_pt << std::endl;
 
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // Create storge for all dofs initialised to NULL
      double** new_dof_pt = new double*[new_n_dof];
      // Copy over the exisiting values to the start of new storage
      for (unsigned i = 0; i < n_dof; i++)
      {
        new_dof_pt[i] = Dof_pt[i];
      }
 
      // Set an index to the next position in the new storage
      unsigned index = n_dof;
      // Loop over the queue and add it's entries to our new storage
      for (std::deque<double*>::const_iterator it = global_dof_pt.begin();
           it != global_dof_pt.end();
           ++it)
      {
        // Add the value to the storage
        new_dof_pt[index] = *it;
        // Increase the array index
        ++index;
      }
 
      // Now delete the old storage
      delete[] Dof_pt;
      // Set the pointer to address the new storage
      Dof_pt = new_dof_pt;
    }
 
    // Now delete the old for the equation numbers storage
    delete[] Eqn_number;
    // Set the pointer to address the new storage
    Eqn_number = new_eqn_number;
    // Finally update the number of degrees of freedom
    Ndof = new_n_dof;
  }

References Dof_pt, Eqn_number, i, Ndof, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::ElementWithMovingNodes::assign_all_generic_local_eqn_numbers(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), oomph::RefineableElement::assign_hanging_local_eqn_numbers(), assign_internal_and_external_local_eqn_numbers(), oomph::FiniteElement::assign_nodal_local_eqn_numbers(), oomph::RefineableSolidElement::assign_solid_hanging_local_eqn_numbers(), and oomph::SolidFiniteElement::assign_solid_local_eqn_numbers().

add_internal_data()

unsigned GeneralisedElement::add_internal_data ( Data *const &  data_pt, const bool &  fd = true  )

protected

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.

//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// 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()

  {
    // Local cache of numbers of internal and external data
    const unsigned n_internal_data = Ninternal_data;
    const unsigned n_external_data = Nexternal_data;
 
    // Find out whether the data is already stored in the array
 
    // Loop over the number of internals
    // The internal data are stored at the beginning of the array
    for (unsigned i = 0; i < n_internal_data; i++)
    {
      // If the passed pointer is stored in the array
      if (internal_data_pt(i) == data_pt)
      {
#ifdef PARANOID
        if (!Suppress_warning_about_repeated_internal_data)
        {
          oomph_info << std::endl << std::endl;
          oomph_info
            << "---------------------------------------------------------------"
               "--"
            << std::endl
            << "Info: Data is already included in this element's internal "
               "storage."
            << std::endl
            << "It's stored as entry " << i << " and I'm not adding it again."
            << std::endl
            << std::endl
            << "Note: You can suppress this message by recompiling without"
            << "\n      PARANOID or setting the boolean \n"
            << "\n      "
               "GeneralisedElement::Suppress_warning_about_repeated_internal_"
               "data"
            << "\n\n      to true." << std::endl
            << "---------------------------------------------------------------"
               "--"
            << std::endl
            << std::endl;
        }
#endif
        // Return the index to the data object
        return i;
      }
    }
 
    // Allocate new storage for the pointers to data
    Data** new_data_pt = new Data*[n_internal_data + n_external_data + 1];
 
    // Copy the old internal values across to the beginning of the array
    for (unsigned i = 0; i < n_internal_data; i++)
    {
      new_data_pt[i] = Data_pt[i];
    }
 
    // Now add the new value to the end of the internal data
    new_data_pt[n_internal_data] = data_pt;
 
    // Copy the external values across
    for (unsigned i = 0; i < n_external_data; i++)
    {
      new_data_pt[n_internal_data + 1 + i] = Data_pt[n_internal_data + i];
    }
 
    // Delete the storage associated with the previous values
    delete[] Data_pt;
 
    // Set the pointer to the new storage
    Data_pt = new_data_pt;
 
    // Resize the array of boolean flags
    Data_fd.resize(n_internal_data + n_external_data + 1);
    // Shuffle the flags for the external data to the end of the array
    for (unsigned i = n_external_data; i > 0; i--)
    {
      Data_fd[n_internal_data + i] = Data_fd[n_internal_data + i - 1];
    }
    // Now add the new flag to the end of the internal data
    Data_fd[n_internal_data] = fd;
 
    // Increase the number of internals
    ++Ninternal_data;
 
    // Return the final index to the new internal data
    return n_internal_data;
  }

References Data_fd, Data_pt, i, internal_data_pt(), Nexternal_data, Ninternal_data, oomph::oomph_info, and Suppress_warning_about_repeated_internal_data.

Referenced by oomph::AxisymmetricQCrouzeixRaviartElement::AxisymmetricQCrouzeixRaviartElement(), oomph::AxisymmetricTCrouzeixRaviartElement::AxisymmetricTCrouzeixRaviartElement(), oomph::AxisymQPVDElementWithPressure::AxisymQPVDElementWithPressure(), oomph::ODEElement::build(), oomph::ConstraintElement::construct_lagrange_multipliers(), oomph::NodeNodeMortaringElement::construct_lagrange_multipliers(), oomph::DisplacementControlElement::DisplacementControlElement(), oomph::ElasticallySupportedRingElement::ElasticallySupportedRingElement(), oomph::FoepplvonKarmanVolumeConstraintElement< ELEMENT, MESH >::FoepplvonKarmanVolumeConstraintElement(), oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement(), oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >::GeneralisedNewtonianQCrouzeixRaviartElement(), oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >::GeneralisedNewtonianTCrouzeixRaviartElement(), HeatedCircularPenetratorElement::HeatedCircularPenetratorElement(), oomph::HeightControlElement::HeightControlElement(), oomph::ImposeFluxForWomersleyElement< DIM >::ImposeFluxForWomersleyElement(), oomph::ImmersedRigidBodyElement::initialise(), oomph::LinearisedAxisymmetricQCrouzeixRaviartElement::LinearisedAxisymmetricQCrouzeixRaviartElement(), oomph::LinearisedNavierStokesEigenfunctionNormalisationElement::LinearisedNavierStokesEigenfunctionNormalisationElement(), oomph::LinearisedQCrouzeixRaviartElement::LinearisedQCrouzeixRaviartElement(), oomph::NavierStokesWomersleyPressureControlElement::NavierStokesWomersleyPressureControlElement(), oomph::NetFluxControlElement< ELEMENT >::NetFluxControlElement(), oomph::NodeElementSolidOnlyMortaringElement::NodeElementSolidOnlyMortaringElement(), oomph::PolarCrouzeixRaviartElement::PolarCrouzeixRaviartElement(), oomph::PseudoBucklingRingElement::PseudoBucklingRingElement(), oomph::QCrouzeixRaviartElement< DIM >::QCrouzeixRaviartElement(), oomph::QPVDElementWithPressure< DIM >::QPVDElementWithPressure(), oomph::QSphericalCrouzeixRaviartElement::QSphericalCrouzeixRaviartElement(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::SingularNavierStokesSolutionElement(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::TAxisymmetricPoroelasticityElement(), oomph::TCrouzeixRaviartElement< DIM >::TCrouzeixRaviartElement(), oomph::TPoroelasticityElement< ORDER >::TPoroelasticityElement(), oomph::TRaviartThomasDarcyElement< ORDER >::TRaviartThomasDarcyElement(), oomph::VolumeConstraintElement::VolumeConstraintElement(), and ZeroResidualGenElement::ZeroResidualGenElement().

add_internal_value_pt_to_map()

void GeneralisedElement::add_internal_value_pt_to_map

(

std::map< unsigned, double * > &

map_of_value_pt

)

Add pointers to the internal data values to map indexed by the global equation number.

This function loops over the internal data of the element and add pointers to their unconstrained values to a map indexed by the global equation number.

  {
    // Loop over the internal data and add their data to the map
    // The internal data are stored at the beginning of the Data_pt array
    for (unsigned i = 0; i < Ninternal_data; i++)
    {
      internal_data_pt(i)->add_value_pt_to_map(map_of_value_pt);
    }
  }

References oomph::Data::add_value_pt_to_map(), i, internal_data_pt(), and Ninternal_data.

assign_additional_local_eqn_numbers()

virtual void oomph::GeneralisedElement::assign_additional_local_eqn_numbers ( )

inlineprotectedvirtual

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.

Reimplemented in oomph::HeightControlElement, oomph::DisplacementControlElement, oomph::FoepplvonKarmanVolumeConstraintElement< ELEMENT, MESH >, oomph::FoepplvonKarmanVolumeConstraintElement< ELEMENT, RefineableTriangleMesh >, ModalPRefineableQPoissonElement< DIM >, SpineGravityTractionElement< ELEMENT >, FixSpineHeightElement, oomph::LinearisedAxisymmetricNavierStokesEquations, FixSpineHeightElement, SpineGravityTractionElement< ELEMENT >, and QOrrSommerfeldElement< 1, NNODE_1D >.

{}

Referenced by assign_local_eqn_numbers().

assign_all_generic_local_eqn_numbers()

virtual void oomph::GeneralisedElement::assign_all_generic_local_eqn_numbers ( const bool &  store_local_dof_pt )

inlineprotectedvirtual

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. If the boolean argument is true then pointers to the dofs will be stored in Dof_pt

Reimplemented in oomph::RefineableQSpectralPoissonElement< DIM, NNODE_1D >, oomph::SpectralElement, oomph::FaceElementAsGeomObject< ELEMENT >, oomph::SolidFiniteElement, oomph::FiniteElement, oomph::ElementWithSpecificMovingNodes< ELEMENT, NODE_TYPE >, oomph::ElementWithSpecificMovingNodes< ELEMENT, SpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, PerturbedSpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, AlgebraicNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, MacroElementNodeUpdateNode >, and oomph::ElementWithMovingNodes.

    {
      this->assign_internal_and_external_local_eqn_numbers(store_local_dof_pt);
    }

References assign_internal_and_external_local_eqn_numbers().

Referenced by oomph::FiniteElement::assign_all_generic_local_eqn_numbers(), and assign_local_eqn_numbers().

assign_internal_and_external_local_eqn_numbers()

void GeneralisedElement::assign_internal_and_external_local_eqn_numbers ( const bool &  store_local_dof_pt )

protectedvirtual

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. If the boolean argument is true then pointers to the dofs will be stored in Dof_pt

This function loops over the internal and external data of the element, adds the GLOBAL equation numbers to the local-to-global look-up scheme and fills in the look-up schemes for the local equation numbers. If the boolean argument is true then pointers to the dofs will be stored in Dof_pt

Reimplemented in oomph::ElementWithExternalElement.

  {
    // Find the number of internal and external data
    const unsigned n_internal_data = Ninternal_data;
    const unsigned n_external_data = Nexternal_data;
    // Find the total number of data
    const unsigned n_total_data = n_internal_data + n_external_data;
 
    // If there is data
    if (n_total_data > 0)
    {
      // Find the number of local equations assigned so far
      unsigned local_eqn_number = ndof();
 
      // We need to find the total number of values stored in all the
      // internal and external data
      // Initialise to the number stored in the first data object
      unsigned n_total_values = Data_pt[0]->nvalue();
      // Loop over the other data and add the number of values stored
      for (unsigned i = 1; i < n_total_data; ++i)
      {
        n_total_values += Data_pt[i]->nvalue();
      }
 
      // If allocated delete the old storage
      if (Data_local_eqn)
      {
        delete[] Data_local_eqn[0];
        delete[] Data_local_eqn;
      }
 
      // If there are no values then we are done, null out the storage and
      // return
      if (n_total_values == 0)
      {
        Data_local_eqn = 0;
        return;
      }
 
      // Allocate the storage for the local equation numbers
      // The idea is that we store internal equation numbers followed by
      // external equation numbers
 
      // Firstly allocate pointers to the rows for each data item
      Data_local_eqn = new int*[n_total_data];
      // Now allocate storage for all the equation numbers
      Data_local_eqn[0] = new int[n_total_values];
      // Set all values to be unclassified
      for (unsigned i = 0; i < n_total_values; ++i)
      {
        Data_local_eqn[0][i] = Data::Is_unclassified;
      }
 
      // Loop over the remaining rows and set their pointers
      for (unsigned i = 1; i < n_total_data; ++i)
      {
        // Initially set the pointer to the i-th row to the pointer
        // to the i-1th row
        Data_local_eqn[i] = Data_local_eqn[i - 1];
        // Now increase the row pointer by the number of values
        // stored at the i-1th data object
        Data_local_eqn[i] += Data_pt[i - 1]->nvalue();
      }
 
      // A local queue to store the global equation numbers
      std::deque<unsigned long> global_eqn_number_queue;
 
      // Now loop over the internal data and assign local equation numbers
      for (unsigned i = 0; i < n_internal_data; i++)
      {
        // Pointer to the internal data
        Data* const data_pt = internal_data_pt(i);
        // Find the number of values stored at the internal data
        unsigned n_value = data_pt->nvalue();
 
        // Loop over the number of values
        for (unsigned j = 0; j < n_value; j++)
        {
          // Get the GLOBAL equation number
          long eqn_number = data_pt->eqn_number(j);
          // If the GLOBAL equation number is positive (a free variable)
          if (eqn_number >= 0)
          {
            // Add the GLOBAL equation number to the queue
            global_eqn_number_queue.push_back(eqn_number);
            // Add pointer to the dof to the queue if required
            if (store_local_dof_pt)
            {
              GeneralisedElement::Dof_pt_deque.push_back(data_pt->value_pt(j));
            }
            // Add the local equation number to the storage scheme
            Data_local_eqn[i][j] = local_eqn_number;
            // Increase the local number
            local_eqn_number++;
          }
          else
          {
            // Set the local scheme to be pinned
            Data_local_eqn[i][j] = Data::Is_pinned;
          }
        }
      } // End of loop over internal data
 
 
      // Now loop over the external data and assign local equation numbers
      for (unsigned i = 0; i < n_external_data; i++)
      {
        // Pointer to the external data
        Data* const data_pt = external_data_pt(i);
        // Find the number of values stored at the external data
        unsigned n_value = data_pt->nvalue();
 
        // Loop over the number of values
        for (unsigned j = 0; j < n_value; j++)
        {
          // Get the GLOBAL equation number
          long eqn_number = data_pt->eqn_number(j);
          // If the GLOBAL equation number is positive (a free variable)
          if (eqn_number >= 0)
          {
            // Add the GLOBAL equation number to the queue
            global_eqn_number_queue.push_back(eqn_number);
            // Add pointer to the dof to the queue if required
            if (store_local_dof_pt)
            {
              GeneralisedElement::Dof_pt_deque.push_back(data_pt->value_pt(j));
            }
            // Add the local equation number to the local scheme
            Data_local_eqn[n_internal_data + i][j] = local_eqn_number;
            // Increase the local number
            local_eqn_number++;
          }
          else
          {
            // Set the local scheme to be pinned
            Data_local_eqn[n_internal_data + i][j] = Data::Is_pinned;
          }
        }
      }
 
      // Now add our global equations numbers to the internal element storage
      add_global_eqn_numbers(global_eqn_number_queue,
                             GeneralisedElement::Dof_pt_deque);
      // Clear the memory used in the deque
      if (store_local_dof_pt)
      {
        std::deque<double*>().swap(GeneralisedElement::Dof_pt_deque);
      }
    }
  }

References add_global_eqn_numbers(), Data_local_eqn, Data_pt, Dof_pt_deque, oomph::Data::eqn_number(), eqn_number(), external_data_pt(), i, internal_data_pt(), oomph::Data::Is_pinned, oomph::Data::Is_unclassified, j, local_eqn_number(), ndof(), Nexternal_data, Ninternal_data, oomph::Data::nvalue(), and oomph::Data::value_pt().

Referenced by assign_all_generic_local_eqn_numbers(), and oomph::ElementWithExternalElement::assign_internal_and_external_local_eqn_numbers().

assign_internal_eqn_numbers()

void GeneralisedElement::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).

This function loops over the internal data of the element and assigns GLOBAL equation numbers to the data objects.

Pass:

• the current total number of dofs, global_number, which gets incremented.
• Dof_pt, the Vector of pointers to the global dofs (to which any internal dofs are added).

  {
    // Loop over the internal data and assign the equation numbers
    // The internal data are stored at the beginning of the Data_pt array
    for (unsigned i = 0; i < Ninternal_data; i++)
    {
      internal_data_pt(i)->assign_eqn_numbers(global_number, Dof_pt);
    }
  }

References oomph::Data::assign_eqn_numbers(), Dof_pt, i, internal_data_pt(), and Ninternal_data.

assign_local_eqn_numbers()

void GeneralisedElement::assign_local_eqn_numbers ( const bool &  store_local_dof_pt )

virtual

Setup the arrays of local equation numbers for the element. If the optional boolean argument is true, then pointers to the associated degrees of freedom are stored locally in the array Dof_pt

Setup the arrays of local equation numbers for the element. In general, this function should not need to be overloaded. Instead the function assign_all_generic_local_eqn_numbers() will be overloaded by different types of Element. That said, the function is virtual so that it may be overloaded by the user if they really know what they are doing.

Reimplemented in oomph::Hijacked< PerturbedSpineElement< FaceGeometry< ELEMENT > > >, oomph::Hijacked< SpineElement< FaceGeometry< FaceGeometry< ELEMENT > > > >, and oomph::Hijacked< SpineElement< FaceGeometry< ELEMENT > > >.

  {
    clear_global_eqn_numbers();
    assign_all_generic_local_eqn_numbers(store_local_dof_pt);
    assign_additional_local_eqn_numbers();
 
    // Check that no global equation numbers are repeated
#ifdef PARANOID
 
    std::ostringstream error_stream;
 
    // Loop over the array of equation numbers and add to set to assess
    // uniqueness
    std::map<unsigned, bool> is_repeated;
    std::set<unsigned long> set_of_global_eqn_numbers;
    unsigned old_ndof = 0;
    for (unsigned n = 0; n < Ndof; ++n)
    {
      set_of_global_eqn_numbers.insert(Eqn_number[n]);
      if (set_of_global_eqn_numbers.size() == old_ndof)
      {
        error_stream << "Repeated global eqn: " << Eqn_number[n] << std::endl;
        is_repeated[Eqn_number[n]] = true;
      }
      old_ndof = set_of_global_eqn_numbers.size();
    }
 
    // If the sizes do not match we have a repeat, throw an error
    if (set_of_global_eqn_numbers.size() != Ndof)
    {
#ifdef OOMPH_HAS_MPI
      error_stream << "Element is ";
      if (!is_halo()) error_stream << "not ";
      error_stream << "a halo element\n\n";
#endif
      error_stream << "\nLocal/lobal equation numbers: " << std::endl;
      for (unsigned n = 0; n < Ndof; ++n)
      {
        error_stream << "  " << n << "        " << Eqn_number[n] << std::endl;
      }
 
      // It's helpful for debugging purposes to output more about this element
      error_stream << std::endl << " element address is " << this << std::endl;
 
      // Check if the repeated dofs are among the internal Data values
      unsigned nint = this->ninternal_data();
      error_stream << "Number of internal data " << nint << std::endl;
      for (unsigned i = 0; i < nint; i++)
      {
        Data* data_pt = this->internal_data_pt(i);
        unsigned nval = data_pt->nvalue();
        for (unsigned j = 0; j < nval; j++)
        {
          int eqn_no = data_pt->eqn_number(j);
          error_stream << "Internal dof: " << eqn_no << std::endl;
          if (is_repeated[unsigned(eqn_no)])
          {
            error_stream << "Repeated internal dof: " << eqn_no << std::endl;
          }
        }
      }
 
      // Check if the repeated dofs are among the external Data values
      unsigned next = this->nexternal_data();
      error_stream << "Number of external data " << next << std::endl;
      for (unsigned i = 0; i < next; i++)
      {
        Data* data_pt = this->external_data_pt(i);
        unsigned nval = data_pt->nvalue();
        for (unsigned j = 0; j < nval; j++)
        {
          int eqn_no = data_pt->eqn_number(j);
          error_stream << "External dof: " << eqn_no << std::endl;
          if (is_repeated[unsigned(eqn_no)])
          {
            error_stream << "Repeated external dof: " << eqn_no;
            Node* nod_pt = dynamic_cast<Node*>(data_pt);
            if (nod_pt != 0)
            {
              error_stream << " (is a node at: ";
              unsigned ndim = nod_pt->ndim();
              for (unsigned ii = 0; ii < ndim; ii++)
              {
                error_stream << nod_pt->x(ii) << " ";
              }
            }
            error_stream << ")\n";
          }
        }
      }
 
 
      // If it's an element with external element check the associated
      // Data
      ElementWithExternalElement* e_el_pt =
        dynamic_cast<ElementWithExternalElement*>(this);
      if (e_el_pt != 0)
      {
        // Check if the repeated dofs are among the external Data values
        {
          unsigned next = e_el_pt->nexternal_interaction_field_data();
          error_stream << "Number of external element data " << next
                       << std::endl;
          Vector<Data*> data_pt(e_el_pt->external_interaction_field_data_pt());
          for (unsigned i = 0; i < next; i++)
          {
            unsigned nval = data_pt[i]->nvalue();
            for (unsigned j = 0; j < nval; j++)
            {
              int eqn_no = data_pt[i]->eqn_number(j);
              error_stream << "External element dof: " << eqn_no << std::endl;
              if (is_repeated[unsigned(eqn_no)])
              {
                error_stream << "Repeated external element dof: " << eqn_no;
                Node* nod_pt = dynamic_cast<Node*>(data_pt[i]);
                if (nod_pt != 0)
                {
                  error_stream << " (is a node at: ";
                  unsigned ndim = nod_pt->ndim();
                  for (unsigned ii = 0; ii < ndim; ii++)
                  {
                    error_stream << nod_pt->x(ii) << " ";
                  }
                }
                error_stream << ")\n";
              }
            }
          }
        }
 
 
        // Check if the repeated dofs are among the external geom Data values
        {
          unsigned next = e_el_pt->nexternal_interaction_geometric_data();
          error_stream << "Number of external element geom data " << next
                       << std::endl;
          Vector<Data*> data_pt(
            e_el_pt->external_interaction_geometric_data_pt());
          for (unsigned i = 0; i < next; i++)
          {
            unsigned nval = data_pt[i]->nvalue();
            for (unsigned j = 0; j < nval; j++)
            {
              int eqn_no = data_pt[i]->eqn_number(j);
              error_stream << "External element geometric dof: " << eqn_no
                           << std::endl;
              if (is_repeated[unsigned(eqn_no)])
              {
                error_stream
                  << "Repeated external element geometric dof: " << eqn_no
                  << " " << data_pt[i]->value(j);
                Node* nod_pt = dynamic_cast<Node*>(data_pt[i]);
                if (nod_pt != 0)
                {
                  error_stream << " (is a node at: ";
                  unsigned ndim = nod_pt->ndim();
                  for (unsigned ii = 0; ii < ndim; ii++)
                  {
                    error_stream << nod_pt->x(i) << " ";
                  }
                  error_stream << ")";
                }
                error_stream << "\n";
              }
            }
          }
        }
      }
 
      // If it's a FiniteElement then output its nodes
      FiniteElement* f_el_pt = dynamic_cast<FiniteElement*>(this);
      if (f_el_pt != 0)
      {
        unsigned n_node = f_el_pt->nnode();
        for (unsigned n = 0; n < n_node; n++)
        {
          Node* nod_pt = f_el_pt->node_pt(n);
          unsigned nval = nod_pt->nvalue();
          for (unsigned j = 0; j < nval; j++)
          {
            int eqn_no = nod_pt->eqn_number(j);
            error_stream << "Node " << n << ": Nodal dof: " << eqn_no;
            if (eqn_no >= 0)
            {
              if (is_repeated[unsigned(eqn_no)])
              {
                error_stream << "Node " << n
                             << ": Repeated nodal dof: " << eqn_no;
                if (j >= f_el_pt->required_nvalue(n))
                {
                  error_stream << " (resized)";
                }
                error_stream << std::endl;
              }
            }
          }
          SolidNode* solid_nod_pt = dynamic_cast<SolidNode*>(nod_pt);
          if (solid_nod_pt != 0)
          {
            Data* data_pt = solid_nod_pt->variable_position_pt();
            unsigned nval = data_pt->nvalue();
            for (unsigned j = 0; j < nval; j++)
            {
              int eqn_no = data_pt->eqn_number(j);
              error_stream << "Node " << n << ": Positional dof: " << eqn_no
                           << std::endl;
              if (is_repeated[unsigned(eqn_no)])
              {
                error_stream << "Repeated positional dof: " << eqn_no << " "
                             << data_pt->value(j) << std::endl;
              }
            }
          }
        }
 
        // Output nodal coordinates of element
        n_node = f_el_pt->nnode();
        for (unsigned n = 0; n < n_node; n++)
        {
          Node* nod_pt = f_el_pt->node_pt(n);
          unsigned n_dim = nod_pt->ndim();
          error_stream << "Node " << n << " at ( ";
          for (unsigned i = 0; i < n_dim; i++)
          {
            error_stream << nod_pt->x(i) << " ";
          }
          error_stream << ")" << std::endl;
        }
      }
 
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
  }

References assign_additional_local_eqn_numbers(), assign_all_generic_local_eqn_numbers(), clear_global_eqn_numbers(), Eqn_number, oomph::Data::eqn_number(), external_data_pt(), oomph::ElementWithExternalElement::external_interaction_field_data_pt(), oomph::ElementWithExternalElement::external_interaction_geometric_data_pt(), i, internal_data_pt(), j, n, oomph::Node::ndim(), Ndof, nexternal_data(), oomph::ElementWithExternalElement::nexternal_interaction_field_data(), oomph::ElementWithExternalElement::nexternal_interaction_geometric_data(), ninternal_data(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::FiniteElement::required_nvalue(), oomph::Data::value(), oomph::SolidNode::variable_position_pt(), and oomph::Node::x().

clear_global_eqn_numbers()

void oomph::GeneralisedElement::clear_global_eqn_numbers ( )

inlineprotected

Clear the storage for the global equation numbers and pointers to dofs (if stored)

    {
      delete[] Eqn_number;
      Eqn_number = 0;
      delete[] Dof_pt;
      Dof_pt = 0;
      Ndof = 0;
    }

References Dof_pt, Eqn_number, and Ndof.

Referenced by assign_local_eqn_numbers().

complete_setup_of_dependencies()

virtual void oomph::GeneralisedElement::complete_setup_of_dependencies ( )

inlinevirtual

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.

Reimplemented in oomph::HelmholtzDtNBoundaryElement< ELEMENT >, oomph::SpineElement< ELEMENT >, oomph::SpineElement< PointElement >, oomph::SpineElement< FaceGeometry< ELEMENT > >, oomph::ElementWithSpecificMovingNodes< ELEMENT, NODE_TYPE >, oomph::ElementWithSpecificMovingNodes< ELEMENT, SpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, PerturbedSpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, AlgebraicNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, MacroElementNodeUpdateNode >, oomph::ElementWithMovingNodes, oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >, and oomph::PerturbedSpineElement< ELEMENT >.

{}

Referenced by oomph::Problem::assign_eqn_numbers().

compute_norm() [1/2]

virtual void oomph::GeneralisedElement::compute_norm ( double &  norm )

inlinevirtual

Compute norm of solution – broken virtual can be overloaded by element writer to implement whatever norm is desired for the specific element

Reimplemented in oomph::UnsteadyHeatEquations< DIM >, oomph::UnsteadyHeatEquations< 2 >, oomph::TimeHarmonicLinearElasticityEquations< DIM >, oomph::TimeHarmonicFourierDecomposedLinearElasticityEquations, oomph::SpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< 2 >, oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< 2 >, oomph::PoissonEquations< DIM >, oomph::PoissonEquations< 1 >, oomph::PoissonEquations< 2 >, oomph::PoissonEquations< 3 >, oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >, oomph::PMLHelmholtzEquations< DIM >, oomph::PMLFourierDecomposedHelmholtzEquations, oomph::NavierStokesEquations< DIM >, oomph::NavierStokesEquations< 2 >, oomph::FourierDecomposedHelmholtzEquations, oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >, oomph::RefineableDoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::AxisymmetricQAdvectionCrouzeixRaviartElement, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::SolidFiniteElement, and QThermalPVDElement< DIM >.

    {
      std::string error_message = "compute_norm undefined for this element \n";
      throw OomphLibError(
        error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

compute_norm() [2/2]

virtual void oomph::GeneralisedElement::compute_norm ( Vector< double > &  norm )

inlinevirtual

Compute norm of solution – broken virtual can be overloaded by element writer to implement whatever norm is desired for the specific element

Reimplemented in oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::NavierStokesEquations< DIM >, and oomph::NavierStokesEquations< 2 >.

    {
      std::string error_message =
        "compute_norm(...) undefined for this element\n";
      throw OomphLibError(
        error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by oomph::AxisymmetricQAdvectionCrouzeixRaviartElement::compute_norm(), and oomph::Mesh::compute_norm().

describe_dofs()

void GeneralisedElement::describe_dofs	(	std::ostream &	out,
		const std::string &	current_string
	)		const

Function to describe the dofs of the element. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

Function to describe the dofs of the Element. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

  {
    for (unsigned i = 0; i < Ninternal_data; i++)
    {
      std::stringstream conversion;
      conversion << " of Internal Data " << i << current_string;
      std::string in(conversion.str());
      internal_data_pt(i)->describe_dofs(out, in);
    }
  }

References oomph::Data::describe_dofs(), i, internal_data_pt(), Ninternal_data, out(), and oomph::Global_string_for_annotation::string().

describe_local_dofs()

void GeneralisedElement::describe_local_dofs ( std::ostream &  out, const std::string &  current_string  ) const

virtual

Function to describe the local dofs of the element. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

Reimplemented in DistanceWrapper< ELEMENT >, oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::RefineableQSpectralPoissonElement< DIM, NNODE_1D >, oomph::SpectralElement, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::ProjectableElement< ELEMENT >, oomph::ProjectableElement< FVK_ELEMENT >, oomph::ProjectableElement< AXISYM_LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< UNSTEADY_HEAT_ELEMENT >, oomph::ProjectableElement< LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< CROUZEIX_RAVIART_ELEMENT >, oomph::ProjectableElement< HELMHOLTZ_ELEMENT >, oomph::ProjectableElement< AXISYMMETRIC_POROELASTICITY_ELEMENT >, oomph::ProjectableElement< TAYLOR_HOOD_ELEMENT >, oomph::ProjectableElement< PVD_ELEMENT >, oomph::ProjectableElement< ADR_ELEMENT >, oomph::ProjectableElement< DARCY_ELEMENT >, oomph::ProjectableElement< POISSON_ELEMENT >, oomph::ProjectableElement< FOURIER_DECOMPOSED_HELMHOLTZ_ELEMENT >, oomph::ProjectableElement< TIME_HARMONIC_LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< LINEAR_HEAT_AND_ELAST_ELEMENT >, oomph::FSIWallElement, oomph::FaceElementAsGeomObject< ELEMENT >, oomph::SolidFiniteElement, oomph::FiniteElement, oomph::ElementWithSpecificMovingNodes< ELEMENT, NODE_TYPE >, oomph::ElementWithSpecificMovingNodes< ELEMENT, SpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, PerturbedSpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, AlgebraicNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, MacroElementNodeUpdateNode >, oomph::ElementWithMovingNodes, oomph::HeatedLinearSurfaceContactElement< ELEMENT >, and oomph::ElementWithExternalElement.

  {
    // Find the number of internal and external data
    const unsigned n_internal_data = Ninternal_data;
    const unsigned n_external_data = Nexternal_data;
 
    // Now loop over the internal data and describe local equation numbers
    for (unsigned i = 0; i < n_internal_data; i++)
    {
      // Pointer to the internal data
      Data* const data_pt = internal_data_pt(i);
 
      std::stringstream conversion;
      conversion << " of Internal Data " << i << current_string;
      std::string in(conversion.str());
      data_pt->describe_dofs(out, in);
    }
 
 
    // Now loop over the external data and assign local equation numbers
    for (unsigned i = 0; i < n_external_data; i++)
    {
      // Pointer to the external data
      Data* const data_pt = external_data_pt(i);
 
      std::stringstream conversion;
      conversion << " of External Data " << i << current_string;
      std::string in(conversion.str());
      data_pt->describe_dofs(out, in);
    }
  }

References oomph::Data::describe_dofs(), external_data_pt(), i, internal_data_pt(), Nexternal_data, Ninternal_data, out(), and oomph::Global_string_for_annotation::string().

Referenced by oomph::ElementWithExternalElement::describe_local_dofs(), and oomph::FiniteElement::describe_local_dofs().

dof_pt_vector()

void oomph::GeneralisedElement::dof_pt_vector ( Vector< double * > &  dof_pt )

inline

Return the vector of pointers to dof values.

    {
      // Check that the internal storage has been set up
#ifdef PARANOID
      if (Dof_pt == 0)
      {
        std::stringstream error_stream;
        error_stream << "Internal dof array not set up in element.\n"
                     << "In order to set it up you must call\n"
                     << "   Problem::enable_store_local_dof_in_elements()\n"
                     << "before the call to Problem::assign_eqn_numbers()\n";
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Resize the vector
      dof_pt.resize(this->Ndof);
      // Loop over the vector and fill in the desired values
      for (unsigned i = 0; i < this->Ndof; ++i)
      {
        dof_pt[i] = Dof_pt[i];
      }
    }

References Dof_pt, i, Ndof, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::AssemblyHandler::dof_pt_vector().

dof_vector()

void oomph::GeneralisedElement::dof_vector ( const unsigned &  t, Vector< double > &  dof  )

inline

Return the vector of dof values at time level t.

    {
      // Check that the internal storage has been set up
#ifdef PARANOID
      if (Dof_pt == 0)
      {
        std::stringstream error_stream;
        error_stream << "Internal dof array not set up in element.\n"
                     << "In order to set it up you must call\n"
                     << "   Problem::enable_store_local_dof_in_elements()\n"
                     << "before the call to Problem::assign_eqn_numbers()\n";
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Resize the vector
      dof.resize(this->Ndof);
      // Loop over the vector and fill in the desired values
      for (unsigned i = 0; i < this->Ndof; ++i)
      {
        dof[i] = Dof_pt[i][t];
      }
    }

References Dof_pt, i, Ndof, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and plotPSD::t.

Referenced by oomph::AssemblyHandler::dof_vector().

eqn_number()

unsigned long oomph::GeneralisedElement::eqn_number ( const unsigned &  ieqn_local ) const

inline

Return the global equation number corresponding to the ieqn_local-th local equation number

    {
#ifdef RANGE_CHECKING
      if (ieqn_local >= Ndof)
      {
        std::ostringstream error_message;
        error_message << "Range Error: Equation number " << ieqn_local
                      << " is not in the range (0," << Ndof - 1 << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Eqn_number[ieqn_local];
    }

References Eqn_number, Ndof, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::NavierStokesSchurComplementPreconditioner::assemble_inv_press_and_veloc_mass_matrix_diagonal(), oomph::PressureBasedSolidLSCPreconditioner::assemble_mass_matrix_diagonal(), oomph::ElementWithMovingNodes::assign_all_generic_local_eqn_numbers(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), oomph::RefineableElement::assign_hanging_local_eqn_numbers(), assign_internal_and_external_local_eqn_numbers(), oomph::FiniteElement::assign_nodal_local_eqn_numbers(), oomph::RefineableSolidElement::assign_solid_hanging_local_eqn_numbers(), oomph::SolidFiniteElement::assign_solid_local_eqn_numbers(), oomph::AssemblyHandler::eqn_number(), oomph::ExplicitTimeStepHandler::eqn_number(), oomph::EigenProblemHandler::eqn_number(), oomph::FoldHandler::eqn_number(), oomph::PitchForkHandler::eqn_number(), oomph::HopfHandler::eqn_number(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::eqn_number(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::fill_in_generic_contribution_to_residuals(), oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::fill_in_generic_residual_contribution_fourier_decomposed_helmholtz_DtN_bc(), oomph::HelmholtzDtNBoundaryElement< ELEMENT >::fill_in_generic_residual_contribution_helmholtz_DtN_bc(), oomph::PeriodicOrbitEquations::fill_in_generic_residual_contribution_orbit(), oomph::FoldHandler::FoldHandler(), oomph::MultiPoissonEquations< DIM, NFIELDS >::get_dof_numbers_for_unknowns(), oomph::AxisymmetricLinearElasticityEquationsBase::get_dof_numbers_for_unknowns(), oomph::AxisymmetricQCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::AxisymmetricQTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::AxisymmetricTCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::AxisymmetricTTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::FSIHermiteBeamElement::get_dof_numbers_for_unknowns(), oomph::BiharmonicEquations< DIM >::get_dof_numbers_for_unknowns(), oomph::TDisplacementBasedFoepplvonKarmanElement< NNODE_1D >::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianAxisymmetricQTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianAxisymmetricTTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >::get_dof_numbers_for_unknowns(), oomph::DisplacementControlElement::get_dof_numbers_for_unknowns(), oomph::LinearElasticityEquationsBase< DIM >::get_dof_numbers_for_unknowns(), oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >::get_dof_numbers_for_unknowns(), oomph::ImposeImpenetrabilityElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::ImposeParallelOutflowElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::NetFluxControlElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::TTaylorHoodElement< DIM >::get_dof_numbers_for_unknowns(), oomph::PMLHelmholtzEquations< DIM >::get_dof_numbers_for_unknowns(), oomph::PMLHelmholtzFluxElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >::get_dof_numbers_for_unknowns(), oomph::FSIDiagHermiteShellElement::get_dof_numbers_for_unknowns(), oomph::ClampedHermiteShellBoundaryConditionElement::get_dof_numbers_for_unknowns(), oomph::PVDEquationsBase< DIM >::get_dof_numbers_for_unknowns(), oomph::PVDEquationsWithPressure< DIM >::get_dof_numbers_for_unknowns(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::BlockPrecQTaylorHoodSpaceTimeElement::get_dof_numbers_for_unknowns(), oomph::BlockPrecQTaylorHoodMixedOrderSpaceTimeElement::get_dof_numbers_for_unknowns(), oomph::QSphericalCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::QSphericalTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::TimeHarmonicFourierDecomposedLinearElasticityEquationsBase::get_dof_numbers_for_unknowns(), oomph::TimeHarmonicLinearElasticityEquationsBase< DIM >::get_dof_numbers_for_unknowns(), oomph::NavierStokesWomersleyPressureControlElement::get_dof_numbers_for_unknowns(), oomph::NetFluxControlElementForWomersleyPressureControl::get_dof_numbers_for_unknowns(), oomph::FoldHandler::get_dresiduals_dparameter(), oomph::PitchForkHandler::get_dresiduals_dparameter(), oomph::HopfHandler::get_dresiduals_dparameter(), oomph::Problem::get_inverse_mass_matrix_times_residuals(), oomph::FoldHandler::get_jacobian(), oomph::PitchForkHandler::get_jacobian(), oomph::HopfHandler::get_jacobian(), oomph::NavierStokesSchurComplementPreconditioner::get_pressure_advection_diffusion_matrix(), oomph::FoldHandler::get_residuals(), oomph::PitchForkHandler::get_residuals(), oomph::HopfHandler::get_residuals(), oomph::HopfHandler::HopfHandler(), oomph::METIS::partition_mesh(), oomph::PeriodicOrbitEquations::set_timestepper_weights(), oomph::FourierDecomposedHelmholtzDtNMesh< ELEMENT >::setup_gamma(), oomph::HelmholtzDtNMesh< ELEMENT >::setup_gamma(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), and oomph::BlockHopfLinearSolver::solve_for_two_rhs().

exclude_external_data_fd()

void oomph::GeneralisedElement::exclude_external_data_fd ( const unsigned &  i )

inline

Set the boolean flag to exclude the external datum from the the finite difference loop when computing the jacobian matrix

    {
#ifdef RANGE_CHECKING
      if (i >= Nexternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: External data " << i
                      << " is not in the range (0," << Nexternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Set the value
      Data_fd[Ninternal_data + i] = false;
    }

References Data_fd, i, Nexternal_data, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

exclude_internal_data_fd()

void oomph::GeneralisedElement::exclude_internal_data_fd ( const unsigned &  i )

inlineprotected

Set the boolean flag to exclude the internal datum from the finite difference loop when computing the jacobian matrix

    {
#ifdef RANGE_CHECKING
      if (i >= Ninternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: Internal data " << i
                      << " is not in the range (0," << Ninternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Set the value
      Data_fd[i] = false;
    }

References Data_fd, i, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

external_data_fd()

bool oomph::GeneralisedElement::external_data_fd ( const unsigned &  i ) const

inline

Return the status of the boolean flag indicating whether the external data is included in the finite difference loop

    {
#ifdef RANGE_CHECKING
      if (i >= Nexternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: Internal data " << i
                      << " is not in the range (0," << Nexternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Return the value
      return Data_fd[Ninternal_data + i];
    }

References Data_fd, i, Nexternal_data, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by fill_in_jacobian_from_external_by_fd().

external_data_pt() [1/2]

Data*& oomph::GeneralisedElement::external_data_pt ( const unsigned &  i )

inline

Return a pointer to i-th external data object.

    {
#ifdef RANGE_CHECKING
      if (i >= Nexternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: External data " << i
                      << " is not in the range (0," << Nexternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Data_pt[Ninternal_data + i];
    }

References Data_pt, i, Nexternal_data, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by add_external_data(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), assign_internal_and_external_local_eqn_numbers(), assign_local_eqn_numbers(), oomph::SolidICProblem::backup_original_state(), oomph::ImmersedRigidBodyElement::delete_external_hijacked_data(), describe_local_dofs(), HeatedCircularPenetratorElement::equilibrium_data(), oomph::ConstraintElement::ext_data_pt(), oomph::ElementElementConstraintElement::extern_data_pt(), external_local_eqn(), oomph::NavierStokesFluxControlElement< ELEMENT >::fill_in_generic_residual_contribution_fluid_traction(), oomph::NavierStokesWomersleyPressureControlElement::fill_in_generic_residual_contribution_pressure_control(), fill_in_jacobian_from_external_by_fd(), flush_external_data(), oomph::RefineableSpaceTimeNavierStokesEquations< DIM >::further_build(), oomph::NavierStokesSurfaceDragTorqueElement< ELEMENT >::get_drag_and_torque(), oomph::ElementElementConstraintElement::intern_data_pt(), oomph::ElasticallySupportedRingElement::load(), oomph::ElementElementConstraintElement::node_pt(), oomph::NavierStokesSurfaceDragTorqueElement< ELEMENT >::output(), oomph::VolumeConstraintElement::p_traded_data_pt(), oomph::SpaceTimeNavierStokesEquations< DIM >::re_st(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::re_st(), oomph::SpaceTimeNavierStokesEquations< DIM >::re_st_pt(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::re_st_pt(), oomph::PseudoBucklingRingElement::reference_pressure_pt(), oomph::RefineableNavierStokesFluxControlElement< ELEMENT >::refineable_fill_in_generic_residual_contribution_fluid_traction(), self_test(), oomph::SpaceTimeNavierStokesEquations< DIM >::st(), and oomph::SpaceTimeNavierStokesEquations< DIM >::st_pt().

external_data_pt() [2/2]

Data* const& oomph::GeneralisedElement::external_data_pt ( const unsigned &  i ) const

inline

Return a pointer to i-th external data object (const version)

    {
#ifdef RANGE_CHECKING
      if (i >= Nexternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: External data " << i
                      << " is not in the range (0," << Nexternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Data_pt[Ninternal_data + i];
    }

References Data_pt, i, Nexternal_data, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

external_local_eqn()

int oomph::GeneralisedElement::external_local_eqn ( const unsigned &  i, const unsigned &  j  )

inlineprotected

Return the local equation number corresponding to the j-th value stored at the i-th external data

    {
      // Check that the data has been allocated
#ifdef RANGE_CHECKING
      if (i >= Nexternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: External data " << i
                      << " is not in the range (0," << Nexternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      else
      {
        unsigned n_value = external_data_pt(i)->nvalue();
        if (j >= n_value)
        {
          std::ostringstream error_message;
          error_message << "Range Error: value " << j << " at internal data "
                        << i << " is not in the range (0," << n_value - 1
                        << ")";
          throw OomphLibError(error_message.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
      }
#endif
#ifdef PARANOID
      if (Data_local_eqn == 0)
      {
        throw OomphLibError(
          "External local equation numbers have not been allocated",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Return the  local equation number stored as the j-th value of the
      // i-th external data object.
      return Data_local_eqn[Ninternal_data + i][j];
    }

References Data_local_eqn, external_data_pt(), i, j, Nexternal_data, Ninternal_data, oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::DGFaceElement::add_flux_contributions(), oomph::LinearisedAxisymmetricNavierStokesEquations::assign_additional_local_eqn_numbers(), oomph::DisplacementControlElement::assign_additional_local_eqn_numbers(), oomph::ImmersedRigidBodyElement::centre_displacement_local_eqn(), oomph::LinearisedNavierStokesEquations::eigenvalue_local_eqn(), oomph::ConstraintElement::ext_eqn(), oomph::ElementElementConstraintElement::extern_data_eqn(), oomph::ConstraintElement::fill_in_contribution_to_residuals(), HeatedCircularPenetratorElement::fill_in_contribution_to_residuals(), oomph::FluxConstraint::fill_in_contribution_to_residuals(), oomph::FoepplvonKarmanEquations::fill_in_contribution_to_residuals(), oomph::ElasticallySupportedRingElement::fill_in_generic_residual_contribution(), oomph::NavierStokesFluxControlElement< ELEMENT >::fill_in_generic_residual_contribution_fluid_traction(), oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::fill_in_generic_residual_contribution_fourier_decomposed_helmholtz_DtN_bc(), oomph::HelmholtzDtNBoundaryElement< ELEMENT >::fill_in_generic_residual_contribution_helmholtz_DtN_bc(), oomph::NavierStokesWomersleyPressureControlElement::fill_in_generic_residual_contribution_pressure_control(), fill_in_jacobian_from_external_by_fd(), oomph::ElementElementConstraintElement::intern_data_eqn(), oomph::ElementElementConstraintElement::node_eqn(), oomph::FluidInterfaceElement::pext_local_eqn(), oomph::VolumeConstraintElement::ptraded_local_eqn(), oomph::VolumeConstraintBoundingElement::ptraded_local_eqn(), oomph::PseudoBucklingRingElement::reference_pressure_local_eqn(), and oomph::RefineableNavierStokesFluxControlElement< ELEMENT >::refineable_fill_in_generic_residual_contribution_fluid_traction().

fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter()

void GeneralisedElement::fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter ( double *const &  parameter_pt, Vector< double > &  dres_dparam, DenseMatrix< double > &  djac_dparam, DenseMatrix< double > &  dmass_matrix_dparam  )

protectedvirtual

Add the elemental contribution to the derivative of the jacobian matrix, mass matrix and the residuals vector with respect to the passed parameter. Note that this function should NOT initialise any entries. It must be called after the residuals vector and matrices have been initialised to zero.

Add the elemental contribution to the derivative of the jacobian matrix, mass matrix and the residuals vector with respect to a parameter. 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.

Reimplemented in oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::NavierStokesEquations< DIM >, oomph::NavierStokesEquations< 2 >, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >, oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations, and oomph::AxisymmetricNavierStokesEquations.

  {
    std::string error_message =
      "Empty fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter() "
      "has";
    error_message += " been called.\n";
    error_message +=
      "This function is called from the default implementation of\n";
    error_message += "get_djacobian_and_dmass_matrix_dparameter();\n";
    error_message +=
      "and must calculate the residuals vector and mass and jacobian matrices ";
    error_message += "without initialising any of their entries.\n\n";
 
    error_message +=
      "If you do not wish to use these defaults, you must overload\n";
    error_message += "get_djacobian_and_dmass_matrix_dparameter(), which must "
                     "initialise the\n";
    error_message += "entries of the returned vector and  matrices to zero.\n";
 
 
    error_message +=
      "This function is intended for use instead of the default (global) \n";
    error_message +=
      "finite-difference routine when analytic expressions are to be used\n";
    error_message += "in continuation and bifurcation tracking problems.\n\n";
    error_message += "This function is only called when the function\n";
    error_message +=
      "Problem::set_analytic_dparameter() has been called in the driver code\n";
 
 
    throw OomphLibError(error_message,
                        "GeneralisedElement::fill_in_contribution_to_djacobian_"
                        "and_dmass_matrix_dparameter()",
                        OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by get_djacobian_and_dmass_matrix_dparameter().

fill_in_contribution_to_djacobian_dparameter()

void GeneralisedElement::fill_in_contribution_to_djacobian_dparameter ( double *const &  parameter_pt, Vector< double > &  dres_dparam, DenseMatrix< double > &  djac_dparam  )

protectedvirtual

Add the elemental contribution to the derivatives of the elemental Jacobian matrix and residuals with respect to a parameter. This function should NOT initialise any entries and must be called after the entries have been initialised to zero The default implementation is to use finite differences to calculate the derivatives.

Reimplemented in oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::NavierStokesEquations< DIM >, oomph::NavierStokesEquations< 2 >, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >, oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations, oomph::AxisymmetricNavierStokesEquations, and GelfandBratuElement< NNODE_1D >.

  {
    std::string error_message =
      "Empty fill_in_contribution_to_djacobian_dparameter() has been ";
    error_message += "called.\n";
    error_message +=
      "This function is called from the default implementation of\n";
    error_message += "get_djacobian_dparameter();\n";
    error_message +=
      "and must calculate the derivatives of residuals vector and jacobian ";
    error_message += "matrix\n";
    error_message += "with respect to the passed parameter ";
    error_message += "without initialising any values.\n\n";
 
    error_message +=
      "If you do not wish to use these defaults, you must overload\n";
    error_message +=
      "get_djacobian_dparameter(), which must initialise the entries\n";
    error_message += "of the returned vector and matrix to zero.\n\n";
 
    error_message +=
      "This function is intended for use instead of the default (global) \n";
    error_message +=
      "finite-difference routine when analytic expressions are to be used\n";
    error_message += "in continuation and bifurcation tracking problems.\n\n";
    error_message += "This function is only called when the function\n";
    error_message +=
      "Problem::set_analytic_dparameter() has been called in the driver code\n";
 
 
    throw OomphLibError(
      error_message,
      "GeneralisedElement::fill_in_contribution_to_djacobian_dparameter()",
      OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by get_djacobian_dparameter().

fill_in_contribution_to_dresiduals_dparameter()

void GeneralisedElement::fill_in_contribution_to_dresiduals_dparameter ( double *const &  parameter_pt, Vector< double > &  dres_dparam  )

protectedvirtual

Add the elemental contribution to the derivatives of the residuals with respect to a parameter. This function should NOT initialise any entries and must be called after the entries have been initialised to zero The default implementation is to use finite differences to calculate the derivatives.

Add the elemental contribution to the derivatives of the residuals with respect to a parameter. This function should NOT initialise any entries and must be called after the entries have been initialised to zero The default implementation is deliberately broken

Reimplemented in oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::NavierStokesEquations< DIM >, oomph::NavierStokesEquations< 2 >, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >, oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations, oomph::AxisymmetricNavierStokesEquations, and GelfandBratuElement< NNODE_1D >.

  {
    std::string error_message =
      "Empty fill_in_contribution_to_dresiduals_dparameter() has been ";
    error_message += "called.\n";
    error_message +=
      "This function is called from the default implementation of\n";
    error_message += "get_dresiduals_dparameter();\n";
    error_message += "and must calculate the derivatives of the residuals "
                     "vector with respect\n";
    error_message += "to the passed parameter ";
    error_message += "without initialising any values.\n\n";
 
    error_message +=
      "If you do not wish to use these defaults, you must overload\n";
    error_message +=
      "get_dresiduals_dparameter(), which must initialise the entries\n";
    error_message += "of the returned vector to zero.\n";
 
    error_message +=
      "This function is intended for use instead of the default (global) \n";
    error_message +=
      "finite-difference routine when analytic expressions are to be used\n";
    error_message += "in continuation and bifurcation tracking problems.\n\n";
    error_message += "This function is only called when the function\n";
    error_message +=
      "Problem::set_analytic_dparameter() has been called in the driver code\n";
 
    throw OomphLibError(
      error_message,
      "GeneralisedElement::fill_in_contribution_to_dresiduals_dparameter()",
      OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by get_dresiduals_dparameter().

fill_in_contribution_to_hessian_vector_products()

void GeneralisedElement::fill_in_contribution_to_hessian_vector_products ( Vector< double > const &  Y, DenseMatrix< double > const &  C, DenseMatrix< double > &  product  )

protectedvirtual

Fill in contribution to the product of the Hessian (derivative of Jacobian with respect to all variables) an eigenvector, Y, and other specified vectors, C (d(J_{ij})/d u_{k}) Y_{j} C_{k}

Fill in contribution to the product of the Hessian (derivative of Jacobian with respect to all variables) an eigenvector, Y, and other specified vectors, C (d(J_{ij})/d u_{k}) Y_{j} C_{k} At the moment the dof pointer is passed in to enable easy calculation of finite difference default

Reimplemented in oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::NavierStokesEquations< DIM >, oomph::NavierStokesEquations< 2 >, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >, oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations, oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations, oomph::RefineableAxisymmetricNavierStokesEquations, and oomph::AxisymmetricNavierStokesEquations.

  {
    std::string error_message =
      "Empty fill_in_contribution_to_hessian_vector_products() has been ";
    error_message += "called.\n";
    error_message +=
      "This function is called from the default implementation of\n";
    error_message += "get_hessian_vector_products(); ";
    error_message += " and must calculate the products \n";
    error_message += "of the hessian matrix with the (global) ";
    error_message += "vectors Y and C\n";
    error_message += "without initialising any values.\n\n";
 
    error_message +=
      "If you do not wish to use these defaults, you must overload\n";
    error_message +=
      "get_hessian_vector_products(), which must initialise the entries\n";
    error_message += "of the returned vector to zero.\n\n";
 
    error_message +=
      "This function is intended for use instead of the default (global) \n";
    error_message +=
      "finite-difference routine when analytic expressions are to be used.\n";
    error_message += "This function is only called when the function\n";
    error_message += "Problem::set_analytic_hessian_products() has been called "
                     "in the driver code\n";
 
    throw OomphLibError(
      error_message,
      "GeneralisedElement::fill_in_contribution_to_hessian_vector_product()",
      OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by get_hessian_vector_products().

fill_in_contribution_to_inner_product_vectors()

void GeneralisedElement::fill_in_contribution_to_inner_product_vectors ( Vector< unsigned > const &  history_index, Vector< Vector< double >> &  inner_product_vector  )

protectedvirtual

Fill in the contributions to the vectors that when taken as dot product with other history values give the inner product over the element

  {
    std::string error_message =
      "Empty fill_in_contribution_to_inner_product_vectors() has been "
      "called.\n";
    error_message +=
      "This function is called from the default implementation of\n";
    error_message += "get_inner_product_vectors(); ";
    error_message += " and must calculate the vectors \n";
    error_message += "corresponding to the input history values\n ";
    error_message +=
      "that when multiplied by other vectors of history values\n";
    error_message += "return the appropriate dot products.\n\n";
    error_message += "The output vectors must not be initialised.\n\n";
 
    error_message +=
      "If you do not wish to use these defaults, you must overload\n";
    error_message +=
      "get_inner_products(), which must initialise the entries\n";
    error_message += "of the returned vector to zero.\n\n";
 
    throw OomphLibError(
      error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by get_inner_product_vectors().

fill_in_contribution_to_inner_products()

void GeneralisedElement::fill_in_contribution_to_inner_products ( Vector< std::pair< unsigned, unsigned >> const &  history_index, Vector< double > &  inner_product  )

protectedvirtual

Fill in the contribution to the inner products between given pairs of history values

  {
    std::string error_message =
      "Empty fill_in_contribution_to_inner_products() has been called.\n";
    error_message +=
      "This function is called from the default implementation of\n";
    error_message += "get_inner_products();\n ";
    error_message += "It must calculate the inner products over the element\n";
    error_message += "of given pairs of history values\n";
    error_message += "without initialision of the output vector.\n\n";
 
    error_message +=
      "If you do not wish to use these defaults, you must overload\n";
    error_message +=
      "get_inner_products(), which must initialise the entries\n";
    error_message += "of the returned vector to zero.\n\n";
 
    throw OomphLibError(
      error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by get_inner_products().

fill_in_contribution_to_jacobian()

virtual void oomph::GeneralisedElement::fill_in_contribution_to_jacobian ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian  )

inlineprotectedvirtual

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

Reimplemented in oomph::NodeNodeMortaringElement, oomph::NodeElementSolidOnlyMortaringElement, oomph::NavierStokesWomersleyPressureControlElement, oomph::NavierStokesImpedanceTractionElement< BULK_NAVIER_STOKES_ELEMENT, WOMERSLEY_ELEMENT, DIM >, oomph::WomersleyEquations< DIM >, oomph::UnsteadyHeatFluxElement< ELEMENT >, oomph::UnsteadyHeatEquations< DIM >, oomph::UnsteadyHeatEquations< 2 >, oomph::TimeHarmonicLinearElasticityTractionElement< ELEMENT >, oomph::TimeHarmonicLinearElasticityEquations< DIM >, oomph::TimeHarmonicFourierDecomposedLinearElasticityTractionElement< ELEMENT >, oomph::TimeHarmonicFourierDecomposedLinearElasticityEquations, oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >, oomph::SteadyAxisymAdvectionDiffusionEquations, oomph::SphericalNavierStokesEquations, oomph::SphericalAdvectionDiffusionFluxElement< ELEMENT >, oomph::SphericalAdvectionDiffusionEquations, oomph::SpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< 2 >, oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< 2 >, oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::FpPressureAdvDiffRobinBCMixedOrderSpaceTimeElement< ELEMENT >, oomph::RefineableNavierStokesMixedOrderSpaceTimeTractionElement< ELEMENT >, oomph::NavierStokesMixedOrderSpaceTimeTractionElement< ELEMENT >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::FpPressureAdvDiffRobinBCSpaceTimeElement< ELEMENT >, oomph::RefineableNavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::NavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::FpPressureAdvDiffRobinBCSpaceTimeElement< ELEMENT >, oomph::RefineableNavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::NavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::FpPressureAdvDiffRobinBCSpaceTimeElement< ELEMENT >, oomph::RefineableNavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::NavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::RefineableFSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::RefineableFSISolidTractionElement< ELEMENT, DIM >, oomph::FSISolidTractionElement< ELEMENT, DIM >, oomph::RefineableSolidTractionElement< ELEMENT >, oomph::SolidTractionElement< ELEMENT >, oomph::PVDEquationsWithPressure< DIM >, oomph::PVDEquations< DIM >, oomph::FSIDiagHermiteShellElement, oomph::KirchhoffLoveShellEquations, oomph::ImmersedRigidBodyElement, oomph::PoroelasticityFaceElement< ELEMENT >, oomph::PoroelasticityEquations< DIM >, oomph::PoroelasticityEquations< 2 >, oomph::PolarStressIntegralElement< ELEMENT >, oomph::PolarNavierStokesEquations, oomph::PolarNavierStokesTractionElement< ELEMENT >, oomph::PoissonFluxElement< ELEMENT >, oomph::PoissonEquations< DIM >, oomph::PoissonEquations< 1 >, oomph::PoissonEquations< 2 >, oomph::PoissonEquations< 3 >, oomph::PMLTimeHarmonicLinearElasticityTractionElement< ELEMENT >, oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >, oomph::PMLHelmholtzFluxElement< ELEMENT >, oomph::PMLHelmholtzEquations< DIM >, oomph::PMLFourierDecomposedHelmholtzFluxElement< ELEMENT >, oomph::PMLFourierDecomposedHelmholtzEquations, oomph::ODEElement, oomph::RefineableNavierStokesFluxControlElement< ELEMENT >, oomph::NavierStokesFluxControlElement< ELEMENT >, oomph::NetFluxControlElement< ELEMENT >, oomph::NavierStokesEquations< DIM >, oomph::NavierStokesEquations< 2 >, oomph::FpPressureAdvDiffRobinBCElement< ELEMENT >, oomph::ImposeParallelOutflowElement< ELEMENT >, oomph::ImposeImpenetrabilityElement< ELEMENT >, oomph::RefineableNavierStokesTractionElement< ELEMENT >, oomph::NavierStokesTractionElement< ELEMENT >, oomph::PMLHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >, oomph::TimeHarmonicLinElastLoadedByPMLHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >, oomph::AdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >, oomph::NavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >, oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >, oomph::RefineableNavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >, oomph::HelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >, oomph::TimeHarmonicLinElastLoadedByHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >, oomph::FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >, oomph::FourierDecomposedTimeHarmonicLinElastLoadedByHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >, oomph::RefineableBuoyantQCrouzeixRaviartElement< DIM >, oomph::BuoyantQCrouzeixRaviartElement< DIM >, RefineableLinearisedQCrouzeixRaviartMultiDomainElement, RefineableLinearisedQTaylorHoodMultiDomainElement, LinearisedQCrouzeixRaviartMultiDomainElement, LinearisedQTaylorHoodMultiDomainElement, oomph::LinearisedNavierStokesEigenfunctionNormalisationElement, RefineableLinearisedAxisymmetricQCrouzeixRaviartMultiDomainElement, RefineableLinearisedAxisymmetricQTaylorHoodMultiDomainElement, LinearisedAxisymmetricQCrouzeixRaviartMultiDomainElement, LinearisedAxisymmetricQTaylorHoodMultiDomainElement, oomph::LinearisedAxisymmetricNavierStokesEquations, oomph::LinearWaveFluxElement< ELEMENT >, oomph::LinearWaveEquations< DIM >, oomph::LinearElasticityTractionElement< ELEMENT >, oomph::LinearElasticityEquations< DIM >, oomph::HelmholtzFluxElement< ELEMENT >, oomph::HelmholtzEquations< DIM >, oomph::HelmholtzDtNBoundaryElement< ELEMENT >, oomph::HelmholtzAbsorbingBCElement< ELEMENT >, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::ProjectableElement< ELEMENT >, oomph::ProjectableElement< FVK_ELEMENT >, oomph::ProjectableElement< AXISYM_LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< UNSTEADY_HEAT_ELEMENT >, oomph::ProjectableElement< LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< CROUZEIX_RAVIART_ELEMENT >, oomph::ProjectableElement< HELMHOLTZ_ELEMENT >, oomph::ProjectableElement< AXISYMMETRIC_POROELASTICITY_ELEMENT >, oomph::ProjectableElement< TAYLOR_HOOD_ELEMENT >, oomph::ProjectableElement< PVD_ELEMENT >, oomph::ProjectableElement< ADR_ELEMENT >, oomph::ProjectableElement< DARCY_ELEMENT >, oomph::ProjectableElement< POISSON_ELEMENT >, oomph::ProjectableElement< FOURIER_DECOMPOSED_HELMHOLTZ_ELEMENT >, oomph::ProjectableElement< TIME_HARMONIC_LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< LINEAR_HEAT_AND_ELAST_ELEMENT >, oomph::FSIWallElement, oomph::FaceElementAsGeomObject< ELEMENT >, oomph::SolidFiniteElement, oomph::FiniteElement, oomph::ElementWithExternalElement, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >, oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations, oomph::FourierDecomposedHelmholtzFluxElement< ELEMENT >, oomph::FourierDecomposedHelmholtzEquations, oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >, oomph::FoepplvonKarmanVolumeConstraintElement< ELEMENT, MESH >, oomph::FoepplvonKarmanVolumeConstraintElement< ELEMENT, RefineableTriangleMesh >, oomph::FluxTransportEquations< DIM >, oomph::ElasticLineFluidInterfaceBoundingElement< ELEMENT >, oomph::ElasticPointFluidInterfaceBoundingElement< ELEMENT >, oomph::ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, SurfaceDerivatives, ELEMENT >, oomph::ElasticUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, AxisymmetricDerivatives, ELEMENT >, oomph::ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, AxisymmetricDerivatives, ELEMENT >, oomph::ElasticUpdateFluidInterfaceElement< SolubleSurfactantTransportInterfaceElement, LineDerivatives, ELEMENT >, oomph::ElasticUpdateFluidInterfaceElement< FluidInterfaceElement, LineDerivatives, ELEMENT >, oomph::SpineLineFluidInterfaceBoundingElement< ELEMENT >, oomph::SpinePointFluidInterfaceBoundingElement< ELEMENT >, oomph::SpineUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >, oomph::SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, LineDerivatives, ELEMENT >, oomph::SpineUpdateFluidInterfaceElement< FluidInterfaceElement, SurfaceDerivatives, ELEMENT >, oomph::SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, AxisymmetricDerivatives, ELEMENT >, oomph::SpineUpdateFluidInterfaceElement< SurfactantTransportInterfaceElement, SurfaceDerivatives, ELEMENT >, oomph::SpineUpdateFluidInterfaceElement< FluidInterfaceElement, AxisymmetricDerivatives, ELEMENT >, oomph::SpineUpdateFluidInterfaceElement< SolubleSurfactantTransportInterfaceElement, LineDerivatives, ELEMENT >, oomph::SpineUpdateFluidInterfaceElement< FluidInterfaceElement, LineDerivatives, ELEMENT >, oomph::SpineSurfaceVolumeConstraintBoundingElement< ELEMENT >, oomph::ElasticSurfaceVolumeConstraintBoundingElement< ELEMENT >, oomph::SpineAxisymmetricVolumeConstraintBoundingElement< ELEMENT >, oomph::ElasticAxisymmetricVolumeConstraintBoundingElement< ELEMENT >, oomph::SpineLineVolumeConstraintBoundingElement< ELEMENT >, oomph::ElasticLineVolumeConstraintBoundingElement< ELEMENT >, oomph::VolumeConstraintElement, oomph::DarcyFaceElement< ELEMENT >, oomph::BiharmonicFluidBoundaryElement, oomph::BiharmonicFluxElement< DIM >, oomph::FSIHermiteBeamElement, oomph::KirchhoffLoveBeamEquations, oomph::AxisymmetricSolidTractionElement< ELEMENT >, oomph::AxisymmetricPVDEquationsWithPressure, oomph::AxisymmetricPVDEquations, oomph::FSILinearisedAxisymPoroelasticTractionElement< POROELASTICITY_BULK_ELEMENT, NAVIER_STOKES_BULK_ELEMENT >, oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >, oomph::AxisymmetricPoroelasticityTractionElement< POROELASTICITY_BULK_ELEMENT >, oomph::AxisymmetricPoroelasticityEquations, oomph::AxisymmetricNavierStokesEquations, oomph::LinearisedFSIAxisymmetricNStNoSlipBCElementElement< FLUID_BULK_ELEMENT, SOLID_BULK_ELEMENT >, oomph::AxisymmetricNavierStokesTractionElement< ELEMENT >, oomph::FSIAxisymmetricLinearElasticityTractionElement< ELASTICITY_BULK_ELEMENT, NAVIER_STOKES_BULK_ELEMENT >, oomph::AxisymmetricLinearElasticityTractionElement< ELEMENT >, oomph::AxisymmetricLinearElasticityEquations, oomph::AxisymAdvectionDiffusionEquations, oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >, oomph::GeneralisedAdvectionDiffusionEquations< DIM >, oomph::GeneralisedAdvectionDiffusionEquations< 2 >, oomph::AdvectionDiffusionFluxElement< ELEMENT >, oomph::AdvectionDiffusionEquations< DIM >, oomph::AdvectionDiffusionEquations< 2 >, oomph::PolarStreamfunctionEquations, oomph::PolarStreamfunctionTractionElement< ELEMENT >, oomph::FluxConstraint, ModalPRefineableQPoissonElement< DIM >, ModalPoissonEquations< DIM >, oomph::IMRODEElement, SpineGravityTractionElement< ELEMENT >, FixSpineHeightElement, oomph::SpinePointMarangoniSurfactantFluidInterfaceBoundingElement< ELEMENT >, SlavePositionPointElement, DependentPositionPointElement, oomph::RefineableDoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, QThermalPVDElement< DIM >, oomph::RefineableBuoyantQSphericalCrouzeixRaviartElement, oomph::SpineLineMarangoniSurfactantFluidInterfaceElement< ELEMENT >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::SpineAxisymmetricMarangoniSurfactantFluidInterfaceElement< ELEMENT >, oomph::AxisymmetricQAdvectionCrouzeixRaviartElement, oomph::FixedVolumeSpineLineMarangoniFluidInterfaceElement< ELEMENT >, oomph::SpineLineMarangoniFluidInterfaceElement< ELEMENT >, oomph::SpineLineMarangoniSurfactantFluidInterfaceElement< ELEMENT >, QAdvectionDiffusionElementWithExternalElement< DIM >, QCrouzeixRaviartElementWithTwoExternalElement< DIM >, RefineableQAdvectionDiffusionElementWithExternalElement< DIM >, RefineableQCrouzeixRaviartElementWithTwoExternalElement< DIM >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, QAxisymAdvectionDiffusionElementWithExternalElement, QAxisymCrouzeixRaviartElementWithExternalElement, RefineableQAxisymAdvectionDiffusionBoussinesqElement, RefineableQAxisymCrouzeixRaviartBoussinesqElement, oomph::RefineableBuoyantQAxisymCrouzeixRaviartElement, QAxisymAdvectionDiffusionElementWithExternalElement, QAxisymCrouzeixRaviartElementWithExternalElement, RefineableQAxisymAdvectionDiffusionBoussinesqElement, RefineableQAxisymCrouzeixRaviartBoussinesqElement, oomph::RefineableBuoyantQAxisymCrouzeixRaviartElement, RefineableQAdvectionDiffusionElementWithExternalElement< DIM >, RefineableQCrouzeixRaviartElementWithExternalElement< DIM >, RefineableBuoyantQCrouzeixRaviartElement< DIM >, SSPorousChannelEquations, LinearisedAxisymmetricQCrouzeixRaviartMultiDomainElement, oomph::PerturbedSpineLinearisedAxisymmetricFluidInterfaceElement< ELEMENT >, oomph::LinearisedAxisymmetricNavierStokesEquations, oomph::MultiPoissonEquations< DIM, NFIELDS >, FluxConstraint, FixSpineHeightElement, SpineGravityTractionElement< ELEMENT >, oomph::HomogenisedLinearElasticityEquations< DIM >, oomph::HeatedPenetratorFluxElement< ELEMENT >, oomph::HeatedLinearSurfaceContactElement< ELEMENT >, oomph::TLinearHeatAndElasticityElement< DIM, NNODE_1D >, SSPorousChannelEquations, ABCElement, PredatorPreyElement, GelfandBratuElement< NNODE_1D >, MyNavierStokesElement, RefineableLinearisedAxisymmetricQCrouzeixRaviartMultiDomainElement, RefineableLinearisedAxisymmetricQTaylorHoodMultiDomainElement, LinearisedAxisymmetricQCrouzeixRaviartMultiDomainElement, LinearisedAxisymmetricQTaylorHoodMultiDomainElement, oomph::LinearisedAxisymmetricNavierStokesEquations, MortaringHelpers::PointElementWithExternalElement, oomph::BiharmonicEquations< DIM >, oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >, oomph::SingularNavierStokesSolutionElement< ELEMENT >, and DistanceWrapper< ELEMENT >.

    {
      // Add the contribution to the residuals
      fill_in_contribution_to_residuals(residuals);
      // Allocate storage for the full residuals (residuals of entire element)
      Vector<double> full_residuals(Ndof);
      // Get the residuals for the entire element
      get_residuals(full_residuals);
      // Calculate the contributions from the internal dofs
      //(finite-difference the lot by default)
      fill_in_jacobian_from_internal_by_fd(full_residuals, jacobian, true);
      // Calculate the contributions from the external dofs
      //(finite-difference the lot by default)
      fill_in_jacobian_from_external_by_fd(full_residuals, jacobian, true);
    }

References fill_in_contribution_to_residuals(), fill_in_jacobian_from_external_by_fd(), fill_in_jacobian_from_internal_by_fd(), get_residuals(), and Ndof.

Referenced by get_jacobian().

fill_in_contribution_to_jacobian_and_mass_matrix()

void GeneralisedElement::fill_in_contribution_to_jacobian_and_mass_matrix ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian, DenseMatrix< double > &  mass_matrix  )

protectedvirtual

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.

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.

Reimplemented in oomph::SphericalNavierStokesEquations, oomph::SphericalAdvectionDiffusionEquations, oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::PVDEquationsWithPressure< DIM >, oomph::PolarStressIntegralElement< ELEMENT >, oomph::PolarNavierStokesEquations, oomph::PolarNavierStokesTractionElement< ELEMENT >, oomph::NavierStokesEquations< DIM >, oomph::NavierStokesEquations< 2 >, oomph::AdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >, oomph::NavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >, oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >, oomph::RefineableNavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >, oomph::RefineableBuoyantQCrouzeixRaviartElement< DIM >, oomph::BuoyantQCrouzeixRaviartElement< DIM >, oomph::LinearisedNavierStokesEigenfunctionNormalisationElement, oomph::LinearisedAxisymmetricNavierStokesEquations, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >, oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations, oomph::DisplacementBasedFoepplvonKarmanEquations, oomph::FluxTransportEquations< DIM >, oomph::SurfactantTransportInterfaceElement, oomph::VolumeConstraintElement, oomph::AxisymmetricNavierStokesEquations, oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >, oomph::GeneralisedAdvectionDiffusionEquations< DIM >, oomph::GeneralisedAdvectionDiffusionEquations< 2 >, oomph::AdvectionDiffusionEquations< DIM >, oomph::AdvectionDiffusionEquations< 2 >, oomph::PolarStreamfunctionTractionElement< ELEMENT >, oomph::FluxConstraint, oomph::SolubleSurfactantTransportInterfaceElement, oomph::RefineableDoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::RefineableBuoyantQSphericalCrouzeixRaviartElement, oomph::SpineLineMarangoniSurfactantFluidInterfaceElement< ELEMENT >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::SpineAxisymmetricMarangoniSurfactantFluidInterfaceElement< ELEMENT >, oomph::AxisymmetricQAdvectionCrouzeixRaviartElement, oomph::SpineLineMarangoniFluidInterfaceElement< ELEMENT >, oomph::SpineLineMarangoniSurfactantFluidInterfaceElement< ELEMENT >, QAdvectionDiffusionElementWithExternalElement< DIM >, QCrouzeixRaviartElementWithTwoExternalElement< DIM >, RefineableQAdvectionDiffusionElementWithExternalElement< DIM >, RefineableQCrouzeixRaviartElementWithTwoExternalElement< DIM >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, QAxisymAdvectionDiffusionElementWithExternalElement, QAxisymCrouzeixRaviartElementWithExternalElement, RefineableQAxisymAdvectionDiffusionBoussinesqElement, RefineableQAxisymCrouzeixRaviartBoussinesqElement, oomph::RefineableBuoyantQAxisymCrouzeixRaviartElement, QAxisymAdvectionDiffusionElementWithExternalElement, QAxisymCrouzeixRaviartElementWithExternalElement, RefineableQAxisymAdvectionDiffusionBoussinesqElement, RefineableQAxisymCrouzeixRaviartBoussinesqElement, oomph::RefineableBuoyantQAxisymCrouzeixRaviartElement, RefineableQAdvectionDiffusionElementWithExternalElement< DIM >, RefineableQCrouzeixRaviartElementWithExternalElement< DIM >, RefineableBuoyantQCrouzeixRaviartElement< DIM >, HarmonicEquations, oomph::LinearisedAxisymmetricNavierStokesEquations, OrrSommerfeldEquations< DIM >, HarmonicEquations, ComplexHarmonicEquations, ABCElement, PredatorPreyElement, and oomph::LinearisedAxisymmetricNavierStokesEquations.

  {
    std::string error_message =
      "Empty fill_in_contribution_to_jacobian_and_mass_matrix() has been ";
    error_message += "called.\n";
    error_message +=
      "This function is called from the default implementation of\n";
    error_message += "get_jacobian_and_mass_matrix();\n";
    error_message +=
      "and must calculate the residuals vector and mass and jacobian matrices ";
    error_message += "without initialising any of their entries.\n\n";
 
    error_message +=
      "If you do not wish to use these defaults, you must overload\n";
    error_message +=
      "get_jacobian_and_mass_matrix(), which must initialise the entries\n";
    error_message +=
      "of the residuals vector, jacobian and mass matrix to zero.\n";
 
    throw OomphLibError(
      error_message,
      "GeneralisedElement::fill_in_contribution_to_jacobian_and_mass_matrix()",
      OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by RefineableBuoyantQCrouzeixRaviartElement< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), RefineableQCrouzeixRaviartElementWithExternalElement< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::RefineableBuoyantQAxisymCrouzeixRaviartElement::fill_in_contribution_to_jacobian_and_mass_matrix(), RefineableQAxisymCrouzeixRaviartBoussinesqElement::fill_in_contribution_to_jacobian_and_mass_matrix(), RefineableQAxisymAdvectionDiffusionBoussinesqElement::fill_in_contribution_to_jacobian_and_mass_matrix(), QAxisymCrouzeixRaviartElementWithExternalElement::fill_in_contribution_to_jacobian_and_mass_matrix(), QAxisymAdvectionDiffusionElementWithExternalElement::fill_in_contribution_to_jacobian_and_mass_matrix(), RefineableQCrouzeixRaviartElementWithTwoExternalElement< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), RefineableQAdvectionDiffusionElementWithExternalElement< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), QCrouzeixRaviartElementWithTwoExternalElement< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), QAdvectionDiffusionElementWithExternalElement< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::AxisymmetricQAdvectionCrouzeixRaviartElement::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::RefineableBuoyantQCrouzeixRaviartElement< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::RefineableNavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::NavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::AdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >::fill_in_contribution_to_jacobian_and_mass_matrix(), and get_jacobian_and_mass_matrix().

fill_in_contribution_to_mass_matrix()

void GeneralisedElement::fill_in_contribution_to_mass_matrix ( Vector< double > &  residuals, DenseMatrix< double > &  mass_matrix  )

protectedvirtual

Add the elemental contribution to the mass matrix matrix. and the residuals vector. Note that this function should 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

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.

Reimplemented in oomph::ODEElement, and oomph::FluxTransportEquations< DIM >.

  {
    std::string error_message =
      "Empty fill_in_contribution_to_mass_matrix() has been called.\n";
    error_message +=
      "This function is called from the default implementation of\n";
    error_message += "get_mass_matrix();\n";
    error_message += "and must calculate the residuals vector and mass matrix ";
    error_message += "without initialising any of their entries.\n\n";
 
    error_message +=
      "If you do not wish to use these defaults, you must overload\n";
    error_message += "get_mass_matrix(), which must initialise the entries\n";
    error_message += "of the residuals vector and mass matrix to zero.\n";
 
    throw OomphLibError(
      error_message,
      "GeneralisedElement::fill_in_contribution_to_mass_matrix()",
      OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by oomph::DGElement::get_inverse_mass_matrix_times_residuals(), get_mass_matrix(), and oomph::DGElement::pre_compute_mass_matrix().

fill_in_contribution_to_residuals()

virtual void oomph::GeneralisedElement::fill_in_contribution_to_residuals ( Vector< double > &  residuals )

inlineprotectedvirtual

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.

Reimplemented in oomph::NodeNodeMortaringElement, oomph::NodeElementSolidOnlyMortaringElement, oomph::HeightControlElement, oomph::YoungLaplaceEquations, oomph::YoungLaplaceContactAngleElement< ELEMENT >, oomph::RefineableYoungLaplaceEquations, oomph::NavierStokesWomersleyPressureControlElement, oomph::NavierStokesImpedanceTractionElement< BULK_NAVIER_STOKES_ELEMENT, WOMERSLEY_ELEMENT, DIM >, oomph::WomersleyEquations< DIM >, oomph::UnsteadyHeatFluxElement< ELEMENT >, oomph::UnsteadyHeatEquations< DIM >, oomph::UnsteadyHeatEquations< 2 >, oomph::TimeHarmonicLinearElasticityTractionElement< ELEMENT >, oomph::TimeHarmonicLinearElasticityEquations< DIM >, oomph::TimeHarmonicFourierDecomposedLinearElasticityTractionElement< ELEMENT >, oomph::TimeHarmonicFourierDecomposedLinearElasticityEquations, oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >, oomph::SteadyAxisymAdvectionDiffusionEquations, oomph::SphericalNavierStokesEquations, oomph::SphericalAdvectionDiffusionFluxElement< ELEMENT >, oomph::SphericalAdvectionDiffusionEquations, oomph::SpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< 2 >, oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< 2 >, oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >, oomph::FpPressureAdvDiffRobinBCMixedOrderSpaceTimeElement< ELEMENT >, oomph::RefineableNavierStokesMixedOrderSpaceTimeTractionElement< ELEMENT >, oomph::NavierStokesMixedOrderSpaceTimeTractionElement< ELEMENT >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::FpPressureAdvDiffRobinBCSpaceTimeElement< ELEMENT >, oomph::RefineableNavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::NavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::FpPressureAdvDiffRobinBCSpaceTimeElement< ELEMENT >, oomph::RefineableNavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::NavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::SpaceTimeNavierStokesEquations< DIM >, oomph::FpPressureAdvDiffRobinBCSpaceTimeElement< ELEMENT >, oomph::RefineableNavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::NavierStokesSpaceTimeTractionElement< ELEMENT >, oomph::RefineableFSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::RefineableSolidTractionElement< ELEMENT >, oomph::SolidTractionElement< ELEMENT >, oomph::PVDEquationsWithPressure< DIM >, oomph::PVDEquations< DIM >, oomph::ClampedHermiteShellBoundaryConditionElement, oomph::KirchhoffLoveShellEquations, oomph::ImmersedRigidBodyElement, oomph::PoroelasticityFaceElement< ELEMENT >, oomph::PoroelasticityEquations< DIM >, oomph::PoroelasticityEquations< 2 >, oomph::PolarStressIntegralElement< ELEMENT >, oomph::PolarNavierStokesEquations, oomph::PolarNavierStokesTractionElement< ELEMENT >, oomph::PoissonFluxElement< ELEMENT >, oomph::PoissonEquations< DIM >, oomph::PoissonEquations< 1 >, oomph::PoissonEquations< 2 >, oomph::PoissonEquations< 3 >, oomph::PMLTimeHarmonicLinearElasticityTractionElement< ELEMENT >, oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >, oomph::PMLHelmholtzFluxElement< ELEMENT >, oomph::PMLHelmholtzEquations< DIM >, oomph::PMLFourierDecomposedHelmholtzFluxElement< ELEMENT >, oomph::PMLFourierDecomposedHelmholtzEquations, oomph::ODEElement, oomph::RefineableNavierStokesFluxControlElement< ELEMENT >, oomph::NavierStokesFluxControlElement< ELEMENT >, oomph::NetFluxControlElement< ELEMENT >, oomph::NavierStokesEquations< DIM >, oomph::NavierStokesEquations< 2 >, oomph::FpPressureAdvDiffRobinBCElement< ELEMENT >, oomph::ImposeParallelOutflowElement< ELEMENT >, oomph::ImposeImpenetrabilityElement< ELEMENT >, oomph::RefineableNavierStokesTractionElement< ELEMENT >, oomph::NavierStokesTractionElement< ELEMENT >, oomph::PMLHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >, oomph::TimeHarmonicLinElastLoadedByPMLHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >, oomph::HelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >, oomph::TimeHarmonicLinElastLoadedByHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >, oomph::FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >, oomph::FourierDecomposedTimeHarmonicLinElastLoadedByHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >, oomph::RefineableBuoyantQCrouzeixRaviartElement< DIM >, oomph::BuoyantQCrouzeixRaviartElement< DIM >, oomph::LinearisedNavierStokesEquations, oomph::LinearisedNavierStokesEigenfunctionNormalisationElement, oomph::LinearisedAxisymmetricNavierStokesEquations, oomph::LinearWaveFluxElement< ELEMENT >, oomph::LinearWaveEquations< DIM >, oomph::LinearElasticityTractionElement< ELEMENT >, oomph::LinearElasticityEquations< DIM >, oomph::HelmholtzFluxElement< ELEMENT >, oomph::HelmholtzEquations< DIM >, oomph::HelmholtzDtNBoundaryElement< ELEMENT >, oomph::HelmholtzAbsorbingBCElement< ELEMENT >, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::ProjectableElement< ELEMENT >, oomph::ProjectableElement< FVK_ELEMENT >, oomph::ProjectableElement< AXISYM_LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< UNSTEADY_HEAT_ELEMENT >, oomph::ProjectableElement< LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< CROUZEIX_RAVIART_ELEMENT >, oomph::ProjectableElement< HELMHOLTZ_ELEMENT >, oomph::ProjectableElement< AXISYMMETRIC_POROELASTICITY_ELEMENT >, oomph::ProjectableElement< TAYLOR_HOOD_ELEMENT >, oomph::ProjectableElement< PVD_ELEMENT >, oomph::ProjectableElement< ADR_ELEMENT >, oomph::ProjectableElement< DARCY_ELEMENT >, oomph::ProjectableElement< POISSON_ELEMENT >, oomph::ProjectableElement< FOURIER_DECOMPOSED_HELMHOLTZ_ELEMENT >, oomph::ProjectableElement< TIME_HARMONIC_LINEAR_ELAST_ELEMENT >, oomph::ProjectableElement< LINEAR_HEAT_AND_ELAST_ELEMENT >, oomph::DisplacementControlElement, oomph::GeneralisedNewtonianNavierStokesEquations< DIM >, oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations, oomph::FourierDecomposedHelmholtzFluxElement< ELEMENT >, oomph::FourierDecomposedHelmholtzEquations, oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >, oomph::FoepplvonKarmanVolumeConstraintElement< ELEMENT, MESH >, oomph::FoepplvonKarmanVolumeConstraintElement< ELEMENT, RefineableTriangleMesh >, oomph::FoepplvonKarmanEquations, oomph::DisplacementBasedFoepplvonKarmanEquations, oomph::FluxTransportEquations< DIM >, oomph::FluidInterfaceElement, oomph::FluidInterfaceBoundingElement, oomph::VolumeConstraintBoundingElement, oomph::VolumeConstraintElement, oomph::DarcyFaceElement< ELEMENT >, oomph::DarcyEquations< DIM >, oomph::DarcyEquations< 2 >, oomph::BiharmonicFluidBoundaryElement, oomph::BiharmonicFluxElement< DIM >, oomph::BiharmonicEquations< DIM >, oomph::ClampedSlidingHermiteBeamBoundaryConditionElement, oomph::KirchhoffLoveBeamEquations, oomph::AxisymmetricSolidTractionElement< ELEMENT >, oomph::AxisymmetricPVDEquationsWithPressure, oomph::AxisymmetricPVDEquations, oomph::AxisymmetricPoroelasticityTractionElement< ELEMENT >, oomph::AxisymmetricPoroelasticityTractionElement< POROELASTICITY_BULK_ELEMENT >, oomph::AxisymmetricPoroelasticityEquations, oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >, oomph::AxisymmetricNavierStokesEquations, oomph::LinearisedFSIAxisymmetricNStNoSlipBCElementElement< FLUID_BULK_ELEMENT, SOLID_BULK_ELEMENT >, oomph::AxisymmetricNavierStokesTractionElement< ELEMENT >, oomph::FSIAxisymmetricLinearElasticityTractionElement< ELASTICITY_BULK_ELEMENT, NAVIER_STOKES_BULK_ELEMENT >, oomph::AxisymmetricLinearElasticityTractionElement< ELEMENT >, oomph::AxisymmetricLinearElasticityEquations, oomph::AxisymFoepplvonKarmanEquations, oomph::AxisymFoepplvonKarmanEquations, oomph::AxisymAdvectionDiffusionEquations, oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >, oomph::GeneralisedAdvectionDiffusionEquations< DIM >, oomph::GeneralisedAdvectionDiffusionEquations< 2 >, oomph::AdvectionDiffusionFluxElement< ELEMENT >, oomph::AdvectionDiffusionEquations< DIM >, oomph::AdvectionDiffusionEquations< 2 >, oomph::NavierStokesFluxControlElement< ELEMENT >, oomph::NetFluxControlElement< ELEMENT >, oomph::PolarStreamfunctionEquations, oomph::PolarStreamfunctionTractionElement< ELEMENT >, oomph::FluxConstraint, ModalPRefineableQPoissonElement< DIM >, ModalPoissonEquations< DIM >, oomph::IMRODEElement, SpineGravityTractionElement< ELEMENT >, FixSpineHeightElement, SlavePositionPointElement, DependentPositionPointElement, oomph::RefineableDoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, QThermalPVDElement< DIM >, oomph::RefineableBuoyantQSphericalCrouzeixRaviartElement, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::AxisymmetricQAdvectionCrouzeixRaviartElement, RefineableQAdvectionDiffusionElementWithExternalElement< DIM >, RefineableQCrouzeixRaviartElementWithTwoExternalElement< DIM >, oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >, oomph::RefineableBuoyantQAxisymCrouzeixRaviartElement, oomph::RefineableBuoyantQAxisymCrouzeixRaviartElement, RefineableQAdvectionDiffusionElementWithExternalElement< DIM >, RefineableQCrouzeixRaviartElementWithExternalElement< DIM >, RefineableBuoyantQCrouzeixRaviartElement< DIM >, SSPorousChannelEquations, oomph::LinearisedAxisymmetricFluidInterfaceElement, oomph::LinearisedAxisymmetricNavierStokesEquations, oomph::MultiPoissonEquations< DIM, NFIELDS >, FluxConstraint, FixSpineHeightElement, SpineGravityTractionElement< ELEMENT >, oomph::HomogenisedLinearElasticityEquations< DIM >, oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >, CircularPenetratorElement, CircularPenetratorElement, HeatedCircularPenetratorElement, oomph::HeatedPenetratorFluxElement< ELEMENT >, oomph::TLinearHeatAndElasticityElement< DIM, NNODE_1D >, oomph::SurfaceMeltElement< ELEMENT >, oomph::UnsteadyHeatBaseFaceElement< ELEMENT >, oomph::SurfaceContactElementBase< ELEMENT >, ZeroResidualGenElement, SSPorousChannelEquations, ABCElement, PredatorPreyElement, GelfandBratuElement< NNODE_1D >, oomph::LinearisedAxisymmetricNavierStokesEquations, oomph::ConstraintElement, oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >, and oomph::SingularNavierStokesSolutionElement< ELEMENT >.

    {
      std::string error_message =
        "Empty fill_in_contribution_to_residuals() has been called.\n";
      error_message +=
        "This function is called from the default implementations of\n";
      error_message += "get_residuals() and get_jacobian();\n";
      error_message +=
        "and must calculate the residuals vector without initialising any of ";
      error_message += "its entries.\n\n";
 
      error_message +=
        "If you do not wish to use these defaults, you must overload both\n";
      error_message += "get_residuals() and get_jacobian(), which must "
                       "initialise the entries\n";
      error_message += "of the residuals vector and jacobian matrix to zero.\n";
 
      error_message += "N.B. the default get_jacobian() function employs "
                       "finite differencing\n";
 
      throw OomphLibError(
        error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by oomph::ElementWithExternalElement::fill_in_contribution_to_jacobian(), fill_in_contribution_to_jacobian(), oomph::FiniteElement::fill_in_contribution_to_jacobian(), oomph::SolidFiniteElement::fill_in_contribution_to_jacobian(), oomph::FSIWallElement::fill_in_contribution_to_jacobian(), oomph::DGElement::get_inverse_mass_matrix_times_residuals(), and get_residuals().

fill_in_jacobian_from_external_by_fd() [1/2]

void oomph::GeneralisedElement::fill_in_jacobian_from_external_by_fd ( DenseMatrix< double > &  jacobian, const bool &  fd_all_data = false  )

inlineprotected

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.

    {
      // Allocate storage for a residuals vector
      Vector<double> residuals(Ndof);
      // Get the residuals for the entire element
      get_residuals(residuals);
      // Call the jacobian calculation
      fill_in_jacobian_from_external_by_fd(residuals, jacobian, fd_all_data);
    }

References fill_in_jacobian_from_external_by_fd(), get_residuals(), and Ndof.

fill_in_jacobian_from_external_by_fd() [2/2]

void GeneralisedElement::fill_in_jacobian_from_external_by_fd ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian, const bool &  fd_all_data = false  )

protected

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.

This function calculates the entries of Jacobian matrix, used in the Newton method, associated with the external degrees of freedom. It does this using finite differences, rather than an analytical formulation, so can be done in total generality. 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.

  {
    // Locally cache the number of external data
    const unsigned n_external_data = Nexternal_data;
    // If there aren't any external data, then return straight away
    if (n_external_data == 0)
    {
      return;
    }
 
    // Call the update function to ensure that the element is in
    // a consistent state before finite differencing starts
    update_before_external_fd();
 
    // Find the number of dofs in the element
    const unsigned n_dof = ndof();
 
    // Create newres vector
    Vector<double> newres(n_dof);
 
    // Integer storage for local unknown
    int local_unknown = 0;
 
    // Use the default finite difference step
    const double fd_step = Default_fd_jacobian_step;
 
    // Loop over the external data
    for (unsigned i = 0; i < n_external_data; i++)
    {
      // If we are doing all finite differences or
      // the variable is included in the finite difference loop, do it
      if (fd_all_data || external_data_fd(i))
      {
        // Get the number of value at the external data
        const unsigned n_value = external_data_pt(i)->nvalue();
 
        // Loop over the number of values
        for (unsigned j = 0; j < n_value; j++)
        {
          // Get the local equation number
          local_unknown = external_local_eqn(i, j);
          // If it's not pinned
          if (local_unknown >= 0)
          {
            // Get a pointer to the External data value
            double* const value_pt = external_data_pt(i)->value_pt(j);
 
            // Save the old value of the External data
            const double old_var = *value_pt;
 
            // Increment the value of the External data
            *value_pt += fd_step;
 
            // Now update any dependent variables
            update_in_external_fd(i);
 
            // Calculate the new residuals
            get_residuals(newres);
 
            // Do finite differences
            for (unsigned m = 0; m < n_dof; m++)
            {
              double sum = (newres[m] - residuals[m]) / fd_step;
              // Stick the entry into the Jacobian matrix
              jacobian(m, local_unknown) = sum;
            }
 
            // Reset the External data
            *value_pt = old_var;
 
            // Reset any dependent variables
            reset_in_external_fd(i);
          }
        }
      } // End of finite differencing for datum (if block)
    }
 
    // End of finite difference loop
    // Final reset of any dependent data
    reset_after_external_fd();
  }

References Default_fd_jacobian_step, external_data_fd(), external_data_pt(), external_local_eqn(), get_residuals(), i, j, m, ndof(), Nexternal_data, oomph::Data::nvalue(), reset_after_external_fd(), reset_in_external_fd(), update_before_external_fd(), update_in_external_fd(), and oomph::Data::value_pt().

Referenced by oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_jacobian(), oomph::SpinePointFluidInterfaceBoundingElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::SpineLineFluidInterfaceBoundingElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::ElasticPointFluidInterfaceBoundingElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::ElasticLineFluidInterfaceBoundingElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::ElementWithExternalElement::fill_in_contribution_to_jacobian(), fill_in_contribution_to_jacobian(), oomph::FiniteElement::fill_in_contribution_to_jacobian(), oomph::SolidFiniteElement::fill_in_contribution_to_jacobian(), oomph::FSIWallElement::fill_in_contribution_to_jacobian(), oomph::ImmersedRigidBodyElement::fill_in_contribution_to_jacobian(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_jacobian(), oomph::SolidTractionElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::RefineableSolidTractionElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_contribution_to_jacobian(), and fill_in_jacobian_from_external_by_fd().

fill_in_jacobian_from_internal_by_fd() [1/2]

void oomph::GeneralisedElement::fill_in_jacobian_from_internal_by_fd ( DenseMatrix< double > &  jacobian, const bool &  fd_all_data = false  )

inlineprotected

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.

    {
      // Allocate storage for the residuals
      Vector<double> residuals(Ndof, 0.0);
      // Get the residuals for the entire element
      get_residuals(residuals);
      // Call the jacobian calculation
      fill_in_jacobian_from_internal_by_fd(residuals, jacobian, fd_all_data);
    }

References fill_in_jacobian_from_internal_by_fd(), get_residuals(), and Ndof.

fill_in_jacobian_from_internal_by_fd() [2/2]

void GeneralisedElement::fill_in_jacobian_from_internal_by_fd ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian, const bool &  fd_all_data = false  )

protected

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.

This function calculates the entries of Jacobian matrix, used in the Newton method, associated with the internal degrees of freedom. It does this using finite differences, rather than an analytical formulation, so can be done in total generality. 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.

  {
    // Locally cache the number of internal data
    const unsigned n_internal_data = Ninternal_data;
 
    // If there aren't any internal data, then return straight away
    if (n_internal_data == 0)
    {
      return;
    }
 
    // Call the update function to ensure that the element is in
    // a consistent state before finite differencing starts
    update_before_internal_fd();
 
    // Find the number of dofs in the element
    const unsigned n_dof = ndof();
 
    // Create newres vector
    Vector<double> newres(n_dof);
 
    // Integer storage for local unknown
    int local_unknown = 0;
 
    // Use the default finite difference step
    const double fd_step = Default_fd_jacobian_step;
 
    // Loop over the internal data
    for (unsigned i = 0; i < n_internal_data; i++)
    {
      // If we are doing all finite differences or
      // the variable is included in the finite difference loop, do it
      if (fd_all_data || internal_data_fd(i))
      {
        // Get the number of value at the internal data
        const unsigned n_value = internal_data_pt(i)->nvalue();
 
        // Loop over the number of values
        for (unsigned j = 0; j < n_value; j++)
        {
          // Get the local equation number
          local_unknown = internal_local_eqn(i, j);
          // If it's not pinned
          if (local_unknown >= 0)
          {
            // Get a pointer to the value of the internal data
            double* const value_pt = internal_data_pt(i)->value_pt(j);
 
            // Save the old value of the Internal data
            const double old_var = *value_pt;
 
            // Increment the value of the Internal data
            *value_pt += fd_step;
 
            // Now update any dependent variables
            update_in_internal_fd(i);
 
            // Calculate the new residuals
            get_residuals(newres);
 
            // Do finite differences
            for (unsigned m = 0; m < n_dof; m++)
            {
              double sum = (newres[m] - residuals[m]) / fd_step;
              // Stick the entry into the Jacobian matrix
              jacobian(m, local_unknown) = sum;
            }
 
            // Reset the Internal data
            *value_pt = old_var;
 
            // Reset any dependent variables
            reset_in_internal_fd(i);
          }
        }
      } // End of finite-differencing for datum (if block)
    }
 
    // End of finite difference loop
    // Final reset of any dependent data
    reset_after_internal_fd();
  }

References Default_fd_jacobian_step, get_residuals(), i, internal_data_fd(), internal_data_pt(), internal_local_eqn(), j, m, ndof(), Ninternal_data, oomph::Data::nvalue(), reset_after_internal_fd(), reset_in_internal_fd(), update_before_internal_fd(), update_in_internal_fd(), and oomph::Data::value_pt().

Referenced by oomph::IMRODEElement::fill_in_contribution_to_jacobian(), oomph::ElementWithExternalElement::fill_in_contribution_to_jacobian(), fill_in_contribution_to_jacobian(), oomph::FiniteElement::fill_in_contribution_to_jacobian(), oomph::SolidFiniteElement::fill_in_contribution_to_jacobian(), oomph::FSIWallElement::fill_in_contribution_to_jacobian(), oomph::ODEElement::fill_in_contribution_to_jacobian(), oomph::ImmersedRigidBodyElement::fill_in_contribution_to_jacobian(), and fill_in_jacobian_from_internal_by_fd().

flush_external_data() [1/2]

void GeneralisedElement::flush_external_data

(

)

Flush all external data.

Flush all the external data, i.e. clear the pointers to external data from the internal storage.

  {
    // Get the numbers of internal and external data
    const unsigned n_external_data = Nexternal_data;
    // If there is external data
    if (n_external_data > 0)
    {
      // Storage for new data, initialised to NULL
      Data** new_data_pt = 0;
 
      // Find the number of internal data
      const unsigned n_internal_data = Ninternal_data;
      // If there is internal data resize Data_pt and copy over
      // the pointers
      if (n_internal_data > 0)
      {
        // The new data pointer should only be the size of the internal data
        new_data_pt = new Data*[n_internal_data];
        // Copy over the internal data only
        for (unsigned i = 0; i < n_internal_data; i++)
        {
          new_data_pt[i] = Data_pt[i];
        }
      }
 
      // Delete the old storage
      delete[] Data_pt;
      // Set the new storage, this will be NULL if there is no internal data
      Data_pt = new_data_pt;
      // Set the number of externals to zero
      Nexternal_data = 0;
 
      // Resize the array of boolean flags to the number of internals
      Data_fd.resize(n_internal_data);
    }
  }

References Data_fd, Data_pt, i, Nexternal_data, and Ninternal_data.

Referenced by oomph::ImmersedRigidBodyElement::flush_drag_mesh(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::set_boundary_shape_geom_object_pt(), HeatedCircularPenetratorElement::set_contact_element_mesh_pt(), oomph::ImmersedRigidBodyElement::set_drag_mesh(), oomph::PseudoBucklingRingElement::set_reference_pressure_pt(), and oomph::SolidICProblem::setup_problem().

flush_external_data() [2/2]

void GeneralisedElement::flush_external_data

(

Data *const &

data_pt

)

Flush the object addressed by data_pt from the external data array.

Remove the object addressed by data_pt from the external data array Note that this could mess up the numbering of other external data

  {
    // Get the current numbers of external data
    const unsigned n_external_data = Nexternal_data;
    // Index of the data to be removed
    // We initialise this to be n_external_data, and it will be smaller than
    // n_external_data if the data pointer is found in the array
    unsigned index = n_external_data;
    // Loop over the external data and find the argument
    for (unsigned i = 0; i < n_external_data; i++)
    {
      // If we have found the data pointer, set the index and break
      if (external_data_pt(i) == data_pt)
      {
        index = i;
        break;
      }
    }
 
    // If we have found an index less than Nexternal_data, then we have found
    // the data in the array
    if (index < n_external_data)
    {
      // Initialise a new array to NULL
      Data** new_data_pt = 0;
 
      // Find the number of internals
      const unsigned n_internal_data = Ninternal_data;
 
      // Find the new number of total data items (one fewer)
      const unsigned n_total_data = n_internal_data + n_external_data - 1;
 
      // Create a new array containing the data items, if we have any
      if (n_total_data > 0)
      {
        new_data_pt = new Data*[n_total_data];
      }
 
      // Copy over all the internal data
      for (unsigned i = 0; i < n_internal_data; i++)
      {
        new_data_pt[i] = Data_pt[i];
      }
 
      // Now copy over the un-flushed data
      unsigned counter = 0;
      for (unsigned i = 0; i < n_external_data; i++)
      {
        // If we are not at the deleted index
        if (i != index)
        {
          // Copy the undeleted entry into the next entry in our new
          // array of pointers to Data
          new_data_pt[n_internal_data + counter] = Data_pt[i];
          // Increase the counter
          ++counter;
        }
      }
 
      // Delete the storage associated with the previous values
      delete[] Data_pt;
 
      // Set pointers to the new storage, will be NULL if no data left
      Data_pt = new_data_pt;
 
      // Remove the entry from the array of boolean flags
      Data_fd.erase(Data_fd.begin() + n_internal_data + index);
 
      // Decrease the number of externals
      --Nexternal_data;
 
      // Issue a warning if there will be external data remaining
      if (Nexternal_data > 1)
      {
        std::ostringstream warning_stream;
        warning_stream
          << "Data removed from element's external data   " << std::endl
          << "You may have to update the indices for remaining data "
          << std::endl
          << "This can be achieved by using add_external_data()    "
          << std::endl;
        OomphLibWarning(warning_stream.str(),
                        "GeneralisedElement::flush_external_data()",
                        OOMPH_EXCEPTION_LOCATION);
      }
    }
  }

References Data_fd, Data_pt, external_data_pt(), i, Nexternal_data, Ninternal_data, and OOMPH_EXCEPTION_LOCATION.

get_djacobian_and_dmass_matrix_dparameter()

virtual void oomph::GeneralisedElement::get_djacobian_and_dmass_matrix_dparameter ( double *const &  parameter_pt, Vector< double > &  dres_dparam, DenseMatrix< double > &  djac_dparam, DenseMatrix< double > &  dmass_matrix_dparam  )

inlinevirtual

Calculate the derivatives of the elemental Jacobian matrix mass matrix and residuals with respect to a parameter

    {
      // Zero the residuals derivative vector
      dres_dparam.initialise(0.0);
      // Zero the jacobian derivative  matrix
      djac_dparam.initialise(0.0);
      // Zero the mass matrix derivative
      dmass_matrix_dparam.initialise(0.0);
      // Add the elemental contribution to the residuals vector and matrices
      this->fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter(
        parameter_pt, dres_dparam, djac_dparam, dmass_matrix_dparam);
    }

References fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter(), oomph::Vector< _Tp >::initialise(), and oomph::DenseMatrix< T >::initialise().

Referenced by oomph::HopfHandler::get_dresiduals_dparameter().

get_djacobian_dparameter()

virtual void oomph::GeneralisedElement::get_djacobian_dparameter ( double *const &  parameter_pt, Vector< double > &  dres_dparam, DenseMatrix< double > &  djac_dparam  )

inlinevirtual

Calculate the derivatives of the elemental Jacobian matrix and residuals with respect to a parameter

    {
      // Zero the residuals vector
      dres_dparam.initialise(0.0);
      // Zero the jacobian matrix
      djac_dparam.initialise(0.0);
      // Add the elemental contribution to the residuals vector
      this->fill_in_contribution_to_djacobian_dparameter(
        parameter_pt, dres_dparam, djac_dparam);
    }

References fill_in_contribution_to_djacobian_dparameter(), oomph::Vector< _Tp >::initialise(), and oomph::DenseMatrix< T >::initialise().

Referenced by oomph::AssemblyHandler::get_djacobian_dparameter(), oomph::FoldHandler::get_dresiduals_dparameter(), and oomph::PitchForkHandler::get_dresiduals_dparameter().

get_dof_numbers_for_unknowns()

virtual void oomph::GeneralisedElement::get_dof_numbers_for_unknowns ( std::list< std::pair< unsigned long, unsigned >> &  dof_lookup_list ) const

inlinevirtual

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 type that this unknown is associated with. (The function can obviously only be called if the equation numbering scheme has been set up.)

Reimplemented in oomph::BlockPreconditionableSpaceTimeElementBase, oomph::NetFluxControlElementForWomersleyPressureControl, oomph::NavierStokesWomersleyPressureControlElement, oomph::TimeHarmonicLinearElasticityEquationsBase< DIM >, oomph::TimeHarmonicFourierDecomposedLinearElasticityEquationsBase, oomph::QSphericalTaylorHoodElement, oomph::QSphericalCrouzeixRaviartElement, oomph::BlockPrecRefineableQUnsteadyHeatMixedOrderSpaceTimeElement< SPATIAL_DIM, NNODE_1D >, oomph::BlockPrecQUnsteadyHeatMixedOrderSpaceTimeElement< SPATIAL_DIM, NNODE_1D >, oomph::BlockPrecRefineableQUnsteadyHeatSpaceTimeElement< SPATIAL_DIM, NNODE_1D >, oomph::BlockPrecQUnsteadyHeatSpaceTimeElement< SPATIAL_DIM, NNODE_1D >, oomph::BlockPrecRefineableQUnsteadyHeatSpaceTimeElement< SPATIAL_DIM, NNODE_1D >, oomph::BlockPrecQUnsteadyHeatSpaceTimeElement< SPATIAL_DIM, NNODE_1D >, oomph::BlockPrecQTaylorHoodMixedOrderSpaceTimeElement, oomph::BlockPrecQTaylorHoodSpaceTimeElement, oomph::QTaylorHoodSpaceTimeElement< DIM >, oomph::QTaylorHoodSpaceTimeElement< 2 >, oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::FSISolidTractionElement< ELEMENT, DIM >, oomph::PVDEquationsWithPressure< DIM >, oomph::PVDEquationsBase< DIM >, oomph::ClampedHermiteShellBoundaryConditionElement, oomph::FSIDiagHermiteShellElement, oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >, oomph::PMLHelmholtzFluxElement< ELEMENT >, oomph::PMLHelmholtzEquations< DIM >, oomph::TTaylorHoodElement< DIM >, oomph::TCrouzeixRaviartElement< DIM >, oomph::NetFluxControlElement< ELEMENT >, oomph::QTaylorHoodElement< DIM >, oomph::QTaylorHoodElement< 2 >, oomph::QCrouzeixRaviartElement< DIM >, oomph::ImposeParallelOutflowElement< ELEMENT >, oomph::ImposeImpenetrabilityElement< ELEMENT >, oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >, oomph::RefineableNavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >, oomph::LinearElasticityEquationsBase< DIM >, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::DisplacementControlElement, oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianAxisymmetricTTaylorHoodElement, oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement, oomph::GeneralisedNewtonianAxisymmetricQTaylorHoodElement, oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement, oomph::TDisplacementBasedFoepplvonKarmanElement< NNODE_1D >, oomph::BiharmonicEquations< DIM >, oomph::FSIHermiteBeamElement, oomph::AxisymmetricTTaylorHoodElement, oomph::AxisymmetricTCrouzeixRaviartElement, oomph::AxisymmetricQTaylorHoodElement, oomph::AxisymmetricQCrouzeixRaviartElement, and oomph::AxisymmetricLinearElasticityEquationsBase.

    {
      // error message stream
      std::ostringstream error_message;
      error_message << "get_dof_numbers_for_unknowns() const has not been \n"
                    << " implemented for this element\n"
                    << std::endl;
      // throw error
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

get_dresiduals_dparameter()

virtual void oomph::GeneralisedElement::get_dresiduals_dparameter ( double *const &  parameter_pt, Vector< double > &  dres_dparam  )

inlinevirtual

Calculate the derivatives of the residuals with respect to a parameter

    {
      // Zero the dres_dparam vector
      dres_dparam.initialise(0.0);
      // Add the elemental contribution to the residuals vector
      this->fill_in_contribution_to_dresiduals_dparameter(parameter_pt,
                                                          dres_dparam);
    }

References fill_in_contribution_to_dresiduals_dparameter(), and oomph::Vector< _Tp >::initialise().

Referenced by oomph::AssemblyHandler::get_dresiduals_dparameter(), oomph::FoldHandler::get_dresiduals_dparameter(), and oomph::PitchForkHandler::get_dresiduals_dparameter().

get_hessian_vector_products()

virtual void oomph::GeneralisedElement::get_hessian_vector_products ( Vector< double > const &  Y, DenseMatrix< double > const &  C, DenseMatrix< double > &  product  )

inlinevirtual

Calculate the product of the Hessian (derivative of Jacobian with respect to all variables) an eigenvector, Y, and other specified vectors, C (d(J_{ij})/d u_{k}) Y_{j} C_{k}

Add the elemental contribution to the product

    {
      // Initialise the product to zero
      product.initialise(0.0);
      this->fill_in_contribution_to_hessian_vector_products(Y, C, product);
    }

References fill_in_contribution_to_hessian_vector_products(), and product().

Referenced by oomph::AssemblyHandler::get_hessian_vector_products(), and oomph::PitchForkHandler::get_hessian_vector_products().

get_inner_product_vectors()

virtual void oomph::GeneralisedElement::get_inner_product_vectors ( Vector< unsigned > const &  history_index, Vector< Vector< double >> &  inner_product_vector  )

inlinevirtual

Compute the vectors that when taken as a dot product with other history values give the inner product over the element.

    {
      const unsigned n_inner_product = inner_product_vector.size();
      for (unsigned i = 0; i < n_inner_product; ++i)
      {
        inner_product_vector[i].initialise(0.0);
      }
      this->fill_in_contribution_to_inner_product_vectors(history_index,
                                                          inner_product_vector);
    }

References fill_in_contribution_to_inner_product_vectors(), and i.

Referenced by oomph::AssemblyHandler::get_inner_product_vectors().

get_inner_products()

virtual void oomph::GeneralisedElement::get_inner_products ( Vector< std::pair< unsigned, unsigned >> const &  history_index, Vector< double > &  inner_product  )

inlinevirtual

Return the vector of inner product of the given pairs of history values

    {
      inner_product.initialise(0.0);
      this->fill_in_contribution_to_inner_products(history_index,
                                                   inner_product);
    }

References fill_in_contribution_to_inner_products(), and oomph::Vector< _Tp >::initialise().

Referenced by oomph::AssemblyHandler::get_inner_products().

get_jacobian()

virtual void oomph::GeneralisedElement::get_jacobian ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian  )

inlinevirtual

Calculate the elemental Jacobian matrix "d equation / d variable".

Reimplemented in oomph::ImposeFluxForWomersleyElement< DIM >, oomph::RefineableSolidQElement< 2 >, oomph::RefineableSolidQElement< 1 >, oomph::RefineableSolidQElement< 3 >, oomph::PseudoBucklingRingElement, oomph::Hijacked< PerturbedSpineElement< FaceGeometry< ELEMENT > > >, oomph::Hijacked< SpineElement< FaceGeometry< FaceGeometry< ELEMENT > > > >, oomph::Hijacked< SpineElement< FaceGeometry< ELEMENT > > >, oomph::ElementWithSpecificMovingNodes< ELEMENT, NODE_TYPE >, oomph::ElementWithSpecificMovingNodes< ELEMENT, SpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, PerturbedSpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, AlgebraicNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, MacroElementNodeUpdateNode >, TwoNodePoissonElement, ElasticFishBackElement, and oomph::ElasticallySupportedRingElement.

    {
      // Zero the residuals vector
      residuals.initialise(0.0);
      // Zero the jacobian matrix
      jacobian.initialise(0.0);
      // Add the elemental contribution to the residuals vector
      fill_in_contribution_to_jacobian(residuals, jacobian);
    }

References fill_in_contribution_to_jacobian(), oomph::Vector< _Tp >::initialise(), and oomph::DenseMatrix< T >::initialise().

Referenced by oomph::AssemblyHandler::get_jacobian(), oomph::FoldHandler::get_jacobian(), oomph::PitchForkHandler::get_jacobian(), oomph::HopfHandler::get_jacobian(), oomph::RefineableSolidQElement< 3 >::get_jacobian(), oomph::RefineableSolidQElement< 1 >::get_jacobian(), oomph::RefineableSolidQElement< 2 >::get_jacobian(), oomph::FoldHandler::get_residuals(), oomph::PitchForkHandler::get_residuals(), and oomph::AugmentedBlockFoldLinearSolver::solve().

get_jacobian_and_mass_matrix()

virtual void oomph::GeneralisedElement::get_jacobian_and_mass_matrix ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian, DenseMatrix< double > &  mass_matrix  )

inlinevirtual

Calculate the residuals and jacobian and elemental "mass" matrix, the matrix that multiplies the time derivative terms.

Reimplemented in oomph::ElementWithSpecificMovingNodes< ELEMENT, NODE_TYPE >, oomph::ElementWithSpecificMovingNodes< ELEMENT, SpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, PerturbedSpineNode >, oomph::ElementWithSpecificMovingNodes< ELEMENT, AlgebraicNode >, and oomph::ElementWithSpecificMovingNodes< ELEMENT, MacroElementNodeUpdateNode >.

    {
      // Zero the residuals vector
      residuals.initialise(0.0);
      // Zero the jacobian matrix
      jacobian.initialise(0.0);
      // Zero the mass matrix
      mass_matrix.initialise(0.0);
      // Add the elemental contribution to the vector and matrix
      fill_in_contribution_to_jacobian_and_mass_matrix(
        residuals, jacobian, mass_matrix);
    }

References fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::Vector< _Tp >::initialise(), and oomph::DenseMatrix< T >::initialise().

Referenced by oomph::PeriodicOrbitEquations::fill_in_generic_residual_contribution_orbit(), oomph::EigenProblemHandler::get_all_vectors_and_matrices(), oomph::HopfHandler::get_jacobian(), oomph::HopfHandler::get_residuals(), oomph::BlockHopfLinearSolver::solve(), and oomph::BlockHopfLinearSolver::solve_for_two_rhs().

get_mass_matrix()

virtual void oomph::GeneralisedElement::get_mass_matrix ( Vector< double > &  residuals, DenseMatrix< double > &  mass_matrix  )

inlinevirtual

Calculate the residuals and the elemental "mass" matrix, the matrix that multiplies the time derivative terms in a problem.

    {
      // Zero the residuals vector
      residuals.initialise(0.0);
      // Zero the mass matrix
      mass_matrix.initialise(0.0);
      // Add the elemental contribution to the vector and matrix
      fill_in_contribution_to_mass_matrix(residuals, mass_matrix);
    }

References fill_in_contribution_to_mass_matrix(), oomph::Vector< _Tp >::initialise(), and oomph::DenseMatrix< T >::initialise().

Referenced by oomph::ExplicitTimeStepHandler::get_all_vectors_and_matrices(), and oomph::ExplicitTimeStepHandler::get_jacobian().

get_residuals()

virtual void oomph::GeneralisedElement::get_residuals ( Vector< double > &  residuals )

inlinevirtual

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.

Reimplemented in oomph::ImposeFluxForWomersleyElement< DIM >, oomph::PseudoBucklingRingElement, oomph::Hijacked< PerturbedSpineElement< FaceGeometry< ELEMENT > > >, oomph::Hijacked< SpineElement< FaceGeometry< FaceGeometry< ELEMENT > > > >, oomph::Hijacked< SpineElement< FaceGeometry< ELEMENT > > >, TwoNodePoissonElement, ElasticFishBackElement, oomph::ElasticallySupportedRingElement, and ZeroResidualGenElement.

    {
      // Zero the residuals vector
      residuals.initialise(0.0);
      // Add the elemental contribution to the residuals vector
      fill_in_contribution_to_residuals(residuals);
    }

References fill_in_contribution_to_residuals(), and oomph::Vector< _Tp >::initialise().

Referenced by oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_jacobian(), oomph::ElementWithExternalElement::fill_in_contribution_to_jacobian(), fill_in_contribution_to_jacobian(), oomph::FiniteElement::fill_in_contribution_to_jacobian(), oomph::SolidFiniteElement::fill_in_contribution_to_jacobian(), oomph::FSIWallElement::fill_in_contribution_to_jacobian(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_jacobian(), oomph::PeriodicOrbitEquations::fill_in_generic_residual_contribution_orbit(), fill_in_jacobian_from_external_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_field_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_geometric_by_fd(), oomph::ElementWithMovingNodes::fill_in_jacobian_from_geometric_data(), fill_in_jacobian_from_internal_by_fd(), oomph::FiniteElement::fill_in_jacobian_from_nodal_by_fd(), oomph::RefineableElement::fill_in_jacobian_from_nodal_by_fd(), oomph::SolidFiniteElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::FiniteElement::get_dresidual_dnodal_coordinates(), oomph::RefineableElement::get_dresidual_dnodal_coordinates(), oomph::AssemblyHandler::get_residuals(), oomph::ExplicitTimeStepHandler::get_residuals(), oomph::FoldHandler::get_residuals(), and oomph::PitchForkHandler::get_residuals().

include_external_data_fd()

void oomph::GeneralisedElement::include_external_data_fd ( const unsigned &  i )

inline

Set the boolean flag to include the external datum in the the finite difference loop when computing the jacobian matrix

    {
#ifdef RANGE_CHECKING
      if (i >= Nexternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: External data " << i
                      << " is not in the range (0," << Nexternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Set the value
      Data_fd[Ninternal_data + i] = true;
    }

References Data_fd, i, Nexternal_data, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

include_internal_data_fd()

void oomph::GeneralisedElement::include_internal_data_fd ( const unsigned &  i )

inlineprotected

Set the boolean flag to include the internal datum in the finite difference loop when computing the jacobian matrix

    {
#ifdef RANGE_CHECKING
      if (i >= Ninternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: Internal data " << i
                      << " is not in the range (0," << Ninternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Set the value
      Data_fd[i] = true;
    }

References Data_fd, i, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

internal_data_fd()

bool oomph::GeneralisedElement::internal_data_fd ( const unsigned &  i ) const

inlineprotected

Return the status of the boolean flag indicating whether the internal data is included in the finite difference loop

    {
#ifdef RANGE_CHECKING
      if (i >= Ninternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: Internal data " << i
                      << " is not in the range (0," << Ninternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Return the value
      return Data_fd[i];
    }

References Data_fd, i, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by fill_in_jacobian_from_internal_by_fd().

internal_data_pt() [1/2]

Data*& oomph::GeneralisedElement::internal_data_pt ( const unsigned &  i )

inline

Return a pointer to i-th internal data object.

    {
#ifdef RANGE_CHECKING
      if (i >= Ninternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: Internal data " << i
                      << " is not in the range (0," << Ninternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Data_pt[i];
    }

References Data_pt, i, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), add_internal_data(), add_internal_value_pt_to_map(), HeatedCircularPenetratorElement::angle(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), assign_internal_and_external_local_eqn_numbers(), assign_internal_eqn_numbers(), assign_local_eqn_numbers(), oomph::SolidICProblem::backup_original_state(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::c(), oomph::Problem::copy(), oomph::LinearisedQCrouzeixRaviartElement::copy_efunction_to_normalisation(), oomph::ProjectableAxisymmetricCrouzeixRaviartElement< CROUZEIX_RAVIART_ELEMENT >::data_values_of_field(), oomph::GeneralisedNewtonianProjectableAxisymmetricCrouzeixRaviartElement< CROUZEIX_RAVIART_ELEMENT >::data_values_of_field(), oomph::ProjectableGeneralisedNewtonianCrouzeixRaviartElement< CROUZEIX_RAVIART_ELEMENT >::data_values_of_field(), describe_dofs(), describe_local_dofs(), oomph::FSI_functions::doc_fsi(), oomph::Mesh::does_pointer_correspond_to_mesh_data(), oomph::AxisymmetricPoroelasticityEquations::dq_internal_dt(), oomph::PoroelasticityEquations< DIM >::dq_internal_dt(), oomph::Mesh::dump(), oomph::LinearisedNavierStokesEigenfunctionNormalisationElement::eigenvalue_data_pt(), oomph::ElasticallySupportedRingElement::ElasticallySupportedRingElement(), HeatedCircularPenetratorElement::equilibrium_data(), ZeroResidualGenElement::eval(), ZeroResidualGenElement::eval_pt(), oomph::IMRODEElement::fill_in_contribution_to_jacobian(), oomph::ODEElement::fill_in_contribution_to_jacobian(), HeatedCircularPenetratorElement::fill_in_contribution_to_residuals(), oomph::IMRODEElement::fill_in_contribution_to_residuals(), oomph::ODEElement::fill_in_contribution_to_residuals(), oomph::AxisymmetricPoroelasticityEquations::fill_in_generic_residual_contribution(), fill_in_jacobian_from_internal_by_fd(), oomph::LinearisedAxisymmetricQCrouzeixRaviartElement::fix_cosine_component_of_pressure(), oomph::AxisymmetricTCrouzeixRaviartElement::fix_pressure(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::fix_pressure(), oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >::fix_pressure(), oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::fix_pressure(), oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >::fix_pressure(), oomph::QCrouzeixRaviartElement< DIM >::fix_pressure(), oomph::PRefineableQCrouzeixRaviartElement< DIM >::fix_pressure(), oomph::TCrouzeixRaviartElement< DIM >::fix_pressure(), oomph::PolarCrouzeixRaviartElement::fix_pressure(), oomph::QSphericalCrouzeixRaviartElement::fix_pressure(), oomph::LinearisedAxisymmetricQCrouzeixRaviartElement::fix_pressure(), oomph::AxisymmetricQCrouzeixRaviartElement::fix_pressure(), oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::fix_pressure(), oomph::LinearisedQCrouzeixRaviartElement::fix_pressure(), oomph::LinearisedAxisymmetricQCrouzeixRaviartElement::fix_sine_component_of_pressure(), oomph::AxisymQPVDElementWithPressure::fix_solid_pressure(), oomph::QPVDElementWithPressure< DIM >::fix_solid_pressure(), oomph::RefineableLinearisedAxisymmetricQCrouzeixRaviartElement::further_build(), oomph::RefineableAxisymmetricQCrouzeixRaviartElement::further_build(), oomph::RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::further_build(), oomph::RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::further_build(), oomph::RefineableLinearisedQCrouzeixRaviartElement::further_build(), oomph::RefineableQCrouzeixRaviartElement< DIM >::further_build(), oomph::RefineablePolarCrouzeixRaviartElement::further_build(), oomph::RefineableQSphericalCrouzeixRaviartElement::further_build(), oomph::Problem::get_dofs(), oomph::PolarCrouzeixRaviartElement::get_load_data(), oomph::ODEProblem::global_temporal_error_norm(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::grad_p_bar(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::grad_u_bar(), HeatedCircularPenetratorElement::HeatedCircularPenetratorElement(), oomph::FiniteElement::identify_field_data_for_interactions(), oomph::RefineableElement::identify_field_data_for_interactions(), SegregatedFSICollapsibleChannelProblem< ELEMENT >::identify_fluid_and_solid_dofs(), SegregatedFSIDrivenCavityProblem< ELEMENT >::identify_fluid_and_solid_dofs(), oomph::RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::identify_load_data(), oomph::RefineableQCrouzeixRaviartElement< DIM >::identify_load_data(), oomph::AxisymmetricTCrouzeixRaviartElement::identify_pressure_data(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::identify_pressure_data(), oomph::QSphericalCrouzeixRaviartElement::identify_pressure_data(), oomph::RefineablePolarCrouzeixRaviartElement::insert_load_data(), internal_local_eqn(), oomph::HeightControlElement::kappa_pt(), oomph::ConstraintElement::lagrange_multiplier(), oomph::ODEProblem::my_set_initial_condition(), oomph::ODEElement::nvalue(), oomph::AxisymmetricQCrouzeixRaviartElement::p_axi_nst(), oomph::AxisymmetricTCrouzeixRaviartElement::p_axi_nst(), oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::p_axi_nst(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::p_axi_nst(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::p_bar(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::p_data_pt(), oomph::TRaviartThomasDarcyElement< ORDER >::p_data_pt(), oomph::LinearisedAxisymmetricQCrouzeixRaviartElement::p_lin_axi_nst(), oomph::LinearisedAxisymmetricQCrouzeixRaviartElement::p_linearised_axi_nst(), oomph::LinearisedQCrouzeixRaviartElement::p_linearised_nst(), oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >::p_nst(), oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::p_nst(), oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >::p_nst(), oomph::QCrouzeixRaviartElement< DIM >::p_nst(), oomph::PRefineableQCrouzeixRaviartElement< DIM >::p_nst(), oomph::TCrouzeixRaviartElement< DIM >::p_nst(), oomph::PolarCrouzeixRaviartElement::p_pnst(), oomph::QSphericalCrouzeixRaviartElement::p_spherical_nst(), oomph::VolumeConstraintElement::p_traded_data_pt(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::p_value(), oomph::TPoroelasticityElement< ORDER >::p_value(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_all(), FlowAroundCylinderProblem< ELEMENT >::pin_all_base_flow_dofs(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::NavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::SpaceTimeNavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::pin_all_non_pressure_dofs(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::pin_c(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::pin_p_value(), oomph::TRaviartThomasDarcyElement< ORDER >::pin_p_value(), oomph::TPoroelasticityElement< ORDER >::pin_p_value(), oomph::LinearisedQCrouzeixRaviartElement::pin_pressure_normalisation_dofs(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::pin_q_internal_value(), oomph::TRaviartThomasDarcyElement< ORDER >::pin_q_internal_value(), oomph::TPoroelasticityElement< ORDER >::pin_q_internal_value(), oomph::LinearisedQCrouzeixRaviartElement::pin_real_or_imag(), oomph::ElasticallySupportedRingElement::pin_yc(), oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement(), oomph::PRefineableQCrouzeixRaviartElement< DIM >::PRefineableQCrouzeixRaviartElement(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::q_internal(), oomph::TRaviartThomasDarcyElement< ORDER >::q_internal(), oomph::TPoroelasticityElement< ORDER >::q_internal(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::q_internal_data_pt(), oomph::TRaviartThomasDarcyElement< ORDER >::q_internal_data_pt(), oomph::Mesh::read(), oomph::RefineableLinearisedAxisymmetricQCrouzeixRaviartElement::rebuild_from_sons(), oomph::RefineableAxisymmetricQCrouzeixRaviartElement::rebuild_from_sons(), oomph::RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::rebuild_from_sons(), oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::rebuild_from_sons(), oomph::RefineableLinearisedQCrouzeixRaviartElement::rebuild_from_sons(), oomph::PRefineableQCrouzeixRaviartElement< DIM >::rebuild_from_sons(), oomph::RefineablePolarCrouzeixRaviartElement::rebuild_from_sons(), oomph::RefineableQSphericalCrouzeixRaviartElement::rebuild_from_sons(), oomph::SolidICProblem::reset_original_state(), oomph::NavierStokesSchurComplementPreconditioner::reset_pin_status(), self_test(), HeatedCircularPenetratorElement::set_angle(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::set_c(), oomph::Mesh::set_consistent_pinned_values_for_continuation(), HeatedCircularPenetratorElement::set_contact_element_mesh_pt(), oomph::Problem::set_dofs(), set_internal_data_time_stepper(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::set_p_value(), oomph::TRaviartThomasDarcyElement< ORDER >::set_p_value(), oomph::Problem::set_pinned_values_to_zero(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::set_q_internal(), oomph::TRaviartThomasDarcyElement< ORDER >::set_q_internal(), oomph::AxisymmetricPoroelasticityEquations::set_q_internal_timestepper(), oomph::PoroelasticityEquations< DIM >::set_q_internal_timestepper(), oomph::QPVDElementWithPressure< DIM >::set_solid_p(), oomph::SolidICProblem::setup_problem(), oomph::AxisymQPVDElementWithPressure::solid_p(), oomph::QPVDElementWithPressure< DIM >::solid_p(), oomph::ODEProblem::solution(), oomph::IMRODEElement::time_interpolate_time(), oomph::IMRODEElement::time_interpolate_u(), oomph::ODEProblem::ts_pt(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::u_bar(), oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >::unfix_pressure(), oomph::RefineableDoubleBuoyantQCrouzeixRaviartElement< DIM >::unfix_pressure(), oomph::BuoyantQCrouzeixRaviartElement< DIM >::unfix_pressure(), FlowAroundCylinderProblem< ELEMENT >::unpin_all_base_flow_dofs(), oomph::AxisymmetricTCrouzeixRaviartElement::unpin_all_internal_pressure_dofs(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::unpin_all_internal_pressure_dofs(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::unpin_c(), oomph::RefineableLinearisedAxisymmetricQCrouzeixRaviartElement::unpin_elemental_pressure_dofs(), oomph::RefineableAxisymmetricQCrouzeixRaviartElement::unpin_elemental_pressure_dofs(), oomph::RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::unpin_elemental_pressure_dofs(), oomph::RefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::unpin_elemental_pressure_dofs(), oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::unpin_elemental_pressure_dofs(), oomph::RefineableLinearisedQCrouzeixRaviartElement::unpin_elemental_pressure_dofs(), oomph::RefineableQCrouzeixRaviartElement< DIM >::unpin_elemental_pressure_dofs(), oomph::PRefineableQCrouzeixRaviartElement< DIM >::unpin_elemental_pressure_dofs(), oomph::RefineablePolarCrouzeixRaviartElement::unpin_elemental_pressure_dofs(), oomph::RefineableQSphericalCrouzeixRaviartElement::unpin_elemental_pressure_dofs(), oomph::RefineableQPVDElementWithPressure< DIM >::unpin_elemental_solid_pressure_dofs(), oomph::QPVDElementWithPressure< DIM >::unpin_elemental_solid_pressure_dofs(), oomph::LinearisedQCrouzeixRaviartElement::unpin_real_or_imag(), oomph::ElasticallySupportedRingElement::unpin_yc(), ZeroResidualGenElement::ZeroResidualGenElement(), and oomph::ImmersedRigidBodyElement::~ImmersedRigidBodyElement().

internal_data_pt() [2/2]

Data* const& oomph::GeneralisedElement::internal_data_pt ( const unsigned &  i ) const

inline

Return a pointer to i-th internal data object (const version)

    {
#ifdef RANGE_CHECKING
      if (i >= Ninternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: Internal data " << i
                      << " is not in the range (0," << Ninternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Data_pt[i];
    }

References Data_pt, i, Ninternal_data, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

internal_local_eqn()

int oomph::GeneralisedElement::internal_local_eqn ( const unsigned &  i, const unsigned &  j  ) const

inlineprotected

Return the local equation number corresponding to the j-th value stored at the i-th internal data

    {
#ifdef RANGE_CHECKING
      if (i >= Ninternal_data)
      {
        std::ostringstream error_message;
        error_message << "Range Error: Internal data " << i
                      << " is not in the range (0," << Ninternal_data - 1
                      << ")";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      else
      {
        unsigned n_value = internal_data_pt(i)->nvalue();
        if (j >= n_value)
        {
          std::ostringstream error_message;
          error_message << "Range Error: value " << j << " at internal data "
                        << i << " is not in the range (0," << n_value - 1
                        << ")";
          throw OomphLibError(error_message.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
      }
#endif
      // Check that the data has been allocated
#ifdef PARANOID
      if (Data_local_eqn == 0)
      {
        throw OomphLibError(
          "Internal local equation numbers have not been allocated",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
#endif
      // Return the local equation number as stored in the Data_local_eqn array
      return Data_local_eqn[i][j];
    }

References Data_local_eqn, i, internal_data_pt(), j, Ninternal_data, oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::FoepplvonKarmanVolumeConstraintElement< ELEMENT, MESH >::assign_additional_local_eqn_numbers(), oomph::DisplacementControlElement::assign_additional_local_eqn_numbers(), oomph::HeightControlElement::assign_additional_local_eqn_numbers(), oomph::ImmersedRigidBodyElement::centre_displacement_local_eqn(), oomph::LinearisedNavierStokesEigenfunctionNormalisationElement::eigenvalue_local_eqn(), HeatedCircularPenetratorElement::fill_in_contribution_to_residuals(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::fill_in_generic_contribution_to_residuals(), oomph::ElasticallySupportedRingElement::fill_in_generic_residual_contribution(), oomph::NavierStokesWomersleyPressureControlElement::fill_in_generic_residual_contribution_pressure_control(), fill_in_jacobian_from_internal_by_fd(), oomph::PseudoBucklingRingElement::geometric_local_eqn(), oomph::ImposeFluxForWomersleyElement< DIM >::get_residuals(), oomph::ConstraintElement::lagrange_eqn(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::p_local_eqn(), oomph::PolarCrouzeixRaviartElement::p_local_eqn(), oomph::AxisymmetricQCrouzeixRaviartElement::p_local_eqn(), oomph::AxisymmetricTCrouzeixRaviartElement::p_local_eqn(), oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::p_local_eqn(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::p_local_eqn(), oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >::p_local_eqn(), oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >::p_local_eqn(), oomph::QCrouzeixRaviartElement< DIM >::p_local_eqn(), oomph::TCrouzeixRaviartElement< DIM >::p_local_eqn(), oomph::TPoroelasticityElement< ORDER >::p_local_eqn(), oomph::QSphericalCrouzeixRaviartElement::p_local_eqn(), oomph::LinearisedAxisymmetricQCrouzeixRaviartElement::p_local_eqn(), oomph::LinearisedQCrouzeixRaviartElement::p_local_eqn(), oomph::VolumeConstraintElement::ptraded_local_eqn(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::q_internal_local_eqn(), oomph::TRaviartThomasDarcyElement< ORDER >::q_internal_local_eqn(), oomph::TPoroelasticityElement< ORDER >::q_internal_local_eqn(), oomph::AxisymQPVDElementWithPressure::solid_p_local_eqn(), and oomph::QPVDElementWithPressure< DIM >::solid_p_local_eqn().

local_eqn_number()

int oomph::GeneralisedElement::local_eqn_number ( const unsigned long &  ieqn_global ) const

inline

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

    {
      // Cache the number of degrees of freedom in the element
      const unsigned n_dof = this->Ndof;
      // Loop over the local equation numbers
      for (unsigned n = 0; n < n_dof; n++)
      {
        // If the global equation numbers match return
        if (ieqn_global == Eqn_number[n])
        {
          return n;
        }
      }
 
      // If we've got all the way to the end the number has not been found
      // return minus one.
      return -1;
    }

References Eqn_number, n, and Ndof.

Referenced by oomph::ElementWithMovingNodes::assign_all_generic_local_eqn_numbers(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), oomph::RefineableElement::assign_hanging_local_eqn_numbers(), assign_internal_and_external_local_eqn_numbers(), oomph::FiniteElement::assign_nodal_local_eqn_numbers(), oomph::RefineableSolidElement::assign_solid_hanging_local_eqn_numbers(), oomph::SolidFiniteElement::assign_solid_local_eqn_numbers(), oomph::BiharmonicFluidBoundaryElement::fill_in_generic_residual_contribution_biharmonic_boundary(), oomph::RefineableNavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >::fill_in_off_diagonal_block_analytic(), oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >::fill_in_off_diagonal_block_analytic(), oomph::NavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >::fill_in_off_diagonal_block_analytic(), oomph::AdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >::fill_in_off_diagonal_block_analytic(), oomph::AxisymmetricQCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::AxisymmetricQTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::AxisymmetricTCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::AxisymmetricTTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::BiharmonicEquations< DIM >::get_dof_numbers_for_unknowns(), oomph::TDisplacementBasedFoepplvonKarmanElement< NNODE_1D >::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianAxisymmetricQTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianAxisymmetricTTaylorHoodElement::get_dof_numbers_for_unknowns(), oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >::get_dof_numbers_for_unknowns(), oomph::DisplacementControlElement::get_dof_numbers_for_unknowns(), oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >::get_dof_numbers_for_unknowns(), oomph::TTaylorHoodElement< DIM >::get_dof_numbers_for_unknowns(), oomph::PMLHelmholtzEquations< DIM >::get_dof_numbers_for_unknowns(), oomph::PMLHelmholtzFluxElement< ELEMENT >::get_dof_numbers_for_unknowns(), oomph::BlockPrecQTaylorHoodSpaceTimeElement::get_dof_numbers_for_unknowns(), oomph::BlockPrecQTaylorHoodMixedOrderSpaceTimeElement::get_dof_numbers_for_unknowns(), oomph::QSphericalCrouzeixRaviartElement::get_dof_numbers_for_unknowns(), oomph::QSphericalTaylorHoodElement::get_dof_numbers_for_unknowns(), and print_connectivity_matrix().

ndof()

unsigned oomph::GeneralisedElement::ndof ( ) const

inline

Return the number of equations/dofs in the element.

    {
      return Ndof;
    }

References Ndof.

Referenced by oomph::NavierStokesSchurComplementPreconditioner::assemble_inv_press_and_veloc_mass_matrix_diagonal(), oomph::PressureBasedSolidLSCPreconditioner::assemble_mass_matrix_diagonal(), oomph::ElementWithMovingNodes::assign_all_generic_local_eqn_numbers(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), oomph::RefineableElement::assign_hanging_local_eqn_numbers(), assign_internal_and_external_local_eqn_numbers(), oomph::FiniteElement::assign_nodal_local_eqn_numbers(), oomph::RefineableSolidElement::assign_solid_hanging_local_eqn_numbers(), oomph::SolidFiniteElement::assign_solid_local_eqn_numbers(), oomph::FoldHandler::eqn_number(), oomph::PitchForkHandler::eqn_number(), oomph::HopfHandler::eqn_number(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::eqn_number(), oomph::AxisymmetricNavierStokesEquations::fill_in_contribution_to_hessian_vector_products(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_contribution_to_hessian_vector_products(), oomph::SpinePointMarangoniSurfactantFluidInterfaceBoundingElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::KirchhoffLoveBeamEquations::fill_in_contribution_to_jacobian(), oomph::ElementWithExternalElement::fill_in_contribution_to_jacobian(), oomph::FiniteElement::fill_in_contribution_to_jacobian(), oomph::SolidFiniteElement::fill_in_contribution_to_jacobian(), oomph::FSIWallElement::fill_in_contribution_to_jacobian(), oomph::KirchhoffLoveShellEquations::fill_in_contribution_to_jacobian(), oomph::DisplacementBasedFoepplvonKarmanEquations::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::PVDEquationsWithPressure< DIM >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_contribution_to_jacobian_and_mass_matrix(), ZeroResidualGenElement::fill_in_contribution_to_residuals(), oomph::ElasticallySupportedRingElement::fill_in_generic_residual_contribution(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_generic_residual_contribution_axi_nst(), oomph::PeriodicOrbitEquations::fill_in_generic_residual_contribution_orbit(), oomph::SphericalNavierStokesEquations::fill_in_generic_residual_contribution_spherical_nst(), fill_in_jacobian_from_external_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_field_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_geometric_by_fd(), oomph::ElementWithMovingNodes::fill_in_jacobian_from_geometric_data(), fill_in_jacobian_from_internal_by_fd(), oomph::FiniteElement::fill_in_jacobian_from_nodal_by_fd(), oomph::RefineableElement::fill_in_jacobian_from_nodal_by_fd(), oomph::SolidFiniteElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::AxisymmetricQAdvectionCrouzeixRaviartElement::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::RefineableDoubleBuoyantQCrouzeixRaviartElement< DIM >::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::FoldHandler::FoldHandler(), oomph::EigenProblemHandler::get_all_vectors_and_matrices(), oomph::AxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::FiniteElement::get_dresidual_dnodal_coordinates(), oomph::RefineableElement::get_dresidual_dnodal_coordinates(), oomph::FoldHandler::get_dresiduals_dparameter(), oomph::PitchForkHandler::get_dresiduals_dparameter(), oomph::HopfHandler::get_dresiduals_dparameter(), oomph::PeriodicOrbitBaseElement::get_inner_product_matrix(), oomph::Problem::get_inverse_mass_matrix_times_residuals(), oomph::DGElement::get_inverse_mass_matrix_times_residuals(), oomph::FoldHandler::get_jacobian(), oomph::PitchForkHandler::get_jacobian(), oomph::HopfHandler::get_jacobian(), oomph::FpPreconditionerAssemblyHandler::get_jacobian(), oomph::ImposeFluxForWomersleyElement< DIM >::get_jacobian(), oomph::AxisymmetricNavierStokesEquations::get_pressure_and_velocity_mass_matrix_diagonal(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_pressure_and_velocity_mass_matrix_diagonal(), oomph::SphericalNavierStokesEquations::get_pressure_and_velocity_mass_matrix_diagonal(), oomph::FoldHandler::get_residuals(), oomph::PitchForkHandler::get_residuals(), oomph::HopfHandler::get_residuals(), oomph::FpPreconditionerAssemblyHandler::get_residuals(), oomph::HopfHandler::HopfHandler(), oomph::AssemblyHandler::ndof(), oomph::ExplicitTimeStepHandler::ndof(), oomph::EigenProblemHandler::ndof(), oomph::FoldHandler::ndof(), oomph::PitchForkHandler::ndof(), oomph::HopfHandler::ndof(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::ndof(), oomph::METIS::partition_mesh(), oomph::DGElement::pre_compute_mass_matrix(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), and oomph::BlockHopfLinearSolver::solve_for_two_rhs().

ndof_types()

virtual unsigned oomph::GeneralisedElement::ndof_types ( ) const

inlinevirtual

The number of types of degrees of freedom in this element are sub-divided into

Reimplemented in oomph::NetFluxControlElementForWomersleyPressureControl, oomph::NavierStokesWomersleyPressureControlElement, oomph::TimeHarmonicLinearElasticityEquationsBase< DIM >, oomph::TimeHarmonicFourierDecomposedLinearElasticityEquationsBase, oomph::QSphericalTaylorHoodElement, oomph::QSphericalCrouzeixRaviartElement, oomph::QTaylorHoodSpaceTimeElement< DIM >, oomph::QTaylorHoodSpaceTimeElement< 2 >, oomph::BlockPreconditionableSpaceTimeElementBase, oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >, oomph::FSISolidTractionElement< ELEMENT, DIM >, oomph::PVDEquationsWithPressure< DIM >, oomph::PVDEquationsBase< DIM >, oomph::ClampedHermiteShellBoundaryConditionElement, oomph::FSIDiagHermiteShellElement, oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >, oomph::PMLHelmholtzFluxElement< ELEMENT >, oomph::PMLHelmholtzEquations< DIM >, oomph::TTaylorHoodElement< DIM >, oomph::TCrouzeixRaviartElement< DIM >, oomph::NetFluxControlElement< ELEMENT >, oomph::QTaylorHoodElement< DIM >, oomph::QTaylorHoodElement< 2 >, oomph::QCrouzeixRaviartElement< DIM >, oomph::ImposeParallelOutflowElement< ELEMENT >, oomph::ImposeImpenetrabilityElement< ELEMENT >, oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >, oomph::RefineableNavierStokesBoussinesqElement< NST_ELEMENT, AD_ELEMENT >, oomph::LinearisedQTaylorHoodElement, oomph::LinearisedQCrouzeixRaviartElement, oomph::LinearisedAxisymmetricQTaylorHoodElement, oomph::LinearisedAxisymmetricQCrouzeixRaviartElement, oomph::LinearElasticityEquationsBase< DIM >, oomph::PseudoSolidNodeUpdateElement< TCrouzeixRaviartElement< 2 >, TPVDBubbleEnrichedElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< TTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianAxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< AxisymmetricTTaylorHoodElement, TPVDElement< 2, 3 > >, oomph::PseudoSolidNodeUpdateElement< GeneralisedNewtonianTTaylorHoodElement< 2 >, TPVDElement< 2, 3 > >, oomph::DisplacementControlElement, oomph::GeneralisedNewtonianTTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianTCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianQTaylorHoodElement< DIM >, oomph::GeneralisedNewtonianQCrouzeixRaviartElement< DIM >, oomph::GeneralisedNewtonianAxisymmetricTTaylorHoodElement, oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement, oomph::GeneralisedNewtonianAxisymmetricQTaylorHoodElement, oomph::GeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement, oomph::TDisplacementBasedFoepplvonKarmanElement< NNODE_1D >, oomph::BiharmonicEquations< DIM >, oomph::FSIHermiteBeamElement, oomph::AxisymmetricTTaylorHoodElement, oomph::AxisymmetricTCrouzeixRaviartElement, oomph::AxisymmetricQTaylorHoodElement, oomph::AxisymmetricQCrouzeixRaviartElement, oomph::AxisymmetricLinearElasticityEquationsBase, RefineableQAdvectionDiffusionElementWithExternalElement< DIM >, RefineableQCrouzeixRaviartElementWithExternalElement< DIM >, RefineableBuoyantQCrouzeixRaviartElement< DIM >, oomph::LinearisedAxisymmetricQTaylorHoodElement, oomph::LinearisedAxisymmetricQCrouzeixRaviartElement, oomph::MyLinearElasticityElement< DIM >, oomph::MultiPoissonEquations< DIM, NFIELDS >, and oomph::MyTaylorHoodElement< DIM >.

    {
      // error message stream
      std::ostringstream error_message;
      error_message << "ndof_types() const has not been implemented for this \n"
                    << "element\n"
                    << std::endl;
      // throw error
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

nexternal_data()

unsigned oomph::GeneralisedElement::nexternal_data ( ) const

inline

Return the number of external data objects.

    {
      return Nexternal_data;
    }

References Nexternal_data.

Referenced by oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), assign_local_eqn_numbers(), oomph::SolidICProblem::backup_original_state(), oomph::ElementElementConstraintElement::build(), oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::fill_in_generic_residual_contribution_fourier_decomposed_helmholtz_DtN_bc(), oomph::HelmholtzDtNBoundaryElement< ELEMENT >::fill_in_generic_residual_contribution_helmholtz_DtN_bc(), oomph::DGElement::get_inverse_mass_matrix_times_residuals(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::set_boundary_shape_geom_object_pt(), and oomph::FluidInterfaceElement::set_external_pressure_data().

ninternal_data()

unsigned oomph::GeneralisedElement::ninternal_data ( ) const

inline

Return the number of internal data objects.

    {
      return Ninternal_data;
    }

References Ninternal_data.

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), assign_local_eqn_numbers(), oomph::SolidICProblem::backup_original_state(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::ElementElementConstraintElement::build(), oomph::Problem::copy(), oomph::FSI_functions::doc_fsi(), oomph::Mesh::does_pointer_correspond_to_mesh_data(), oomph::Mesh::dump(), oomph::Problem::get_dofs(), oomph::PolarCrouzeixRaviartElement::get_load_data(), oomph::FiniteElement::identify_field_data_for_interactions(), oomph::RefineableElement::identify_field_data_for_interactions(), SegregatedFSICollapsibleChannelProblem< ELEMENT >::identify_fluid_and_solid_dofs(), SegregatedFSIDrivenCavityProblem< ELEMENT >::identify_fluid_and_solid_dofs(), oomph::AxisymmetricTCrouzeixRaviartElement::identify_pressure_data(), oomph::GeneralisedNewtonianAxisymmetricTCrouzeixRaviartElement::identify_pressure_data(), oomph::QSphericalCrouzeixRaviartElement::identify_pressure_data(), oomph::MyProblem::my_set_initial_condition(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_all(), FlowAroundCylinderProblem< ELEMENT >::pin_all_base_flow_dofs(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::NavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::SpaceTimeNavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::pin_all_non_pressure_dofs(), oomph::Mesh::read(), oomph::SolidICProblem::reset_original_state(), oomph::NavierStokesSchurComplementPreconditioner::reset_pin_status(), oomph::Mesh::set_consistent_pinned_values_for_continuation(), oomph::Problem::set_dofs(), oomph::Problem::set_pinned_values_to_zero(), oomph::MyProblem::set_up_impulsive_initial_condition(), oomph::SolidICProblem::setup_problem(), and FlowAroundCylinderProblem< ELEMENT >::unpin_all_base_flow_dofs().

operator=()

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

delete

Broken assignment operator.

reset_after_external_fd()

virtual void oomph::GeneralisedElement::reset_after_external_fd ( )

inlineprotectedvirtual

Function that is call after the finite differencing of the external data. This may be overloaded to reset any dependent variables that may have changed during the finite differencing.

Reimplemented in oomph::ImmersedRigidBodyElement, oomph::FSIWallElement, and oomph::FluidInterfaceBoundingElement.

{}

Referenced by fill_in_jacobian_from_external_by_fd().

reset_after_internal_fd()

virtual void oomph::GeneralisedElement::reset_after_internal_fd ( )

inlineprotectedvirtual

Function that is call after the finite differencing of the internal data. This may be overloaded to reset any dependent variables that may have changed during the finite differencing.

Reimplemented in oomph::ImmersedRigidBodyElement, and oomph::FSIWallElement.

{}

Referenced by fill_in_jacobian_from_internal_by_fd().

reset_in_external_fd()

virtual void oomph::GeneralisedElement::reset_in_external_fd ( const unsigned &  i )

inlineprotectedvirtual

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.

Reimplemented in oomph::ImmersedRigidBodyElement, oomph::FSIWallElement, and oomph::FluidInterfaceBoundingElement.

    {
      update_in_external_fd(i);
    }

References i, and update_in_external_fd().

Referenced by fill_in_jacobian_from_external_by_fd().

reset_in_internal_fd()

virtual void oomph::GeneralisedElement::reset_in_internal_fd ( const unsigned &  i )

inlineprotectedvirtual

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.

Reimplemented in oomph::ImmersedRigidBodyElement, and oomph::FSIWallElement.

    {
      update_in_internal_fd(i);
    }

References i, and update_in_internal_fd().

Referenced by fill_in_jacobian_from_internal_by_fd().

self_test()

unsigned GeneralisedElement::self_test ( )

virtual

Self-test: Have all internal values been classified as pinned/unpinned? Return 0 if OK.

Reimplemented in oomph::YoungLaplaceEquations, oomph::WomersleyEquations< DIM >, oomph::UnsteadyHeatEquations< DIM >, oomph::UnsteadyHeatEquations< 2 >, oomph::SteadyAxisymAdvectionDiffusionEquations, oomph::SphericalAdvectionDiffusionEquations, oomph::SpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< 2 >, oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >, oomph::SpaceTimeUnsteadyHeatEquations< 2 >, oomph::PoroelasticityEquations< DIM >, oomph::PoroelasticityEquations< 2 >, oomph::PoissonEquations< DIM >, oomph::PoissonEquations< 1 >, oomph::PoissonEquations< 2 >, oomph::PoissonEquations< 3 >, oomph::PMLHelmholtzEquations< DIM >, oomph::PMLFourierDecomposedHelmholtzEquations, oomph::LinearWaveEquations< DIM >, oomph::HelmholtzEquations< DIM >, oomph::FiniteElement, oomph::FourierDecomposedHelmholtzEquations, oomph::FoepplvonKarmanEquations, oomph::DisplacementBasedFoepplvonKarmanEquations, oomph::DarcyEquations< DIM >, oomph::DarcyEquations< 2 >, oomph::BiharmonicEquations< DIM >, oomph::AxisymmetricPoroelasticityEquations, oomph::AxisymFoepplvonKarmanEquations, oomph::AxisymFoepplvonKarmanEquations, oomph::AxisymAdvectionDiffusionEquations, oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >, oomph::GeneralisedAdvectionDiffusionEquations< DIM >, oomph::GeneralisedAdvectionDiffusionEquations< 2 >, oomph::AdvectionDiffusionEquations< DIM >, oomph::AdvectionDiffusionEquations< 2 >, ModalPRefineableQPoissonElement< DIM >, ModalPoissonEquations< DIM >, TwoNodePoissonElement, and oomph::MultiPoissonEquations< DIM, NFIELDS >.

  {
    // Initialise
    bool passed = true;
 
    // Loop over internal Data
    for (unsigned i = 0; i < Ninternal_data; i++)
    {
      if (internal_data_pt(i)->self_test() != 0)
      {
        passed = false;
        oomph_info << "\n ERROR: Failed GeneralisedElement::self_test()!"
                   << std::endl;
        oomph_info << "for internal data object number: " << i << std::endl;
      }
    }
 
    // Loop over external Data
    for (unsigned i = 0; i < Nexternal_data; i++)
    {
      if (external_data_pt(i)->self_test() != 0)
      {
        passed = false;
        oomph_info << "\n ERROR: Failed GeneralisedElement::self_test()!"
                   << std::endl;
        oomph_info << "for external data object number: " << i << std::endl;
      }
    }
 
    // Return verdict
    if (passed)
    {
      return 0;
    }
    else
    {
      return 1;
    }
  }

References external_data_pt(), i, internal_data_pt(), Nexternal_data, Ninternal_data, and oomph::oomph_info.

Referenced by oomph::FiniteElement::self_test().

set_internal_data_time_stepper()

void oomph::GeneralisedElement::set_internal_data_time_stepper ( const unsigned &  i, TimeStepper *const &  time_stepper_pt, const bool &  preserve_existing_data  )

inline

Set the timestepper associated with the i-th internal data object

    {
      this->internal_data_pt(i)->set_time_stepper(time_stepper_pt,
                                                  preserve_existing_data);
    }

References internal_data_pt(), and oomph::Data::set_time_stepper().

update_before_external_fd()

virtual void oomph::GeneralisedElement::update_before_external_fd ( )

inlineprotectedvirtual

Function that is called before the finite differencing of any external data. This may be overloaded to update any dependent data before finite differencing takes place.

{}

Referenced by fill_in_jacobian_from_external_by_fd().

update_before_internal_fd()

virtual void oomph::GeneralisedElement::update_before_internal_fd ( )

inlineprotectedvirtual

Function that is called before the finite differencing of any internal data. This may be overloaded to update any dependent data before finite differencing takes place.

{}

Referenced by fill_in_jacobian_from_internal_by_fd().

update_in_external_fd()

virtual void oomph::GeneralisedElement::update_in_external_fd ( const unsigned &  i )

inlineprotectedvirtual

Function called within the finite difference loop for external data after a change in any values in the i-th external data object

Reimplemented in oomph::ImmersedRigidBodyElement, oomph::FSIWallElement, and oomph::FluidInterfaceBoundingElement.

{}

Referenced by fill_in_jacobian_from_external_by_fd(), and reset_in_external_fd().

update_in_internal_fd()

virtual void oomph::GeneralisedElement::update_in_internal_fd ( const unsigned &  i )

inlineprotectedvirtual

Function called within the finite difference loop for internal data after a change in any values in the i-th internal data object.

Reimplemented in oomph::ImmersedRigidBodyElement, and oomph::FSIWallElement.

{}

Referenced by fill_in_jacobian_from_internal_by_fd(), and reset_in_internal_fd().

Member Data Documentation

Data_fd

std::vector<bool> oomph::GeneralisedElement::Data_fd

private

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.

Referenced by add_external_data(), add_internal_data(), exclude_external_data_fd(), exclude_internal_data_fd(), external_data_fd(), flush_external_data(), include_external_data_fd(), include_internal_data_fd(), and internal_data_fd().

Data_local_eqn

int** oomph::GeneralisedElement::Data_local_eqn

private

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.

Referenced by assign_internal_and_external_local_eqn_numbers(), external_local_eqn(), internal_local_eqn(), and ~GeneralisedElement().

Data_pt

Data** oomph::GeneralisedElement::Data_pt

private

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.

Referenced by add_external_data(), add_internal_data(), assign_internal_and_external_local_eqn_numbers(), external_data_pt(), flush_external_data(), internal_data_pt(), and ~GeneralisedElement().

Default_fd_jacobian_step

double GeneralisedElement::Default_fd_jacobian_step = 1.0e-8

static

Double used for the default finite difference step in elemental jacobian calculations

Default value used as the increment for finite difference calculations of the jacobian matrices

Referenced by oomph::ConstitutiveLaw::calculate_d_second_piola_kirchhoff_stress_dG(), oomph::FluxTransportEquations< DIM >::dflux_du(), oomph::DGFaceElement::dnumerical_flux_du(), oomph::SpinePointMarangoniSurfactantFluidInterfaceBoundingElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::ConstraintElement::fill_in_contribution_to_residuals(), fill_in_jacobian_from_external_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_field_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_geometric_by_fd(), oomph::ElementWithMovingNodes::fill_in_jacobian_from_geometric_data(), fill_in_jacobian_from_internal_by_fd(), oomph::FiniteElement::fill_in_jacobian_from_nodal_by_fd(), oomph::RefineableElement::fill_in_jacobian_from_nodal_by_fd(), oomph::SolidFiniteElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::AxisymmetricQAdvectionCrouzeixRaviartElement::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::RefineableDoubleBuoyantQCrouzeixRaviartElement< DIM >::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::AxisymmetricNavierStokesEquations::get_body_force_gradient_axi_nst(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_body_force_gradient_axi_nst(), oomph::LinearisedAxisymmetricNavierStokesEquations::get_body_force_gradient_base_flow(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_body_force_gradient_nst(), oomph::NavierStokesEquations< DIM >::get_body_force_gradient_nst(), oomph::SpaceTimeNavierStokesEquations< DIM >::get_body_force_gradient_nst(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::get_body_force_gradient_nst(), oomph::ElementWithMovingNodes::get_dnodal_coordinates_dgeom_dofs(), oomph::AxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::FiniteElement::get_dresidual_dnodal_coordinates(), oomph::RefineableElement::get_dresidual_dnodal_coordinates(), oomph::RefineableNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::SpaceTimeNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableSpaceTimeNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >::get_reaction_deriv_adv_diff_react(), oomph::AxisymmetricNavierStokesEquations::get_source_fct_gradient(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_source_fct_gradient(), oomph::LinearisedAxisymmetricNavierStokesEquations::get_source_gradient_base_flow(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_source_gradient_nst(), oomph::NavierStokesEquations< DIM >::get_source_gradient_nst(), oomph::SpaceTimeNavierStokesEquations< DIM >::get_source_gradient_nst(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::get_source_gradient_nst(), oomph::PoissonEquations< DIM >::get_source_gradient_poisson(), and oomph::FiniteElement::locate_zeta().

Dof_pt

double** oomph::GeneralisedElement::Dof_pt

private

Storage for array of pointers to degrees of freedom ordered by local equation number. This information is not needed, except in continuation, bifurcation tracking and periodic orbit calculations. It is not set up unless the control flag Problem::Store_local_dof_pts_in_elements = true

Referenced by add_global_eqn_numbers(), assign_internal_eqn_numbers(), clear_global_eqn_numbers(), dof_pt_vector(), and dof_vector().

Dof_pt_deque

std::deque< double * > GeneralisedElement::Dof_pt_deque

staticprotected

Static storage for deque used to add_global_equation_numbers when pointers to the dofs in each element are not required

Static storage used when pointers to the dofs are being assembled by add_global_eqn_numbers()

Referenced by oomph::ElementWithMovingNodes::assign_all_generic_local_eqn_numbers(), oomph::SpectralElement::assign_all_generic_local_eqn_numbers(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), oomph::RefineableElement::assign_hanging_local_eqn_numbers(), assign_internal_and_external_local_eqn_numbers(), oomph::FiniteElement::assign_nodal_local_eqn_numbers(), oomph::RefineableSolidElement::assign_solid_hanging_local_eqn_numbers(), and oomph::SolidFiniteElement::assign_solid_local_eqn_numbers().

Dummy_matrix

DenseMatrix< double > GeneralisedElement::Dummy_matrix

staticprotected

Empty dense matrix used as a dummy argument to combined residual and jacobian functions in the case when only the residuals are being assembled

Referenced by oomph::AxisymmetricNavierStokesEquations::fill_in_contribution_to_djacobian_dparameter(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_contribution_to_djacobian_dparameter(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_djacobian_dparameter(), oomph::NavierStokesEquations< DIM >::fill_in_contribution_to_djacobian_dparameter(), oomph::SpaceTimeNavierStokesEquations< DIM >::fill_in_contribution_to_djacobian_dparameter(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::fill_in_contribution_to_djacobian_dparameter(), oomph::AxisymmetricNavierStokesEquations::fill_in_contribution_to_dresiduals_dparameter(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_contribution_to_dresiduals_dparameter(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_dresiduals_dparameter(), oomph::NavierStokesEquations< DIM >::fill_in_contribution_to_dresiduals_dparameter(), oomph::SpaceTimeNavierStokesEquations< DIM >::fill_in_contribution_to_dresiduals_dparameter(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::fill_in_contribution_to_dresiduals_dparameter(), oomph::PeriodicOrbitEquations::fill_in_contribution_to_integrated_residuals(), oomph::LinearisedAxisymmetricNavierStokesEquations::fill_in_contribution_to_jacobian(), MyNavierStokesElement::fill_in_contribution_to_jacobian(), oomph::PolarStreamfunctionTractionElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::AdvectionDiffusionEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::GeneralisedAdvectionDiffusionEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >::fill_in_contribution_to_jacobian(), oomph::AxisymAdvectionDiffusionEquations::fill_in_contribution_to_jacobian(), oomph::fill_in_contribution_to_jacobian(), oomph::AxisymmetricNavierStokesEquations::fill_in_contribution_to_jacobian(), oomph::FluxTransportEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_contribution_to_jacobian(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::NavierStokesEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::PolarNavierStokesTractionElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::PolarNavierStokesEquations::fill_in_contribution_to_jacobian(), oomph::PVDEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::PVDEquationsWithPressure< DIM >::fill_in_contribution_to_jacobian(), oomph::SpaceTimeNavierStokesEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::fill_in_contribution_to_jacobian(), oomph::SphericalAdvectionDiffusionEquations::fill_in_contribution_to_jacobian(), oomph::SphericalNavierStokesEquations::fill_in_contribution_to_jacobian(), oomph::SteadyAxisymAdvectionDiffusionEquations::fill_in_contribution_to_jacobian(), oomph::PolarStreamfunctionTractionElement< ELEMENT >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::PolarNavierStokesTractionElement< ELEMENT >::fill_in_contribution_to_jacobian_and_mass_matrix(), oomph::FluxTransportEquations< DIM >::fill_in_contribution_to_mass_matrix(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::fill_in_contribution_to_residuals(), oomph::SCoupledElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::LinearisedAxisymmetricNavierStokesEquations::fill_in_contribution_to_residuals(), oomph::UnsteadyHeatFluxPseudoMeltElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::HelmholtzPointSourceElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::HomogenisedLinearElasticityEquations< DIM >::fill_in_contribution_to_residuals(), oomph::MultiPoissonEquations< DIM, NFIELDS >::fill_in_contribution_to_residuals(), oomph::LinearisedAxisymmetricFluidInterfaceElement::fill_in_contribution_to_residuals(), DependentPositionPointElement::fill_in_contribution_to_residuals(), SlavePositionPointElement::fill_in_contribution_to_residuals(), oomph::NavierStokesElementWithSingularity< BASIC_NAVIER_STOKES_ELEMENT >::fill_in_contribution_to_residuals(), oomph::PMLHelmholtzPointSourceElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::PolarStreamfunctionTractionElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::PolarStreamfunctionEquations::fill_in_contribution_to_residuals(), oomph::NavierStokesFluxControlElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::AdvectionDiffusionEquations< DIM >::fill_in_contribution_to_residuals(), oomph::AdvectionDiffusionFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::GeneralisedAdvectionDiffusionEquations< DIM >::fill_in_contribution_to_residuals(), oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >::fill_in_contribution_to_residuals(), oomph::AxisymAdvectionDiffusionEquations::fill_in_contribution_to_residuals(), oomph::fill_in_contribution_to_residuals(), oomph::AxisymmetricLinearElasticityEquations::fill_in_contribution_to_residuals(), oomph::LinearisedFSIAxisymmetricNStNoSlipBCElementElement< FLUID_BULK_ELEMENT, SOLID_BULK_ELEMENT >::fill_in_contribution_to_residuals(), oomph::AxisymmetricNavierStokesEquations::fill_in_contribution_to_residuals(), oomph::LinearisedAxisymPoroelasticBJS_FSIElement< FLUID_BULK_ELEMENT, POROELASTICITY_BULK_ELEMENT >::fill_in_contribution_to_residuals(), oomph::AxisymmetricPoroelasticityEquations::fill_in_contribution_to_residuals(), oomph::AxisymmetricPVDEquationsWithPressure::fill_in_contribution_to_residuals(), oomph::DarcyEquations< DIM >::fill_in_contribution_to_residuals(), oomph::FluidInterfaceBoundingElement::fill_in_contribution_to_residuals(), oomph::FluidInterfaceElement::fill_in_contribution_to_residuals(), oomph::FluxTransportEquations< DIM >::fill_in_contribution_to_residuals(), oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::FourierDecomposedHelmholtzEquations::fill_in_contribution_to_residuals(), oomph::FourierDecomposedHelmholtzFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::fill_in_contribution_to_residuals(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_contribution_to_residuals(), oomph::ProjectableElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::HelmholtzAbsorbingBCElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::HelmholtzDtNBoundaryElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::HelmholtzEquations< DIM >::fill_in_contribution_to_residuals(), oomph::HelmholtzFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::LinearElasticityEquations< DIM >::fill_in_contribution_to_residuals(), oomph::LinearWaveEquations< DIM >::fill_in_contribution_to_residuals(), oomph::LinearWaveFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::LinearisedNavierStokesEquations::fill_in_contribution_to_residuals(), oomph::FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >::fill_in_contribution_to_residuals(), oomph::HelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >::fill_in_contribution_to_residuals(), oomph::PMLHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >::fill_in_contribution_to_residuals(), oomph::NavierStokesTractionElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::RefineableNavierStokesTractionElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::ImposeImpenetrabilityElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::ImposeParallelOutflowElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::NavierStokesEquations< DIM >::fill_in_contribution_to_residuals(), oomph::RefineableNavierStokesFluxControlElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::PMLFourierDecomposedHelmholtzEquations::fill_in_contribution_to_residuals(), oomph::PMLFourierDecomposedHelmholtzFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::PMLHelmholtzEquations< DIM >::fill_in_contribution_to_residuals(), oomph::PMLHelmholtzFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::fill_in_contribution_to_residuals(), oomph::PoissonEquations< DIM >::fill_in_contribution_to_residuals(), oomph::PoissonFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::PolarNavierStokesTractionElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::PolarNavierStokesEquations::fill_in_contribution_to_residuals(), oomph::PoroelasticityEquations< DIM >::fill_in_contribution_to_residuals(), oomph::ImmersedRigidBodyElement::fill_in_contribution_to_residuals(), oomph::PVDEquations< DIM >::fill_in_contribution_to_residuals(), oomph::PVDEquationsWithPressure< DIM >::fill_in_contribution_to_residuals(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::RefineableFSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::NavierStokesSpaceTimeTractionElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::RefineableNavierStokesSpaceTimeTractionElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::SpaceTimeNavierStokesEquations< DIM >::fill_in_contribution_to_residuals(), oomph::NavierStokesMixedOrderSpaceTimeTractionElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::RefineableNavierStokesMixedOrderSpaceTimeTractionElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::fill_in_contribution_to_residuals(), oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >::fill_in_contribution_to_residuals(), oomph::SpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >::fill_in_contribution_to_residuals(), oomph::SphericalAdvectionDiffusionEquations::fill_in_contribution_to_residuals(), oomph::SphericalAdvectionDiffusionFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::SphericalNavierStokesEquations::fill_in_contribution_to_residuals(), oomph::SteadyAxisymAdvectionDiffusionEquations::fill_in_contribution_to_residuals(), oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::TimeHarmonicFourierDecomposedLinearElasticityEquations::fill_in_contribution_to_residuals(), oomph::TimeHarmonicLinearElasticityEquations< DIM >::fill_in_contribution_to_residuals(), oomph::UnsteadyHeatEquations< DIM >::fill_in_contribution_to_residuals(), oomph::UnsteadyHeatFluxElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::WomersleyEquations< DIM >::fill_in_contribution_to_residuals(), oomph::NavierStokesImpedanceTractionElement< BULK_NAVIER_STOKES_ELEMENT, WOMERSLEY_ELEMENT, DIM >::fill_in_contribution_to_residuals(), oomph::NavierStokesWomersleyPressureControlElement::fill_in_contribution_to_residuals(), oomph::NodeElementSolidOnlyMortaringElement::fill_in_contribution_to_residuals(), oomph::NodeNodeMortaringElement::fill_in_contribution_to_residuals(), oomph::ScaleCoupledElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::VolumeCoupledElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::NavierStokesElementWithSingularity< BASIC_NAVIER_STOKES_ELEMENT >::fill_in_generic_residual_contribution_wrapped_nst(), oomph::NavierStokesEquations< DIM >::fill_in_pressure_advection_diffusion_residuals(), oomph::SpaceTimeNavierStokesEquations< DIM >::fill_in_pressure_advection_diffusion_residuals(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::fill_in_pressure_advection_diffusion_residuals(), and oomph::SolidFiniteElement::fill_in_residuals_for_solid_ic().

Eqn_number

unsigned long* oomph::GeneralisedElement::Eqn_number

private

Storage for the global equation numbers represented by the degrees of freedom in the element.

Referenced by add_global_eqn_numbers(), assign_local_eqn_numbers(), clear_global_eqn_numbers(), eqn_number(), local_eqn_number(), and ~GeneralisedElement().

Ndof

unsigned oomph::GeneralisedElement::Ndof

private

Number of degrees of freedom.

Referenced by add_global_eqn_numbers(), assign_local_eqn_numbers(), clear_global_eqn_numbers(), dof_pt_vector(), dof_vector(), eqn_number(), fill_in_contribution_to_jacobian(), fill_in_jacobian_from_external_by_fd(), fill_in_jacobian_from_internal_by_fd(), local_eqn_number(), and ndof().

Nexternal_data

unsigned oomph::GeneralisedElement::Nexternal_data

private

Number of external data.

Referenced by add_external_data(), add_internal_data(), assign_internal_and_external_local_eqn_numbers(), describe_local_dofs(), exclude_external_data_fd(), external_data_fd(), external_data_pt(), external_local_eqn(), fill_in_jacobian_from_external_by_fd(), flush_external_data(), include_external_data_fd(), nexternal_data(), and self_test().

Ninternal_data

unsigned oomph::GeneralisedElement::Ninternal_data

private

Number of internal data.

Referenced by add_external_data(), add_internal_data(), add_internal_value_pt_to_map(), assign_internal_and_external_local_eqn_numbers(), assign_internal_eqn_numbers(), describe_dofs(), describe_local_dofs(), exclude_external_data_fd(), exclude_internal_data_fd(), external_data_fd(), external_data_pt(), external_local_eqn(), fill_in_jacobian_from_internal_by_fd(), flush_external_data(), include_external_data_fd(), include_internal_data_fd(), internal_data_fd(), internal_data_pt(), internal_local_eqn(), ninternal_data(), self_test(), and ~GeneralisedElement().

Suppress_warning_about_repeated_external_data

bool GeneralisedElement::Suppress_warning_about_repeated_external_data = true

static

Static boolean to suppress warnings about repeated external data. Defaults to true.

Static boolean to suppress warnings about repeated external data. Defaults to true

Referenced by add_external_data().

Suppress_warning_about_repeated_internal_data

bool GeneralisedElement::Suppress_warning_about_repeated_internal_data

static

Initial value:

=
    false

Static boolean to suppress warnings about repeated internal data. Defaults to false.

Static boolean to suppress warnings about repeated internal data. Defaults to false

Referenced by add_internal_data().

---

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

• elements.h
• elements.cc