RefineableBinArray Class Reference

RefineableBinArray class. More...

#include <sample_point_container.h>

Inheritance diagram for RefineableBinArray:

Public Member Functions
	RefineableBinArray (SamplePointContainerParameters *bin_array_parameters_pt)
	Constructor. More...
	RefineableBinArray (const RefineableBinArray &data)=delete
	Broken copy constructor. More...
void	operator= (const RefineableBinArray &)=delete
	Broken assignment operator. More...
	~RefineableBinArray ()
	Destructor. More...
RefineableBinArray *	root_bin_array_pt () const
	Root bin array. More...
RefineableBin *	bin_pt (const unsigned &i) const
	Pointer to i-th bin; can be null if bin is empty. More...
unsigned	nbin () const
	Number of bins (not taking recursion into account) More...
unsigned	total_number_of_sample_points_computed_recursively () const
	Compute total number of sample points recursively. More...
void	fill_bin_array (const Vector< SamplePoint * > &sample_point_pt)
	Fill the bin array with specified SamplePoints. More...
void	add_sample_point (SamplePoint *new_sample_point_pt, const Vector< double > &zeta)
	Add specified SamplePoint to RefineableBinArray. More...
void	locate_zeta (const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s)
void	get_bin_boundaries (const unsigned &bin_index, Vector< std::pair< double, double >> &min_and_max_coordinates)
unsigned	depth () const
	Depth of the hierarchical bin_array. More...
unsigned	max_depth () const
	Max depth of the hierarchical bin_array; const version. More...
unsigned &	max_depth ()
	Max depth of the hierarchical bin_array. More...
bool	bin_array_is_recursive () const
	Is the BinArray recursive? More...
unsigned	max_number_of_sample_point_per_bin () const
void	output_bins (std::ofstream &outfile)
	Output bins. More...
void	output_bin_vertices (std::ofstream &outfile)
	Output bin vertices (allowing display of bins as zones). More...
void	output_neighbouring_bins (const unsigned &bin_index, const unsigned &radius, std::ofstream &outfile)
	Output neighbouring bins at given "radius" of the specified bin. More...
unsigned &	total_number_of_sample_points_visited_during_locate_zeta_from_top_level ()
unsigned &	first_sample_point_to_actually_lookup_during_locate_zeta ()
unsigned &	last_sample_point_to_actually_lookup_during_locate_zeta ()
unsigned &	multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta ()
unsigned &	initial_last_sample_point_to_actually_lookup_during_locate_zeta ()
Public Member Functions inherited from BinArray
	BinArray (Mesh *mesh_pt, const Vector< std::pair< double, double >> &min_and_max_coordinates, const Vector< unsigned > &dimensions_of_bin_array, 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...
	BinArray ()
	BinArray (const BinArray &data)=delete
	Broken copy constructor. More...
void	operator= (const BinArray &)=delete
	Broken assignment operator. More...
virtual	~BinArray ()
	Virtual destructor. More...
void	get_neighbouring_bins_helper (const unsigned &bin_index, const unsigned &radius, Vector< unsigned > &neighbouring_bin_index, const bool &use_old_version=true)
void	profile_get_neighbouring_bins_helper ()
unsigned	coords_to_bin_index (const Vector< double > &zeta)
void	coords_to_vectorial_bin_index (const Vector< double > &zeta, Vector< unsigned > &bin_index)
	Get "coordinates" of bin that contains specified zeta. More...
unsigned	max_bin_dimension () const
	Max. bin dimension (number of bins in coordinate directions) More...
unsigned	ndim_zeta () const
	Dimension of the zeta ( = dim of local coordinate of elements) More...
unsigned	dimension_of_bin_array (const unsigned &i) const
	Number of bins in coordinate direction i. More...
Vector< unsigned >	dimensions_of_bin_array () const
unsigned	dimensions_of_bin_array (const unsigned &i) const
	Number of bins in specified coordinate direction. More...
Public Member Functions inherited from 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)
	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...
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 unsigned	Default_n_bin_1d = 5
	Default number of bins (in each coordinate direction) More...
Static Public Attributes inherited from SamplePointContainer
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...

Private Member Functions
void	fill_bin_array ()
	Fill the bin array with sample points from FiniteElements stored in mesh. More...
void	create_sample_points_from_element (FiniteElement *const element_pt, const unsigned &n_element)

Private Attributes
Vector< RefineableBin * >	Bin_pt
	Vector of pointers to constituent RefineableBins. More...
bool	Bin_array_is_recursive
unsigned	Depth
unsigned	Max_depth
	Max depth of the hierarchical bin_array. More...
unsigned	Max_number_of_sample_point_per_bin
RefineableBinArray *	Root_bin_array_pt
	Pointer to root bin array. More...
unsigned	First_sample_point_to_actually_lookup_during_locate_zeta
unsigned	Last_sample_point_to_actually_lookup_during_locate_zeta
unsigned	Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta
unsigned	Initial_last_sample_point_to_actually_lookup_during_locate_zeta

