SamplePointContainer Class Reference

Base class for all sample point containers. More...

#include <sample_point_container.h>

Inheritance diagram for SamplePointContainer:

Public Member Functions
	SamplePointContainer (Mesh *mesh_pt, const Vector< std::pair< double, double >> &min_and_max_coordinates, const bool &use_eulerian_coordinates_during_setup, const bool &ignore_halo_elements_during_locate_zeta_search, const unsigned &nsample_points_generated_per_element)
	Constructor. More...
	SamplePointContainer ()
	SamplePointContainer (const SamplePointContainer &data)=delete
	Broken copy constructor. More...
void	operator= (const SamplePointContainer &)=delete
	Broken assignment operator. More...
virtual	~SamplePointContainer ()
	Virtual destructor. More...
virtual void	locate_zeta (const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s)=0
virtual unsigned &	total_number_of_sample_points_visited_during_locate_zeta_from_top_level ()
virtual unsigned	total_number_of_sample_points_computed_recursively () const =0
virtual unsigned	ndim_zeta () const =0
	Dimension of the zeta ( = dim of local coordinate of elements) More...
Mesh *	mesh_pt () const
	Pointer to mesh from whose FiniteElements sample points are created. More...
const std::pair< double, double > &	min_and_max_coordinates (const unsigned &i) const
const Vector< std::pair< double, double > > &	min_and_max_coordinates () const
bool	use_eulerian_coordinates_during_setup () const
unsigned &	nsample_points_generated_per_element ()
	"Measure of" number of sample points generated in each element More...
double &	max_search_radius ()

Static Public Attributes
static std::ofstream	Visited_sample_points_file
	File to record sequence of visited sample points in. More...
static bool	Always_fail_elemental_locate_zeta = false
	Boolean flag to make to make locate zeta fail. More...
static bool	Use_equally_spaced_interior_sample_points = true
static bool	Enable_timing_of_setup = false
	Time setup? More...
static double	Percentage_offset = 5.0
	Offset of sample point container boundaries beyond max/min coords. More...

Protected Member Functions
void	setup_min_and_max_coordinates ()
	Setup the min and max coordinates for the mesh, in each dimension. More...

Protected Attributes
Mesh *	Mesh_pt
	Pointer to mesh from whose FiniteElements sample points are created. More...
Vector< std::pair< double, double > >	Min_and_max_coordinates
bool	Use_eulerian_coordinates_during_setup
unsigned	Nsample_points_generated_per_element
	"Measure of" number of sample points generated in each element More...
unsigned	Total_number_of_sample_points_visited_during_locate_zeta_from_top_level
double	Max_search_radius

Detailed Description

Base class for all sample point containers.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

Constructor & Destructor Documentation

SamplePointContainer() [1/3]

SamplePointContainer::SamplePointContainer ( Mesh *  mesh_pt, const Vector< std::pair< double, double >> &  min_and_max_coordinates, const bool &  use_eulerian_coordinates_during_setup, const bool &  ignore_halo_elements_during_locate_zeta_search, const unsigned &  nsample_points_generated_per_element  )

inline

Constructor.

    : Mesh_pt(mesh_pt),
      Min_and_max_coordinates(min_and_max_coordinates),
      Use_eulerian_coordinates_during_setup(
        use_eulerian_coordinates_during_setup),
#ifdef OOMPH_HAS_MPI
      Ignore_halo_elements_during_locate_zeta_search(
        ignore_halo_elements_during_locate_zeta_search),
#endif
      Nsample_points_generated_per_element(
        nsample_points_generated_per_element),
      Total_number_of_sample_points_visited_during_locate_zeta_from_top_level(0)
  {
    // Don't limit max. search radius
    Max_search_radius = DBL_MAX;
  }

References Max_search_radius.

SamplePointContainer() [2/3]

SamplePointContainer::SamplePointContainer ( )

inline

