interpolate_from_integral_points.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
// Augments an element to be able to interpolate from integral points to the nodes
// This is useful when we only know data at the integral points but for whatever reason
// need to be able to calculate it at the nodes.
// E.g. if data can only be taken from an external element which can only be done at the integral points
//  but we want to be able to interpolate it to some point in this element.
// OR if the data can only be found at the integral points by taking from an external element
//  but we want to use the data for providing a z2 error measure
 
#ifndef INTERPOLATE_FROM_INTEGRAL_POINTS_HEADER
#define INTERPOLATE_FROM_INTEGRAL_POINTS_HEADER
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
#include "../../../oomph-lib/src/generic/elements.h"
#include "../../../oomph-lib/src/generic/shape.h"
#include "../../../oomph-lib/src/generic/linear_solver.h"
#include "../../../oomph-lib/src/generic/stored_shape_function_elements.h"
namespace oomph
{
 
class InterpolateFromIntegralPointsBase : public virtual FiniteElement
{
public:
 InterpolateFromIntegralPointsBase() : FiniteElement(),
                                       Can_delete_inverse_mapping_stored(true),
                                       Inverse_mapping_pt(0)
 {}
 
 ~InterpolateFromIntegralPointsBase()
 {
  delete_all_ipt_to_node_mapping();
 }
 
 // Const access to pointer to the inverse mapping data
 inline DenseMatrix<double>* const& inverse_mapping_pt() const
 {
  return Inverse_mapping_pt;
 }
 
 // Set the integration scheme, set the scheme according to the base element then compute the integral point to node mapping
 void set_integration_scheme(Integral* const& integral_pt)
 {
  // Call the base class to handle assigning integration scheme
  FiniteElement::set_integration_scheme(integral_pt);
 
  // Compute the inverse mapping of the matrix
  pre_compute_ipt_to_node_mapping();
 }
 
 // We need a OomphCommunicator in order to create a linear solver to invert the mapping
 //  from the nodes to the integral points
 void set_communicator_pt(OomphCommunicator* communicator_pt)
 {
  Communicator_pt = communicator_pt;
 }
 
 // Fill in the matrix mapping from the integral points to the nodes of the element
 void pre_compute_ipt_to_node_mapping();
 
 // Set the matrix mapping from the integral points to the nodes of the element from that stored in another element
 void set_compute_ipt_to_node_mapping_from_element(InterpolateFromIntegralPointsBase* const& element_pt);
 
 // Return the weight stored for mapping from the ipt-th integral point to the n-th node.
 inline double integral_point_to_node_weight(const unsigned& ipt, const unsigned& n)
 {
  return (*Inverse_mapping_pt)(n, ipt);
 }
 
private:
 // Delete the matrix mapping from the integral points to the nodes of the element
 void delete_all_ipt_to_node_mapping();
 
 // Pointer to the communicator
 OomphCommunicator* Communicator_pt;
 
 // Pointer to the inverse mapping - the mapping from the integral points to the nodes
 // DenseDoubleMatrix to inherit solving functionality from DoubleMatrix class
 DenseMatrix<double>* Inverse_mapping_pt;
 
 // If the element can delete the Inverse_mapping_pt data
 bool Can_delete_inverse_mapping_stored;
};
 
template<class ELEMENT>
class InterpolateFromIntegralPointsFaceElement : public virtual ELEMENT,
                                                 public virtual InterpolateFromIntegralPointsBase
{
public:
 InterpolateFromIntegralPointsFaceElement(FiniteElement* const& element_pt,
                                          const int& face_index,
                                          const bool& called_from_refineable_constructor = false)
                                          : InterpolateFromIntegralPointsBase(),
                                            ELEMENT(element_pt, face_index, called_from_refineable_constructor)
 {}
 
 ~InterpolateFromIntegralPointsFaceElement() {}
};
 
} // End namespace
#endif