Additional Inherited Members
Protected Member Functions inherited from SamplePointContainer
void	setup_min_and_max_coordinates ()
	Setup the min and max coordinates for the mesh, in each dimension. More...
Protected Attributes inherited from BinArray
Vector< unsigned >	Dimensions_of_bin_array
	Number of bins in each coordinate direction. More...
Protected Attributes inherited from SamplePointContainer
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

RefineableBinArray class.

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

Constructor & Destructor Documentation

RefineableBinArray() [1/2]

RefineableBinArray::RefineableBinArray

(

SamplePointContainerParameters *

sample_point_container_parameters_pt

)

Constructor.

/////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// RefineableBin array class /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////

    : SamplePointContainer(
        sample_point_container_parameters_pt->mesh_pt(),
        sample_point_container_parameters_pt->min_and_max_coordinates(),
        sample_point_container_parameters_pt
          ->use_eulerian_coordinates_during_setup(),
        sample_point_container_parameters_pt
          ->ignore_halo_elements_during_locate_zeta_search(),
        sample_point_container_parameters_pt
          ->nsample_points_generated_per_element()),
      BinArray(
        sample_point_container_parameters_pt->mesh_pt(),
        sample_point_container_parameters_pt->min_and_max_coordinates(),
        dynamic_cast<BinArrayParameters*>(sample_point_container_parameters_pt)
          ->dimensions_of_bin_array(),
        sample_point_container_parameters_pt
          ->use_eulerian_coordinates_during_setup(),
        sample_point_container_parameters_pt
          ->ignore_halo_elements_during_locate_zeta_search(),
        sample_point_container_parameters_pt
          ->nsample_points_generated_per_element())
  {
    RefineableBinArrayParameters* ref_bin_array_parameters_pt =
      dynamic_cast<RefineableBinArrayParameters*>(
        sample_point_container_parameters_pt);
 
#ifdef PARANOID
    if (ref_bin_array_parameters_pt == 0)
    {
      throw OomphLibError("Wrong sample_point_container_parameters_pt",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    Bin_array_is_recursive =
      ref_bin_array_parameters_pt->bin_array_is_recursive();
    Depth = ref_bin_array_parameters_pt->depth();
    Max_depth = ref_bin_array_parameters_pt->max_depth();
    Max_number_of_sample_point_per_bin =
      ref_bin_array_parameters_pt->max_number_of_sample_point_per_bin();
    Root_bin_array_pt = ref_bin_array_parameters_pt->root_bin_array_pt();
 
    // Set default size of bin array (and spatial dimension!)
    if (Dimensions_of_bin_array.size() == 0)
    {
      int dim = 0;
      if (Mesh_pt->nelement() != 0)
      {
        dim = Mesh_pt->finite_element_pt(0)->dim();
      }
 
      // Need to do an Allreduce to ensure that the dimension is consistent
      // even when no elements are assigned to a certain processor
#ifdef OOMPH_HAS_MPI
      // Only a problem if the mesh has been distributed
      if (Mesh_pt->is_mesh_distributed())
      {
        // Need a non-null communicator
        if (Mesh_pt->communicator_pt() != 0)
        {
          int n_proc = Mesh_pt->communicator_pt()->nproc();
          if (n_proc > 1)
          {
            int dim_reduce;
            MPI_Allreduce(&dim,
                          &dim_reduce,
                          1,
                          MPI_INT,
                          MPI_MAX,
                          Mesh_pt->communicator_pt()->mpi_comm());
            dim = dim_reduce;
          }
        }
      }
#endif
 
      Dimensions_of_bin_array.resize(dim, Default_n_bin_1d);
    }
 
    // Have we specified max/min coordinates?
    // If not, compute them on the fly from mesh
    if (Min_and_max_coordinates.size() == 0)
    {
      setup_min_and_max_coordinates();
    }
 
    // Get total number of bins and make space
    unsigned dim = Dimensions_of_bin_array.size();
    unsigned n_bin = 1;
    for (unsigned i = 0; i < dim; i++)
    {
      n_bin *= Dimensions_of_bin_array[i];
    }
    Bin_pt.resize(n_bin, 0);
 
    // I'm my own root bin array
    if (Depth == 0)
    {
      Root_bin_array_pt = this;
    }
 
#ifdef PARANOID
    if (Depth > 0)
    {
      if (Root_bin_array_pt == 0)
      {
        throw OomphLibError(
          "Must specify root_bin_array for lower-level bin arrays\n",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
 
    // Initialise
    Total_number_of_sample_points_visited_during_locate_zeta_from_top_level = 0;
    First_sample_point_to_actually_lookup_during_locate_zeta = 0;
    Last_sample_point_to_actually_lookup_during_locate_zeta = UINT_MAX;
    Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta =
      2; // hierher tune this and create public static default
    Initial_last_sample_point_to_actually_lookup_during_locate_zeta =
      10; // hierher UINT MAX is temporary bypass! tune this  and create public
          // static default
 
    // Now fill the bastard...
    if (Depth == 0)
    {
      // Time it
      double t_start = 0.0;
      if (SamplePointContainer::Enable_timing_of_setup)
      {
        t_start = TimingHelpers::timer();
      }
      fill_bin_array();
      if (SamplePointContainer::Enable_timing_of_setup)
      {
        double t_end = TimingHelpers::timer();
        unsigned npts = total_number_of_sample_points_computed_recursively();
        oomph_info << "Time for setup of " << dim
                   << "-dimensional sample point container containing " << npts
                   << " sample points: " << t_end - t_start
                   << " sec  (ref_bin); third party: 0 sec ( = 0 %)"
                   << std::endl;
      }
    }
  }

References Bin_array_is_recursive, Bin_pt, Default_n_bin_1d, Depth, BinArray::Dimensions_of_bin_array, SamplePointContainer::Enable_timing_of_setup, fill_bin_array(), First_sample_point_to_actually_lookup_during_locate_zeta, i, Initial_last_sample_point_to_actually_lookup_during_locate_zeta, Last_sample_point_to_actually_lookup_during_locate_zeta, Max_depth, Max_number_of_sample_point_per_bin, SamplePointContainer::Mesh_pt, SamplePointContainer::Min_and_max_coordinates, Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, root_bin_array_pt(), Root_bin_array_pt, SamplePointContainer::setup_min_and_max_coordinates(), total_number_of_sample_points_computed_recursively(), and SamplePointContainer::Total_number_of_sample_points_visited_during_locate_zeta_from_top_level.

RefineableBinArray() [2/2]

RefineableBinArray::RefineableBinArray ( const RefineableBinArray &  data )

delete

Broken copy constructor.

~RefineableBinArray()

RefineableBinArray::~RefineableBinArray ( )

inline

Destructor.

  {
    unsigned n = Bin_pt.size();
    for (unsigned i = 0; i < n; i++)
    {
      if (Bin_pt[i] != 0)
      {
        delete Bin_pt[i];
        Bin_pt[i] = 0;
      }
    }
  }

References Bin_pt, i, and n.

Member Function Documentation

add_sample_point()

void RefineableBinArray::add_sample_point ( SamplePoint *  new_sample_point_pt, const Vector< double > &  zeta  )

inline

Add specified SamplePoint to RefineableBinArray.

  {
    // Find the correct bin
    unsigned bin_index = coords_to_bin_index(zeta);
 
    // if the bin is not yet created, create it...
    if (Bin_pt[bin_index] == 0)
    {
      Bin_pt[bin_index] = new RefineableBin(this, bin_index);
    }
    // Then add the SamplePoint
    Bin_pt[bin_index]->add_sample_point(new_sample_point_pt, zeta);
  }

References Bin_pt, BinArray::coords_to_bin_index(), and Eigen::zeta().

Referenced by fill_bin_array().

bin_array_is_recursive()

bool RefineableBinArray::bin_array_is_recursive ( ) const

inline

Is the BinArray recursive?

  {
    return Bin_array_is_recursive;
  }

References Bin_array_is_recursive.

bin_pt()

RefineableBin* RefineableBinArray::bin_pt ( const unsigned &  i ) const

inline

Pointer to i-th bin; can be null if bin is empty.

  {
    return Bin_pt[i];
  }

References Bin_pt, and i.

create_sample_points_from_element()

void RefineableBinArray::create_sample_points_from_element ( FiniteElement *const  element_pt, const unsigned &  n_element  )

private

Loop over all sample points in the element specified via the pointer and create a SamplePoint for each. Also specify the index of the element in its mesh.

depth()

unsigned RefineableBinArray::depth ( ) const

inline

Depth of the hierarchical bin_array.

  {
    return Depth;
  }

References Depth.

fill_bin_array() [1/2]

void RefineableBinArray::fill_bin_array ( )

private

Fill the bin array with sample points from FiniteElements stored in mesh.

For all the sample points we have to create ...

  {
    // Fill 'em in:
    unsigned nel = Mesh_pt->nelement();
    for (unsigned e = 0; e < nel; e++)
    {
      FiniteElement* el_pt = Mesh_pt->finite_element_pt(e);
 
      // Total number of sample point we will create
      unsigned nplot =
        el_pt->nplot_points(Nsample_points_generated_per_element);
 
      for (unsigned j = 0; j < nplot; j++)
      {
        // ... create it: Pass element index in mesh (vector
        // of elements and index of sample point within element
        SamplePoint* new_sample_point_pt = new SamplePoint(e, j);
 
        // Coordinates of this point
        Vector<double> zeta(ndim_zeta());
        Vector<double> s(ndim_zeta());
        bool use_equally_spaced_interior_sample_points =
          SamplePointContainer::Use_equally_spaced_interior_sample_points;
        el_pt->get_s_plot(j,
                          Nsample_points_generated_per_element,
                          s,
                          use_equally_spaced_interior_sample_points);
        if (Use_eulerian_coordinates_during_setup)
        {
          el_pt->interpolated_x(s, zeta);
        }
        else
        {
          el_pt->interpolated_zeta(s, zeta);
        }
 
#ifdef PARANOID
 
        // Check if point is inside
        bool is_inside = true;
        std::ostringstream error_message;
        unsigned dim = ndim_zeta();
        for (unsigned i = 0; i < dim; i++)
        {
          if ((zeta[i] < Min_and_max_coordinates[i].first) ||
              (zeta[i] > Min_and_max_coordinates[i].second))
          {
            is_inside = false;
            error_message << "Sample point at zeta[" << i << "]  = " << zeta[i]
                          << " is outside limits of bin array: "
                          << Min_and_max_coordinates[i].first << " and "
                          << Min_and_max_coordinates[i].second << std::endl;
          }
        }
 
        if (!is_inside)
        {
          error_message << "Please correct the limits passed to the "
                        << "constructor." << std::endl;
          throw OomphLibError(error_message.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
 
#endif
 
 
        // Finding the correct bin to put the sample point
        unsigned bin_index = coords_to_bin_index(zeta);
 
        // if the bin is not yet created, create it
        if (Bin_pt[bin_index] == 0)
        {
          Bin_pt[bin_index] = new RefineableBin(this, bin_index);
        }
 
        // ... and then fill the bin with this new sample point
        Bin_pt[bin_index]->add_sample_point(new_sample_point_pt, zeta);
      }
    }
  }

References Bin_pt, BinArray::coords_to_bin_index(), e(), i, j, SamplePointContainer::Mesh_pt, SamplePointContainer::Min_and_max_coordinates, BinArray::ndim_zeta(), SamplePointContainer::Nsample_points_generated_per_element, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, s, SamplePointContainer::Use_equally_spaced_interior_sample_points, SamplePointContainer::Use_eulerian_coordinates_during_setup, and Eigen::zeta().

Referenced by RefineableBinArray().

fill_bin_array() [2/2]

void RefineableBinArray::fill_bin_array ( const Vector< SamplePoint * > &  sample_point_pt )

inline

Fill the bin array with specified SamplePoints.

  {
    unsigned n_dim = ndim_zeta();
 
    unsigned n = sample_point_pt.size();
    for (unsigned i = 0; i < n; i++)
    {
      // Coordinates of this point
      Vector<double> zeta(n_dim);
 
      // Which element is the point in?
      unsigned e = sample_point_pt[i]->element_index_in_mesh();
      FiniteElement* el_pt = Mesh_pt->finite_element_pt(e);
 
      // Which sample point is it at?
      unsigned j = sample_point_pt[i]->sample_point_index_in_element();
      Vector<double> s(n_dim);
      bool use_equally_spaced_interior_sample_points =
        SamplePointContainer::Use_equally_spaced_interior_sample_points;
      el_pt->get_s_plot(j,
                        Nsample_points_generated_per_element,
                        s,
                        use_equally_spaced_interior_sample_points);
      if (Use_eulerian_coordinates_during_setup)
      {
        el_pt->interpolated_x(s, zeta);
      }
      else
      {
        el_pt->interpolated_zeta(s, zeta);
      }
 
      // Add it
      add_sample_point(sample_point_pt[i], zeta);
    }
  }

References add_sample_point(), e(), i, j, SamplePointContainer::Mesh_pt, n, BinArray::ndim_zeta(), SamplePointContainer::Nsample_points_generated_per_element, s, SamplePointContainer::Use_equally_spaced_interior_sample_points, SamplePointContainer::Use_eulerian_coordinates_during_setup, and Eigen::zeta().

first_sample_point_to_actually_lookup_during_locate_zeta()

unsigned& RefineableBinArray::first_sample_point_to_actually_lookup_during_locate_zeta ( )

inline

When searching through sample points recursively from the top level RefineableBinArray (in deterministic order!) only actually do the locate_zeta calls when when the counter exceeds this value.

  {
    return First_sample_point_to_actually_lookup_during_locate_zeta;
  }

References First_sample_point_to_actually_lookup_during_locate_zeta.

Referenced by oomph::Multi_domain_functions::aux_setup_multi_domain_interaction().

get_bin_boundaries()

void RefineableBinArray::get_bin_boundaries	(	const unsigned &	bin_index,
		Vector< std::pair< double, double >> &	min_and_max_coordinates_of_bin
	)

Boundaries of specified bin in each coordinate direction. *.first = min; *.second = max.

  {
    unsigned bin_index_local = bin_index;
 
    // temporary storage for the eulerian dim
    unsigned current_dim = ndim_zeta();
    min_and_max_coordinates_of_bin.resize(current_dim);
    for (unsigned u = 0; u < current_dim; u++)
    {
      // The number of bins there are according to the u-th dimension
      unsigned nbin_in_dir = bin_index_local % dimension_of_bin_array(u);
      bin_index_local /= dimension_of_bin_array(u);
 
      // The range between the maximum and minimum u-th coordinates of a bin
      double range =
        (Min_and_max_coordinates[u].second - Min_and_max_coordinates[u].first) /
        double(Dimensions_of_bin_array[u]);
 
      // Now updating the minimum and maximum u-th coordinates for this bin.
      min_and_max_coordinates_of_bin[u].first =
        Min_and_max_coordinates[u].first + double(nbin_in_dir) * range;
      min_and_max_coordinates_of_bin[u].second =
        min_and_max_coordinates_of_bin[u].first + range;
    }
  }

References BinArray::dimension_of_bin_array(), BinArray::Dimensions_of_bin_array, SamplePointContainer::Min_and_max_coordinates, and BinArray::ndim_zeta().

Referenced by output_neighbouring_bins().

initial_last_sample_point_to_actually_lookup_during_locate_zeta()

unsigned& RefineableBinArray::initial_last_sample_point_to_actually_lookup_during_locate_zeta ( )

inline

When searching through sample points recursively from the top level RefineableBinArray (in deterministic order!) only actually do the locate_zeta calls when when the counter exceeds this value. This is the initial value when starting the spiral based search.

  {
    return Initial_last_sample_point_to_actually_lookup_during_locate_zeta;
  }

References Initial_last_sample_point_to_actually_lookup_during_locate_zeta.

Referenced by oomph::Multi_domain_functions::aux_setup_multi_domain_interaction().

last_sample_point_to_actually_lookup_during_locate_zeta()

unsigned& RefineableBinArray::last_sample_point_to_actually_lookup_during_locate_zeta ( )

inline

When searching through sample points recursively from the top level RefineableBinArray (in deterministic order!) only actually do the locate_zeta calls when when the counter is less than this value.

  {
    return Last_sample_point_to_actually_lookup_during_locate_zeta;
  }

References Last_sample_point_to_actually_lookup_during_locate_zeta.

Referenced by oomph::Multi_domain_functions::aux_setup_multi_domain_interaction().

locate_zeta()

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

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.

Implements SamplePointContainer.

  {
    // Default: we've failed miserably
    sub_geom_object_pt = 0;
 
    unsigned dim = ndim_zeta();
 
    // Top level book keeping and sanity checking
    if (Depth == 0)
    {
      // Reset counter for number of sample points visited.
      // If we can't find the point we should at least make sure that
      // we've visited all the sample points before giving up.
      Total_number_of_sample_points_visited_during_locate_zeta_from_top_level =
        0;
 
      // Does the zeta coordinate lie within the current (top level!) bin
      // structure? Skip this test if we want to always fail because that's
      //  usually done to trace out the spiral path
      if (!BinArray::Always_fail_elemental_locate_zeta)
      {
        // Loop over the lagrangian dimension
        for (unsigned i = 0; i < dim; i++)
        {
          // If the i-th coordinate is less than the minimum
          if (zeta[i] < Min_and_max_coordinates[i].first)
          {
            return;
          }
          // Otherwise coordinate may be bigger than the maximum
          else if (zeta[i] > Min_and_max_coordinates[i].second)
          {
            return;
          }
        }
      }
    }
 
    // Finding the bin in which the point is located
    int bin_index = coords_to_bin_index(zeta);
 
#ifdef PARANOID
    if (bin_index < 0)
    {
      throw OomphLibError("Negative bin index...",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Start at this radius (radius = 0 is the central bin)
    unsigned radius = 0;
 
    // "coordinates" of the bin which is most likely to contain the
    // point
    Vector<unsigned> bin_index_v(dim);
    coords_to_vectorial_bin_index(zeta, bin_index_v);
 
    // We loop over all the dimensions to find the maximum radius we have to
    // do the spiraling if we want to be sure there is no bin left at the end
    unsigned max_radius = 0;
    for (unsigned k = 0; k < dim; k++)
    {
      unsigned local =
        std::max((bin_index_v[k] + 1),
                 (Dimensions_of_bin_array[k] - bin_index_v[k] - 1));
      if (local > max_radius)
      {
        max_radius = local;
      }
    }
 
    // Vector which will store the indices of the neighbouring bins
    // at the current radius
    Vector<unsigned> bin_index_at_current_radius;
    while (radius <= max_radius)
    {
      // Get the neighbouring bins
      bin_index_at_current_radius.clear();
      get_neighbouring_bins_helper(
        bin_index, radius, bin_index_at_current_radius);
      // How many are there
      unsigned nbin_at_current_radius = bin_index_at_current_radius.size();
      unsigned n_bin = nbin();
 
      // Keep looping over entries (stop if we found geom object)
      unsigned k = 0;
      while ((k < nbin_at_current_radius) && (sub_geom_object_pt == 0))
      {
        int neigh_bin_index = bin_index_at_current_radius[k];
#ifdef PARANOID
        if (neigh_bin_index < 0)
        {
          throw OomphLibError("Negative neighbour bin index...",
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
#endif
        if (neigh_bin_index < int(n_bin))
        {
          // If the bin exists
          if (Bin_pt[neigh_bin_index] != 0)
          {
            // We call the correct method to locate_zeta in the bin
            Bin_pt[neigh_bin_index]->locate_zeta(zeta, sub_geom_object_pt, s);
          }
        }
        k++;
      }
 
      // Reached end of loop over bins at this radius (or found the point)
      // Which one?
      if (sub_geom_object_pt != 0)
      {
        return;
      }
      // Increment radius
      else
      {
        radius++;
      }
    }
 
 
#ifdef PARANOID
 
    // If we still haven't found the point, check that we've at least visited
    // all the sample points
    if (Depth == 0)
    {
      if (
        Total_number_of_sample_points_visited_during_locate_zeta_from_top_level !=
        total_number_of_sample_points_computed_recursively())
      {
        if (max_search_radius() == DBL_MAX)
        {
          std::ostringstream error_message;
          error_message
            << "Zeta not found after visiting "
            << Total_number_of_sample_points_visited_during_locate_zeta_from_top_level
            << " sample points out of "
            << total_number_of_sample_points_computed_recursively() << std::endl
            << "Where are the missing sample points???\n";
          throw OomphLibError(error_message.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
      }
    }
 
#endif
  }

References SamplePointContainer::Always_fail_elemental_locate_zeta, Bin_pt, BinArray::coords_to_bin_index(), BinArray::coords_to_vectorial_bin_index(), Depth, BinArray::Dimensions_of_bin_array, BinArray::get_neighbouring_bins_helper(), i, k, max, SamplePointContainer::max_search_radius(), SamplePointContainer::Min_and_max_coordinates, nbin(), BinArray::ndim_zeta(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, UniformPSDSelfTest::radius, s, total_number_of_sample_points_computed_recursively(), SamplePointContainer::Total_number_of_sample_points_visited_during_locate_zeta_from_top_level, and Eigen::zeta().

max_depth() [1/2]

unsigned& RefineableBinArray::max_depth ( )

inline

Max depth of the hierarchical bin_array.

  {
    return Max_depth;
  }

References Max_depth.

max_depth() [2/2]

unsigned RefineableBinArray::max_depth ( ) const

inline

Max depth of the hierarchical bin_array; const version.

  {
    return Max_depth;
  }

References Max_depth.

max_number_of_sample_point_per_bin()

unsigned RefineableBinArray::max_number_of_sample_point_per_bin ( ) const

inline

Maximum number of sample points in bin (before its subdivided recursively)

  {
    return Max_number_of_sample_point_per_bin;
  }

References Max_number_of_sample_point_per_bin.

multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta()

unsigned& RefineableBinArray::multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta ( )

inline

Every time we've completed a "spiral", visiting a finite number of sample points in a deterministic order, use this multiplier to increase the max. number of sample points to be visited. Using a multiplier rather than a constant increment increases the amount of (more and more unlikely to yield anything!) work done locally before doing another costly mpi round trip when we're already far from the point we're trying to find.

  {
    return Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta;
  }

References Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta.

Referenced by oomph::Multi_domain_functions::aux_setup_multi_domain_interaction().

nbin()

unsigned RefineableBinArray::nbin ( ) const

inlinevirtual

Number of bins (not taking recursion into account)

Implements BinArray.

  {
    return Bin_pt.size();
  }

References Bin_pt.

Referenced by locate_zeta(), and total_number_of_sample_points_computed_recursively().

operator=()

void RefineableBinArray::operator= ( const RefineableBinArray &  )

delete

Broken assignment operator.

output_bin_vertices()

void RefineableBinArray::output_bin_vertices ( std::ofstream &  outfile )

virtual

Output bin vertices (allowing display of bins as zones).

Output neighbouring bins up to given "radius" of the specified bin.

Implements BinArray.

  {
    // Loop over bins
    unsigned n_bin = Bin_pt.size();
    for (unsigned i = 0; i < n_bin; i++)
    {
      if (Bin_pt[i] != 0)
      {
        Bin_pt[i]->output_bin_vertices(outfile);
      }
    }
  }

References Bin_pt, and i.

output_bins()

void RefineableBinArray::output_bins ( std::ofstream &  outfile )

inlinevirtual

Output bins.

Loop over bins

Implements BinArray.

  {
    unsigned n_bin = Bin_pt.size();
    for (unsigned i = 0; i < n_bin; i++)
    {
      if (Bin_pt[i] != 0)
      {
        Bin_pt[i]->output(outfile);
      }
    }
  }

References Bin_pt, and i.

output_neighbouring_bins()

void RefineableBinArray::output_neighbouring_bins	(	const unsigned &	bin_index,
		const unsigned &	radius,
		std::ofstream &	outfile
	)

Output neighbouring bins at given "radius" of the specified bin.

Output neighbouring bins up to given "radius" of the specified bin.

  {
    unsigned n_lagr = ndim_zeta();
 
    Vector<unsigned> neighbouring_bin_index;
    get_neighbouring_bins_helper(bin_index, radius, neighbouring_bin_index);
    unsigned nneigh = neighbouring_bin_index.size();
 
    // Outline of bin structure
    switch (n_lagr)
    {
      case 1:
        outfile << "ZONE I=2\n"
                << Min_and_max_coordinates[0].first << std::endl
                << Min_and_max_coordinates[0].second << std::endl;
        break;
 
      case 2:
 
        outfile << "ZONE I=2, J=2\n"
                << Min_and_max_coordinates[0].first << " "
                << Min_and_max_coordinates[1].first << " "
                << "\n"
 
                << Min_and_max_coordinates[0].second << " "
                << Min_and_max_coordinates[1].first << " "
                << "\n"
 
                << Min_and_max_coordinates[0].first << " "
                << Min_and_max_coordinates[1].second << " "
                << "\n"
 
                << Min_and_max_coordinates[0].second << " "
                << Min_and_max_coordinates[1].second << " "
                << "\n";
        break;
 
      case 3:
 
        outfile << "ZONE I=2, J=2, K=2 \n"
                << Min_and_max_coordinates[0].first << " "
                << Min_and_max_coordinates[1].first << " "
                << Min_and_max_coordinates[2].first << " "
                << "\n"
 
                << Min_and_max_coordinates[0].second << " "
                << Min_and_max_coordinates[1].first << " "
                << Min_and_max_coordinates[2].first << " "
                << "\n"
 
                << Min_and_max_coordinates[0].first << " "
                << Min_and_max_coordinates[1].second << " "
                << Min_and_max_coordinates[2].first << " "
                << "\n"
 
                << Min_and_max_coordinates[0].second << " "
                << Min_and_max_coordinates[1].second << " "
                << Min_and_max_coordinates[2].first << " "
                << "\n"
 
                << Min_and_max_coordinates[0].first << " "
                << Min_and_max_coordinates[1].first << " "
                << Min_and_max_coordinates[2].second << " "
                << "\n"
 
                << Min_and_max_coordinates[0].second << " "
                << Min_and_max_coordinates[1].first << " "
                << Min_and_max_coordinates[2].second << " "
                << "\n"
 
                << Min_and_max_coordinates[0].first << " "
                << Min_and_max_coordinates[1].second << " "
                << Min_and_max_coordinates[2].second << " "
                << "\n"
 
                << Min_and_max_coordinates[0].second << " "
                << Min_and_max_coordinates[1].second << " "
                << Min_and_max_coordinates[2].second << " "
                << "\n";
        break;
 
      default:
 
        oomph_info << "n_lagr=" << n_lagr << std::endl;
        throw OomphLibError(
          "Wrong dimension!", OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    // Loop over neighbours
    for (unsigned i = 0; i < nneigh; i++)
    {
      Vector<std::pair<double, double>> min_and_max_coordinates(n_lagr);
      get_bin_boundaries(neighbouring_bin_index[i], min_and_max_coordinates);
 
      switch (n_lagr)
      {
        case 1:
          outfile << "ZONE I=2\n"
                  << min_and_max_coordinates[0].first << std::endl
                  << min_and_max_coordinates[0].second << std::endl;
          break;
 
        case 2:
 
          outfile << "ZONE I=2, J=2\n"
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " "
                  << "\n";
          break;
 
        case 3:
 
          outfile << "ZONE I=2, J=2, K=2\n"
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].second << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].second << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].second << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].second << " "
                  << "\n";
          break;
 
        default:
 
          oomph_info << "n_lagr=" << n_lagr << std::endl;
          throw OomphLibError("Wrong dimension!",
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
      }
    }
  }

References get_bin_boundaries(), BinArray::get_neighbouring_bins_helper(), i, SamplePointContainer::min_and_max_coordinates(), SamplePointContainer::Min_and_max_coordinates, BinArray::ndim_zeta(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and UniformPSDSelfTest::radius.

root_bin_array_pt()

RefineableBinArray* RefineableBinArray::root_bin_array_pt ( ) const

inline

Root bin array.

  {
    return Root_bin_array_pt;
  }

References Root_bin_array_pt.

Referenced by RefineableBinArray().

total_number_of_sample_points_computed_recursively()

unsigned RefineableBinArray::total_number_of_sample_points_computed_recursively ( ) const

virtual

Compute total number of sample points recursively.

Implements SamplePointContainer.

  {
    unsigned count = 0;
    unsigned n_bin = nbin();
    for (unsigned i = 0; i < n_bin; i++)
    {
      if (Bin_pt[i] != 0)
      {
        count +=
          Bin_pt[i]->total_number_of_sample_points_computed_recursively();
      }
    }
    return count;
  }

References Bin_pt, i, and nbin().

Referenced by oomph::Multi_domain_functions::aux_setup_multi_domain_interaction(), locate_zeta(), and RefineableBinArray().

total_number_of_sample_points_visited_during_locate_zeta_from_top_level()

unsigned& RefineableBinArray::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

Reimplemented from SamplePointContainer.

  {
    if (Depth == 0)
    {
      return Total_number_of_sample_points_visited_during_locate_zeta_from_top_level;
    }
    else
    {
      return Root_bin_array_pt
        ->total_number_of_sample_points_visited_during_locate_zeta_from_top_level();
    }
  }

References Depth, Root_bin_array_pt, SamplePointContainer::Total_number_of_sample_points_visited_during_locate_zeta_from_top_level, and total_number_of_sample_points_visited_during_locate_zeta_from_top_level().

Referenced by total_number_of_sample_points_visited_during_locate_zeta_from_top_level().

Member Data Documentation

Bin_array_is_recursive

bool RefineableBinArray::Bin_array_is_recursive

private

Variable which stores if the RefineableBinArray is recursive or not.

Referenced by bin_array_is_recursive(), and RefineableBinArray().

Bin_pt

Vector<RefineableBin*> RefineableBinArray::Bin_pt

private

Vector of pointers to constituent RefineableBins.

Referenced by add_sample_point(), bin_pt(), fill_bin_array(), locate_zeta(), nbin(), output_bin_vertices(), output_bins(), RefineableBinArray(), total_number_of_sample_points_computed_recursively(), and ~RefineableBinArray().

Default_n_bin_1d

unsigned RefineableBinArray::Default_n_bin_1d = 5

static

Default number of bins (in each coordinate direction)

Default number of bins (in each coordinate direction) (Note: don't move this into a common base class because each derived class has its own value; we'll want far fewer in the refineable version!)

Referenced by RefineableBinArray().

Depth

unsigned RefineableBinArray::Depth

private

Variable which stores the Depth value of the bin_array. Useful for debugging and for preventing "infinite" recursion in case if there is a problem.

Referenced by depth(), locate_zeta(), RefineableBinArray(), and total_number_of_sample_points_visited_during_locate_zeta_from_top_level().

First_sample_point_to_actually_lookup_during_locate_zeta

unsigned RefineableBinArray::First_sample_point_to_actually_lookup_during_locate_zeta

private

When searching through sample points recursively from the top level RefineableBinArray (in deterministic order!) only actually do the locate_zeta calls when when the counter exceeds this value.

Referenced by first_sample_point_to_actually_lookup_during_locate_zeta(), and RefineableBinArray().

Initial_last_sample_point_to_actually_lookup_during_locate_zeta

unsigned RefineableBinArray::Initial_last_sample_point_to_actually_lookup_during_locate_zeta

private

When searching through sample points recursively from the top level RefineableBinArray (in deterministic order!) only actually do the locate_zeta calls when when the counter exceeds this value. This is the initial value when starting the spiral based search.

Referenced by initial_last_sample_point_to_actually_lookup_during_locate_zeta(), and RefineableBinArray().

Last_sample_point_to_actually_lookup_during_locate_zeta

unsigned RefineableBinArray::Last_sample_point_to_actually_lookup_during_locate_zeta

private

When searching through sample points recursively from the top level RefineableBinArray (in deterministic order!) only actually do the locate_zeta calls when when the counter is less than this value.

Referenced by last_sample_point_to_actually_lookup_during_locate_zeta(), and RefineableBinArray().

Max_depth

unsigned RefineableBinArray::Max_depth

private

Max depth of the hierarchical bin_array.

Referenced by max_depth(), and RefineableBinArray().

Max_number_of_sample_point_per_bin

unsigned RefineableBinArray::Max_number_of_sample_point_per_bin

private

Maximum number of sample points in bin (before it's subdivided recursively)

Referenced by max_number_of_sample_point_per_bin(), and RefineableBinArray().

Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta

unsigned RefineableBinArray::Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta

private

Every time we've completed a "spiral", visiting a finite number of sample points in a deterministic order, use this multiplier to increase the max. number of sample points to be visited. Using a multiplier rather than a constant increment increases the amount of (more and more unlikely to yield anything!) work done locally before doing another costly mpi round trip when we're already far from the point we're trying to find.

Referenced by multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta(), and RefineableBinArray().

Root_bin_array_pt

RefineableBinArray* RefineableBinArray::Root_bin_array_pt

private

Pointer to root bin array.

Referenced by RefineableBinArray(), root_bin_array_pt(), and total_number_of_sample_points_visited_during_locate_zeta_from_top_level().

---

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

• sample_point_container.h
• sample_point_container.cc