Broken default constructor; needed for broken copy constructors. Don't call. It will die.

  {
    // Throw the error
    throw OomphLibError("Broken default constructor. Don't call this!",
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

SamplePointContainer() [3/3]

SamplePointContainer::SamplePointContainer ( const SamplePointContainer &  data )

delete

Broken copy constructor.

~SamplePointContainer()

virtual SamplePointContainer::~SamplePointContainer ( )

inlinevirtual

Virtual destructor.

{}

Member Function Documentation

locate_zeta()

virtual void SamplePointContainer::locate_zeta ( const Vector< double > &  zeta, GeomObject *&  sub_geom_object_pt, Vector< double > &  s  )

pure virtual

Find sub-GeomObject (finite element) and the local coordinate s within it that contains point with global coordinate zeta. sub_geom_object_pt=0 if point can't be found.

Implemented in NonRefineableBinArray, and RefineableBinArray.

Referenced by oomph::MeshAsGeomObject::locate_zeta().

max_search_radius()

double& SamplePointContainer::max_search_radius ( )

inline

Set maximum search radius for locate zeta. This is initialised do DBL_MAX so we brutally search through the entire bin structure, no matter how big it is until we've found the required point (or failed to do so. This can be VERY costly with fine meshes. Here the user takes full responsibility and states that we have no chance in hell to find the required point in a bin whose closest vertex is further than the specified max search radius.

  {
    return Max_search_radius;
  }

References Max_search_radius.

Referenced by RefineableBinArray::locate_zeta(), and oomph::LineVisualiser::setup().

mesh_pt()

Mesh* SamplePointContainer::mesh_pt ( ) const

inline

Pointer to mesh from whose FiniteElements sample points are created.

  {
    return Mesh_pt;
  }

References Mesh_pt.

min_and_max_coordinates() [1/2]

const Vector<std::pair<double, double> >& SamplePointContainer::min_and_max_coordinates ( ) const

inline

Vector of pair of doubles for min and maximum coordinates. min (first) and max. (second) coordinates

  {
    return Min_and_max_coordinates;
  }

References Min_and_max_coordinates.

Referenced by RefineableBinArray::output_neighbouring_bins().

min_and_max_coordinates() [2/2]

const std::pair<double, double>& SamplePointContainer::min_and_max_coordinates ( const unsigned &  i ) const

inline

Pair of doubles for min and maximum coordinates in i-th direction: min (first) and max. (second) coordinates

  {
    return Min_and_max_coordinates[i];
  }

References i, and Min_and_max_coordinates.

Referenced by oomph::RefineableGmshTetMesh< ELEMENT >::adapt().

ndim_zeta()

virtual unsigned SamplePointContainer::ndim_zeta ( ) const

pure virtual

Dimension of the zeta ( = dim of local coordinate of elements)

Implemented in BinArray.

nsample_points_generated_per_element()

unsigned& SamplePointContainer::nsample_points_generated_per_element ( )

inline

"Measure of" number of sample points generated in each element

  {
    return Nsample_points_generated_per_element;
  }

References Nsample_points_generated_per_element.

operator=()

void SamplePointContainer::operator= ( const SamplePointContainer &  )

delete

Broken assignment operator.

setup_min_and_max_coordinates()

void SamplePointContainer::setup_min_and_max_coordinates ( )

protected

Setup the min and max coordinates for the mesh, in each dimension.

Helper function to compute the min and max coordinates for the mesh, in each dimension

  {
    // Get the lagrangian dimension
    int n_lagrangian = ndim_zeta();
 
    // Storage locally (i.e. in parallel on each processor)
    // for the minimum and maximum coordinates
    double zeta_min_local[n_lagrangian];
    double zeta_max_local[n_lagrangian];
    for (int i = 0; i < n_lagrangian; i++)
    {
      zeta_min_local[i] = DBL_MAX;
      zeta_max_local[i] = -DBL_MAX;
    }
 
    // Loop over the elements of the mesh
    unsigned n_el = Mesh_pt->nelement();
    for (unsigned e = 0; e < n_el; e++)
    {
      FiniteElement* el_pt = Mesh_pt->finite_element_pt(e);
 
      // Get the number of vertices (nplot=2 does the trick)
      unsigned n_plot = 2;
      unsigned n_plot_points = el_pt->nplot_points(n_plot);
 
      // Loop over the number of plot points
      for (unsigned iplot = 0; iplot < n_plot_points; iplot++)
      {
        Vector<double> s_local(n_lagrangian);
        Vector<double> zeta_global(n_lagrangian);
 
        // Get the local s -- need to sample over the entire range
        // of the elements!
        bool use_equally_spaced_interior_sample_points = false;
        el_pt->get_s_plot(
          iplot, n_plot, s_local, use_equally_spaced_interior_sample_points);
 
        // Now interpolate to global coordinates
        if (Use_eulerian_coordinates_during_setup)
        {
          el_pt->interpolated_x(s_local, zeta_global);
        }
        else
        {
          el_pt->interpolated_zeta(s_local, zeta_global);
        }
 
        // Check the max and min in each direction
        for (int i = 0; i < n_lagrangian; i++)
        {
          // Is the coordinate less than the minimum?
          if (zeta_global[i] < zeta_min_local[i])
          {
            zeta_min_local[i] = zeta_global[i];
          }
          // Is the coordinate bigger than the maximum?
          if (zeta_global[i] > zeta_max_local[i])
          {
            zeta_max_local[i] = zeta_global[i];
          }
        }
      }
    }
 
    // Global extrema - in parallel, need to get max/min across all processors
    double zeta_min[n_lagrangian];
    double zeta_max[n_lagrangian];
    for (int i = 0; i < n_lagrangian; i++)
    {
      zeta_min[i] = 0.0;
      zeta_max[i] = 0.0;
    }
 
#ifdef OOMPH_HAS_MPI
    // If the mesh has been distributed and we want consistent bins
    // across all processors
    if (Mesh_pt->is_mesh_distributed())
    {
      // .. we need a non-null communicator!
      if (Mesh_pt->communicator_pt() != 0)
      {
        int n_proc = Mesh_pt->communicator_pt()->nproc();
        if (n_proc > 1)
        {
          // Get the minima and maxima over all processors
          MPI_Allreduce(zeta_min_local,
                        zeta_min,
                        n_lagrangian,
                        MPI_DOUBLE,
                        MPI_MIN,
                        Mesh_pt->communicator_pt()->mpi_comm());
          MPI_Allreduce(zeta_max_local,
                        zeta_max,
                        n_lagrangian,
                        MPI_DOUBLE,
                        MPI_MAX,
                        Mesh_pt->communicator_pt()->mpi_comm());
        }
      }
      else // Null communicator - throw an error
      {
        std::ostringstream error_message_stream;
        error_message_stream << "Communicator not set for a Mesh\n"
                             << "that was created from a distributed Mesh";
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
    else // If the mesh hasn't been distributed then the
    // max and min are the same on all processors
    {
      for (int i = 0; i < n_lagrangian; i++)
      {
        zeta_min[i] = zeta_min_local[i];
        zeta_max[i] = zeta_max_local[i];
      }
    }
#else // If we're not using MPI then the mesh can't be distributed
    for (int i = 0; i < n_lagrangian; i++)
    {
      zeta_min[i] = zeta_min_local[i];
      zeta_max[i] = zeta_max_local[i];
    }
#endif
 
    // Decrease/increase min and max to allow for any overshoot in
    // meshes that may move around
    // There's no point in doing this for DIM_LAGRANGIAN==1
    for (int i = 0; i < n_lagrangian; i++)
    {
      double length = zeta_max[i] - zeta_min[i];
      zeta_min[i] -= ((Percentage_offset / 100.0) * length);
      zeta_max[i] += ((Percentage_offset / 100.0) * length);
    }
 
    // Set the entries as the Min/Max_coords vector
    Min_and_max_coordinates.resize(n_lagrangian);
    for (int i = 0; i < n_lagrangian; i++)
    {
      Min_and_max_coordinates[i].first = zeta_min[i];
      Min_and_max_coordinates[i].second = zeta_max[i];
    }
  }

References e(), i, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by NonRefineableBinArray::NonRefineableBinArray(), and RefineableBinArray::RefineableBinArray().

total_number_of_sample_points_computed_recursively()

virtual unsigned SamplePointContainer::total_number_of_sample_points_computed_recursively ( ) const

pure virtual

Total number of sample points in sample point container, possibly computed recursively.

Implemented in NonRefineableBinArray, and RefineableBinArray.

total_number_of_sample_points_visited_during_locate_zeta_from_top_level()

virtual unsigned& SamplePointContainer::total_number_of_sample_points_visited_during_locate_zeta_from_top_level ( )

inlinevirtual

Counter to keep track of how many sample points we've visited during top level call to locate_zeta. Virtual so it can be overloaded for different versions.

Reimplemented in RefineableBinArray.

  {
    return Total_number_of_sample_points_visited_during_locate_zeta_from_top_level;
  }

References Total_number_of_sample_points_visited_during_locate_zeta_from_top_level.

Referenced by NonRefineableBinArray::locate_zeta().

use_eulerian_coordinates_during_setup()

bool SamplePointContainer::use_eulerian_coordinates_during_setup ( ) const

inline

Use Eulerian coordinates (i.e. interpolated_x) rather than zeta itself (i.e. interpolated_zeta) to identify point.

  {
    return Use_eulerian_coordinates_during_setup;
  }

References Use_eulerian_coordinates_during_setup.

Referenced by NonRefineableBinArray::locate_zeta().

Member Data Documentation

Always_fail_elemental_locate_zeta

bool SamplePointContainer::Always_fail_elemental_locate_zeta = false

static

Boolean flag to make to make locate zeta fail.

Boolean flag to make to make locate zeta fail. Used for debugging/ illustration of search procedures.

Referenced by check_locate_zeta(), RefineableBin::locate_zeta(), RefineableBinArray::locate_zeta(), and NonRefineableBinArray::locate_zeta().

Enable_timing_of_setup

bool SamplePointContainer::Enable_timing_of_setup = false

static

Time setup?

Referenced by NonRefineableBinArray::NonRefineableBinArray(), and RefineableBinArray::RefineableBinArray().

Max_search_radius

double SamplePointContainer::Max_search_radius

protected

Max radius beyond which we stop searching the bin. Initialised to DBL_MAX so keep going until the point is found or until we've searched every single bin. Overwriting this means we won't search in bins whose closest vertex is at a distance greater than Max_search_radius from the point to be located.

Referenced by NonRefineableBinArray::locate_zeta(), max_search_radius(), and SamplePointContainer().

Mesh_pt

Mesh* SamplePointContainer::Mesh_pt

protected

Pointer to mesh from whose FiniteElements sample points are created.

Referenced by RefineableBinArray::fill_bin_array(), NonRefineableBinArray::fill_bin_array(), mesh_pt(), NonRefineableBinArray::NonRefineableBinArray(), and RefineableBinArray::RefineableBinArray().

Min_and_max_coordinates

Vector<std::pair<double, double> > SamplePointContainer::Min_and_max_coordinates

protected

Vector of pairs of doubles for min and maximum coordinates. Call: Min_and_max_coordinates[j] gives me the pair of min (first) and max. (second) coordinates in the j-th coordinate direction.

Referenced by BinArray::coords_to_bin_index(), BinArray::coords_to_vectorial_bin_index(), RefineableBinArray::fill_bin_array(), NonRefineableBinArray::fill_bin_array(), NonRefineableBinArray::get_bin(), RefineableBinArray::get_bin_boundaries(), NonRefineableBinArray::get_bin_vertices(), RefineableBinArray::locate_zeta(), NonRefineableBinArray::locate_zeta(), min_and_max_coordinates(), NonRefineableBinArray::NonRefineableBinArray(), RefineableBinArray::output_neighbouring_bins(), BinArray::profile_get_neighbouring_bins_helper(), and RefineableBinArray::RefineableBinArray().

Nsample_points_generated_per_element

unsigned SamplePointContainer::Nsample_points_generated_per_element

protected

"Measure of" number of sample points generated in each element

Referenced by RefineableBinArray::fill_bin_array(), NonRefineableBinArray::fill_bin_array(), and nsample_points_generated_per_element().

Percentage_offset

double SamplePointContainer::Percentage_offset = 5.0

static

Offset of sample point container boundaries beyond max/min coords.

Referenced by NonRefineableBinArray::fill_bin_array().

Total_number_of_sample_points_visited_during_locate_zeta_from_top_level

unsigned SamplePointContainer::Total_number_of_sample_points_visited_during_locate_zeta_from_top_level

protected

Counter to keep track of how many sample points we've visited during top level call to locate_zeta

Referenced by RefineableBinArray::locate_zeta(), NonRefineableBinArray::locate_zeta(), RefineableBinArray::RefineableBinArray(), total_number_of_sample_points_visited_during_locate_zeta_from_top_level(), and RefineableBinArray::total_number_of_sample_points_visited_during_locate_zeta_from_top_level().

Use_equally_spaced_interior_sample_points

bool SamplePointContainer::Use_equally_spaced_interior_sample_points = true

static

Use equally spaced sample points? (otherwise vertices are sampled repeatedly

Referenced by RefineableBinArray::fill_bin_array(), NonRefineableBinArray::fill_bin_array(), and RefineableBin::locate_zeta().

Use_eulerian_coordinates_during_setup

bool SamplePointContainer::Use_eulerian_coordinates_during_setup

protected

Use Eulerian coordinates (i.e. interpolated_x) rather than zeta itself (i.e. interpolated_zeta) to identify point.

Referenced by RefineableBinArray::fill_bin_array(), NonRefineableBinArray::fill_bin_array(), NonRefineableBinArray::output_bins(), and use_eulerian_coordinates_during_setup().

Visited_sample_points_file

std::ofstream SamplePointContainer::Visited_sample_points_file

static

File to record sequence of visited sample points in.

File to record sequence of visited sample points in. Used for debugging/ illustration of search procedures.

/////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// SamplePointContainer base class /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////

Referenced by check_locate_zeta(), RefineableBin::locate_zeta(), and NonRefineableBinArray::locate_zeta().

---

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

• sample_point_container.h
• sample_point_container.cc