NonRefineableBinArray Class Reference

NonRefineableBinArray class. More...

#include <sample_point_container.h>

Inheritance diagram for NonRefineableBinArray:

Public Member Functions
	NonRefineableBinArray (SamplePointContainerParameters *bin_array_parameters_pt)
	Constructor. More...
	~NonRefineableBinArray ()
	Destructor: More...
	NonRefineableBinArray (const NonRefineableBinArray &data)=delete
	Broken copy constructor. More...
void	operator= (const NonRefineableBinArray &)=delete
	Broken assignment operator. More...
void	locate_zeta (const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s)
unsigned	nbin () const
	Total number of bins (empty or not) More...
unsigned	total_number_of_sample_points_computed_recursively () const
	Compute total number of sample points recursively. More...
unsigned	n_spiral_chunk () const
	Number of spirals to be searched in one go const version. More...
unsigned &	n_spiral_chunk ()
	Number of spirals to be searched in one go. More...
unsigned &	max_spiral_level ()
unsigned &	current_min_spiral_level ()
	Access function to current min. spiral level. More...
unsigned &	current_max_spiral_level ()
	Access function to current max. spiral level. More...
void	get_fill_stats (unsigned &n_bin, unsigned &max_n_entry, unsigned &min_n_entry, unsigned &tot_n_entry, unsigned &n_empty) const
	Provide some stats on the fill level of the associated bin. More...
double	min_distance (const unsigned &i_bin, const Vector< double > &zeta)
void	output_bin_vertices (std::ofstream &outfile)
	Output bin vertices (allowing display of bins as zones). More...
void	get_bin_vertices (const unsigned &i_bin, Vector< Vector< double >> &bin_vertex)
void	get_bin (const Vector< double > &zeta, int &bin_number)
void	get_bin (const Vector< double > &zeta, int &bin_number, Vector< std::pair< FiniteElement *, Vector< double >>> &sample_point_pairs)
Vector< Vector< std::pair< FiniteElement *, Vector< double > > > >	bin_content () const
	Get the contents of all bins in vector. More...
const std::map< unsigned, Vector< std::pair< FiniteElement *, Vector< double > > > > *	get_all_bins_content () const
	Get the contents of all bins in vector. More...
void	fill_bin_by_diffusion (const unsigned &bin_diffusion_radius=1)
void	output_bins (std::ofstream &outfile)
	Output bins. More...
void	output_bins (std::string &filename)
	Output bins. More...
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...
virtual unsigned &	total_number_of_sample_points_visited_during_locate_zeta_from_top_level ()
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 = 100
	Default number of bins (in each coordinate direction) More...
static unsigned long	Total_nbin_cells_counter = 0
static unsigned long	Threshold_for_total_bin_cell_number_warning
static bool	Suppress_warning_about_large_total_number_of_bins
	Boolean to supppress warnings about large number of bins. More...
static bool	Already_warned_about_large_number_of_bin_cells
static unsigned	Threshold_for_elements_per_bin_warning = 100
static bool	Suppress_warning_about_small_number_of_bins
	Boolean to supppress warnings about small number of bins. More...
static bool	Already_warned_about_small_number_of_bin_cells
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_bins_of_objects ()
void	flush_bins_of_objects ()

Private Attributes
SparseVector< Vector< std::pair< FiniteElement *, Vector< double > > > >	Bin_object_coord_pairs
	Storage for paired objects and coords in each bin. More...
unsigned	Max_spiral_level
unsigned	Current_min_spiral_level
	Current min. spiralling level. More...
unsigned	Current_max_spiral_level
	Current max. spiralling level. More...
unsigned	Nspiral_chunk
	Number of spirals to be searched in one go. More...

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

NonRefineableBinArray class.

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

Constructor & Destructor Documentation

NonRefineableBinArray() [1/2]

NonRefineableBinArray::NonRefineableBinArray

(

SamplePointContainerParameters *

sample_point_container_parameters_pt

)

Constructor.

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

    : 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())
  {
    // 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();
    }
 
    // Spiraling parameters
    Max_spiral_level = UINT_MAX;
    Current_min_spiral_level = 0;
 
    NonRefineableBinArrayParameters* non_ref_bin_array_parameters_pt =
      dynamic_cast<NonRefineableBinArrayParameters*>(
        sample_point_container_parameters_pt);
 
#ifdef PARANOID
    if (non_ref_bin_array_parameters_pt == 0)
    {
      throw OomphLibError("Wrong sample_point_container_parameters_pt",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    Nspiral_chunk = non_ref_bin_array_parameters_pt->nspiral_chunk();
    Current_max_spiral_level = max_bin_dimension();
 
    // Time it
    double t_start = 0.0;
    if (SamplePointContainer::Enable_timing_of_setup)
    {
      t_start = TimingHelpers::timer();
    }
 
    // Now fill the bastard...
    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 " << Dimensions_of_bin_array.size()
                 << "-dimensional sample point container containing " << npts
                 << " sample points: " << t_end - t_start
                 << " sec  (non-ref_bin); third party: 0 sec ( = 0 %)"
                 << std::endl;
    }
  }

References Current_max_spiral_level, Current_min_spiral_level, Default_n_bin_1d, BinArray::Dimensions_of_bin_array, SamplePointContainer::Enable_timing_of_setup, fill_bin_array(), BinArray::max_bin_dimension(), Max_spiral_level, SamplePointContainer::Mesh_pt, SamplePointContainer::Min_and_max_coordinates, Nspiral_chunk, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, SamplePointContainer::setup_min_and_max_coordinates(), and total_number_of_sample_points_computed_recursively().

~NonRefineableBinArray()

NonRefineableBinArray::~NonRefineableBinArray ( )

inline

Destructor:

  {
    flush_bins_of_objects();
  }

References flush_bins_of_objects().

NonRefineableBinArray() [2/2]

NonRefineableBinArray::NonRefineableBinArray ( const NonRefineableBinArray &  data )

delete

Broken copy constructor.

Member Function Documentation

bin_content()

Vector<Vector<std::pair<FiniteElement*, Vector<double> > > > NonRefineableBinArray::bin_content ( ) const

inline

Get the contents of all bins in vector.

  {
    Vector<Vector<std::pair<FiniteElement*, Vector<double>>>> all_vals;
    Bin_object_coord_pairs.get_all_values(all_vals);
    return all_vals;
  }

References Bin_object_coord_pairs.

create_bins_of_objects()

void NonRefineableBinArray::create_bins_of_objects ( )

private

Initialise and populate the "bin" structure for locating coordinates and increment counter for total number of bins in active use by any MeshAsGeomObject)

current_max_spiral_level()

unsigned& NonRefineableBinArray::current_max_spiral_level ( )

inline

Access function to current max. spiral level.

  {
    return Current_max_spiral_level;
  }

References Current_max_spiral_level.

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

current_min_spiral_level()

unsigned& NonRefineableBinArray::current_min_spiral_level ( )

inline

Access function to current min. spiral level.

  {
    return Current_min_spiral_level;
  }

References Current_min_spiral_level.

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

fill_bin_array()

void NonRefineableBinArray::fill_bin_array ( )

private

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

Loop over subobjects (elements) to decide which bin they belong in...

  {
    // Store the lagrangian dimension
    const unsigned n_lagrangian = this->ndim_zeta();
 
    // Flush all objects out of the bin structure
    flush_bins_of_objects();
 
    // Temporary storage in bin
    std::map<unsigned, Vector<std::pair<FiniteElement*, Vector<double>>>>
      tmp_bin_object_coord_pairs;
 
    // Total number of bins
    unsigned ntotalbin = nbin();
 
    // Initialise the structure that keep tracks of the occupided bins
    Bin_object_coord_pairs.initialise(ntotalbin);
 
 
    // Issue warning about small number of bins
    if (!Suppress_warning_about_small_number_of_bins)
    {
      // Calculate the (nearest integer) number of elements per bin
      unsigned n_mesh_element = Mesh_pt->nelement();
      unsigned elements_per_bin = n_mesh_element / ntotalbin;
      // If it is above the threshold then issue a warning
      if (elements_per_bin > Threshold_for_elements_per_bin_warning)
      {
        if (!Already_warned_about_small_number_of_bin_cells)
        {
          Already_warned_about_small_number_of_bin_cells = true;
          std::ostringstream warn_message;
          warn_message
            << "The average (integer) number of elements per bin is \n\n"
            << elements_per_bin << ", which is more than \n\n"
            << "   "
               "NonRefineableBinArray::Threshold_for_elements_per_bin_warning="
            << Threshold_for_elements_per_bin_warning
            << "\n\nIf the lookup seems slow (and you have the memory),"
            << "consider increasing\n"
            << "BinArray::Dimensions_of_bin_array from their current\n"
            << "values of { ";
          unsigned nn = Dimensions_of_bin_array.size();
          for (unsigned ii = 0; ii < nn; ii++)
          {
            warn_message << Dimensions_of_bin_array[ii] << " ";
          }
          warn_message
            << " }.\n"
            << "\nNOTE: You can suppress this warning by increasing\n\n"
            << "   NonRefineableBinArray::"
            << "Threshold_for_elements_per_bin_warning\n\n"
            << "or by setting \n\n   "
            << "NonRefineableBinArray::Suppress_warning_about_small_number_of_"
               "bins\n\n"
            << "to true (both are public static data).\n\n";
          OomphLibWarning(warn_message.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
        }
      }
    }
 
 
    // Increase overall counter
    Total_nbin_cells_counter += ntotalbin;
 
 
    // Issue warning?
    if (!Suppress_warning_about_large_total_number_of_bins)
    {
      if (Total_nbin_cells_counter >
          Threshold_for_total_bin_cell_number_warning)
      {
        if (!Already_warned_about_large_number_of_bin_cells)
        {
          Already_warned_about_large_number_of_bin_cells = true;
          std::ostringstream warn_message;
          warn_message
            << "Have allocated \n\n"
            << "   NonRefineableBinArray::Total_nbin_cells_counter="
            << NonRefineableBinArray::Total_nbin_cells_counter
            << "\n\nbin cells, which is more than \n\n"
            << "   NonRefineableBinArray::"
            << "Threshold_for_total_bin_cell_number_warning="
            << NonRefineableBinArray::
                 Threshold_for_total_bin_cell_number_warning
            << "\n\nIf you run out of memory, consider reducing\n"
            << "BinArray::Dimensions_of_bin_array from their current\n"
            << "values of { ";
          unsigned nn = Dimensions_of_bin_array.size();
          for (unsigned ii = 0; ii < nn; ii++)
          {
            warn_message << Dimensions_of_bin_array[ii] << " ";
          }
          warn_message
            << " }.\n"
            << "\nNOTE: You can suppress this warning by increasing\n\n"
            << "   NonRefineableBinArray::"
            << "Threshold_for_total_bin_cell_number_warning\n\n"
            << "or by setting \n\n   NonRefineableBinArray::"
            << "Suppress_warning_about_large_total_number_of_bins\n\n"
            << "to true (both are public static data).\n\n"
            << "NOTE: I'll only issue this warning once -- total number of\n"
            << "bins may grow yet further!\n";
          OomphLibWarning(warn_message.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
        }
      }
    }
 
    unsigned n_sub = Mesh_pt->nelement();
    for (unsigned e = 0; e < n_sub; e++)
    {
      // Cast to the element (sub-object) first
      FiniteElement* el_pt =
        dynamic_cast<FiniteElement*>(Mesh_pt->finite_element_pt(e));
 
      // Get specified number of points within the element
      unsigned n_plot_points =
        el_pt->nplot_points(Nsample_points_generated_per_element);
 
      for (unsigned iplot = 0; iplot < n_plot_points; iplot++)
      {
        // Storage for local and global coordinates
        Vector<double> local_coord(n_lagrangian, 0.0);
        Vector<double> global_coord(n_lagrangian, 0.0);
 
        // Get local coordinate and interpolate to global
        bool use_equally_spaced_interior_sample_points =
          SamplePointContainer::Use_equally_spaced_interior_sample_points;
        el_pt->get_s_plot(iplot,
                          Nsample_points_generated_per_element,
                          local_coord,
                          use_equally_spaced_interior_sample_points);
 
        // Now get appropriate global coordinate
        if (Use_eulerian_coordinates_during_setup)
        {
          el_pt->interpolated_x(local_coord, global_coord);
        }
        else
        {
          el_pt->interpolated_zeta(local_coord, global_coord);
        }
 
        // Which bin are the global coordinates in?
        unsigned bin_number = 0;
        unsigned multiplier = 1;
        // Loop over the dimension
        for (unsigned i = 0; i < n_lagrangian; i++)
        {
#ifdef PARANOID
          if ((global_coord[i] < Min_and_max_coordinates[i].first) ||
              (global_coord[i] > Min_and_max_coordinates[i].second))
          {
            std::ostringstream error_message;
            error_message
              << "Bin sample point " << iplot << " in element " << e << "\n"
              << "is outside bin limits in coordinate direction " << i << ":\n"
              << "Sample point coordinate: " << global_coord[i] << "\n"
              << "Max bin coordinate     : "
              << Min_and_max_coordinates[i].second << "\n"
              << "Min bin coordinate     : " << Min_and_max_coordinates[i].first
              << "\n"
              << "You should either setup the bin boundaries manually\n"
              << "or increase the percentage offset by which the\n"
              << "automatically computed bin limits are increased \n"
              << "beyond their sampled max/mins. This is defined in\n"
              << "the (public) namespace member\n\n"
              << "SamplePointContainer::Percentage_offset \n\n which \n"
              << "currently has the value: "
              << SamplePointContainer::Percentage_offset << "\n";
            throw OomphLibError(error_message.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
          }
 
#endif
          unsigned bin_number_i =
            int(Dimensions_of_bin_array[i] *
                ((global_coord[i] - Min_and_max_coordinates[i].first) /
                 (Min_and_max_coordinates[i].second -
                  Min_and_max_coordinates[i].first)));
 
          // Buffer the case when the global coordinate is the maximum
          // value
          if (bin_number_i == Dimensions_of_bin_array[i])
          {
            bin_number_i -= 1;
          }
 
          // Add to the bin number
          bin_number += multiplier * bin_number_i;
 
          // Sort out the multiplier
          multiplier *= Dimensions_of_bin_array[i];
        }
 
        // Add element-sample local coord pair to the calculated bin
        tmp_bin_object_coord_pairs[bin_number].push_back(
          std::make_pair(el_pt, local_coord));
      }
    }
 
    // Finally copy filled vectors across -- wiping memory from temporary
    // map as we go along is good and wouldn't be possible if we
    // filled the SparseVector's internal map within that class.
    typedef std::map<
      unsigned,
      Vector<std::pair<FiniteElement*, Vector<double>>>>::iterator IT;
    for (IT it = tmp_bin_object_coord_pairs.begin();
         it != tmp_bin_object_coord_pairs.end();
         it++)
    {
      Bin_object_coord_pairs.set_value((*it).first, (*it).second);
      // Make space immediately
      (*it).second.clear();
    }
  }

References Already_warned_about_large_number_of_bin_cells, Already_warned_about_small_number_of_bin_cells, Bin_object_coord_pairs, BinArray::Dimensions_of_bin_array, e(), flush_bins_of_objects(), i, int(), SamplePointContainer::Mesh_pt, SamplePointContainer::Min_and_max_coordinates, Global_Physical_Variables::multiplier(), nbin(), BinArray::ndim_zeta(), SamplePointContainer::Nsample_points_generated_per_element, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, SamplePointContainer::Percentage_offset, Suppress_warning_about_large_total_number_of_bins, Suppress_warning_about_small_number_of_bins, Threshold_for_elements_per_bin_warning, Threshold_for_total_bin_cell_number_warning, Total_nbin_cells_counter, SamplePointContainer::Use_equally_spaced_interior_sample_points, and SamplePointContainer::Use_eulerian_coordinates_during_setup.

Referenced by NonRefineableBinArray().

fill_bin_by_diffusion()

void NonRefineableBinArray::fill_bin_by_diffusion

(

const unsigned &

bin_diffusion_radius = 1

)

Fill bin by diffusion, populating each empty bin with the same content as the first non-empty bin found during a spiral-based search up to the specified "radius" (default 1)

  {
    // oomph_info << "PROFILING GET_NEIGHBOURING_BINS_HELPER():" << std::endl;
    // profile_get_neighbouring_bins_helper();
 
    // Loop over all bins to check if they're empty
    std::list<unsigned> empty_bins;
    unsigned n_bin = nbin();
    std::vector<bool> was_empty_until_current_iteration(n_bin, false);
    for (unsigned i = 0; i < n_bin; i++)
    {
      if (Bin_object_coord_pairs[i].size() == 0)
      {
        empty_bins.push_front(i);
        was_empty_until_current_iteration[i] = true;
      }
    }
 
    // Now keep processing the empty bins until there are none left
    unsigned iter = 0;
    Vector<unsigned> newly_filled_bin;
    while (empty_bins.size() != 0)
    {
      newly_filled_bin.clear();
      newly_filled_bin.reserve(empty_bins.size());
      for (std::list<unsigned>::iterator it = empty_bins.begin();
           it != empty_bins.end();
           it++)
      {
        unsigned bin = (*it);
 
        // Look for immediate neighbours within the specified "bin radius"
        unsigned level = bin_diffusion_radius;
        Vector<unsigned> neighbour_bin;
        get_neighbouring_bins_helper(bin, level, neighbour_bin);
        unsigned n_neigh = neighbour_bin.size();
 
        // Find closest pair
        double min_dist = DBL_MAX;
        std::pair<FiniteElement*, Vector<double>> closest_pair;
        for (unsigned i = 0; i < n_neigh; i++)
        {
          unsigned neigh_bin = neighbour_bin[i];
 
          // Only allow to re-populate from bins that were already filled at
          // previous iteration, otherwise things can progate too fast
          if (!was_empty_until_current_iteration[neigh_bin])
          {
            unsigned nbin_content = Bin_object_coord_pairs[neigh_bin].size();
            for (unsigned j = 0; j < nbin_content; j++)
            {
              FiniteElement* el_pt = Bin_object_coord_pairs[neigh_bin][j].first;
              Vector<double> s(Bin_object_coord_pairs[neigh_bin][j].second);
              Vector<double> x(2);
              el_pt->interpolated_x(s, x);
              // Get minimum distance of sample point from any of the vertices
              // of current bin
              // hierher Louis questions if this is the right thing to do!
              // Matthias agrees
              // with him but hasn't done anything yet...
              // should use the distance to the centre of gravity of
              // the empty bin instead!
              double dist = min_distance(bin, x);
              if (dist < min_dist)
              {
                min_dist = dist;
                closest_pair = Bin_object_coord_pairs[neigh_bin][j];
              }
            }
          }
        }
 
        // Have we filled the bin?
        if (min_dist != DBL_MAX)
        {
          Vector<std::pair<FiniteElement*, Vector<double>>> new_entry;
          new_entry.push_back(closest_pair);
          Bin_object_coord_pairs.set_value(bin, new_entry);
 
          // Record that we've filled it.
          newly_filled_bin.push_back(bin);
 
          // Wipe entry without breaking the linked list (Andrew's trick --
          // nice!)
          std::list<unsigned>::iterator it_to_be_deleted = it;
          it--;
          empty_bins.erase(it_to_be_deleted);
        }
      }
 
      // Get ready for next iteration on remaining empty bins
      iter++;
      // Now update the vector that records which bins were empty up to now
      unsigned n = newly_filled_bin.size();
      for (unsigned i = 0; i < n; i++)
      {
        was_empty_until_current_iteration[newly_filled_bin[i]] = false;
      }
    }
 
 
#ifdef PARANOID
    // Loop over all bins to check if they're empty
    n_bin = nbin();
    for (unsigned i = 0; i < n_bin; i++)
    {
      if (Bin_object_coord_pairs[i].size() == 0)
      {
        std::ostringstream error_message_stream;
        error_message_stream << "Bin " << i << " is still empty\n"
                             << "after trying to fill it by diffusion\n";
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
 
#endif
  }

References Bin_object_coord_pairs, BinArray::get_neighbouring_bins_helper(), i, j, min_distance(), n, nbin(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, s, size, and plotDoE::x.

flush_bins_of_objects()

void NonRefineableBinArray::flush_bins_of_objects ( )

inlineprivate

Flush the storage for the binning method (and decrement counter for total number of bins in active use by any MeshAsGeomObject)

  {
    Total_nbin_cells_counter -= Bin_object_coord_pairs.nnz();
    Bin_object_coord_pairs.clear();
  }

References Bin_object_coord_pairs, and Total_nbin_cells_counter.

Referenced by fill_bin_array(), and ~NonRefineableBinArray().

get_all_bins_content()

const std::map<unsigned, Vector<std::pair<FiniteElement*, Vector<double> > > >* NonRefineableBinArray::get_all_bins_content ( ) const

inline

Get the contents of all bins in vector.

  {
    // Return the content of the bins
    return Bin_object_coord_pairs.map_pt();
  }

References Bin_object_coord_pairs.

get_bin() [1/2]

void NonRefineableBinArray::get_bin	(	const Vector< double > &	zeta,
		int &	bin_number
	)

Get the number of the bin containing the specified coordinate. Bin number is negative if the coordinate is outside the bin structure.

  {
    // Default for point not found
    bin_number = -1;
 
    // Get the lagrangian dimension
    const unsigned n_lagrangian = this->ndim_zeta();
 
    // Does the zeta coordinate lie within the current bin structure?
 
    // Loop over the lagrangian dimension
    for (unsigned i = 0; i < n_lagrangian; 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;
      }
    }
 
    // Use the min and max coords of the bin structure, to find
    // the bin structure containing the current zeta cooordinate
 
    // Initialise for subsequent computation
    bin_number = 0;
 
    // Offset for rows/matrices in higher dimensions
    unsigned multiplier = 1;
 
    // Loop over the dimension
    for (unsigned i = 0; i < n_lagrangian; i++)
    {
      // Find the bin number of the current coordinate
      unsigned bin_number_i =
        int(Dimensions_of_bin_array[i] *
            ((zeta[i] - Min_and_max_coordinates[i].first) /
             (Min_and_max_coordinates[i].second -
              Min_and_max_coordinates[i].first)));
      // Buffer the case when we are exactly on the edge
      if (bin_number_i == Dimensions_of_bin_array[i])
      {
        bin_number_i -= 1;
      }
      // Now add to the bin number using the multiplier
      bin_number += multiplier * bin_number_i;
      // Increase the current row/matrix multiplier for the next loop
      multiplier *= Dimensions_of_bin_array[i];
    }
 
 
#ifdef PARANOID
 
    // Tolerance for "out of bin" test
    double tol = 1.0e-10;
 
    unsigned nvertex = (int)pow(2, n_lagrangian);
    Vector<Vector<double>> bin_vertex(nvertex);
    for (unsigned j = 0; j < nvertex; j++)
    {
      bin_vertex[j].resize(n_lagrangian);
    }
    get_bin_vertices(bin_number, bin_vertex);
    for (unsigned i = 0; i < n_lagrangian; i++)
    {
      double min_vertex_coord = DBL_MAX;
      double max_vertex_coord = -DBL_MAX;
      for (unsigned j = 0; j < nvertex; j++)
      {
        if (bin_vertex[j][i] < min_vertex_coord)
        {
          min_vertex_coord = bin_vertex[j][i];
        }
        if (bin_vertex[j][i] > max_vertex_coord)
        {
          max_vertex_coord = bin_vertex[j][i];
        }
      }
      if (zeta[i] < min_vertex_coord - tol)
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "Trouble! " << i << " -th coordinate of sample point, " << zeta[i]
          << " , isn't actually between limits, " << min_vertex_coord << " and "
          << max_vertex_coord << " [it's below by more than " << tol << " !] "
          << std::endl;
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
 
      if (zeta[i] > max_vertex_coord + tol)
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "Trouble! " << i << " -th coordinate of sample point, " << zeta[i]
          << " , isn't actually between limits, " << min_vertex_coord << " and "
          << max_vertex_coord << " [it's above by more than " << tol << "!] "
          << std::endl;
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
  }

References BinArray::Dimensions_of_bin_array, get_bin_vertices(), i, int(), j, SamplePointContainer::Min_and_max_coordinates, Global_Physical_Variables::multiplier(), BinArray::ndim_zeta(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Eigen::bfloat16_impl::pow(), and Eigen::zeta().

get_bin() [2/2]

void NonRefineableBinArray::get_bin	(	const Vector< double > &	zeta,
		int &	bin_number,
		Vector< std::pair< FiniteElement *, Vector< double >>> &	sample_point_pairs
	)

Get the number of the bin containing the specified coordinate; also return the contents of that bin. Bin number is negative if the coordinate is outside the bin structure.

get_bin_vertices()

void NonRefineableBinArray::get_bin_vertices	(	const unsigned &	i_bin,
		Vector< Vector< double >> &	bin_vertex
	)

Get vector of vectors containing the coordinates of the vertices of the i_bin-th bin: bin_vertex[j][i] contains the i-th coordinate of the j-th vertex.

  {
    // Spatial dimension of bin
    const unsigned n_lagrangian = this->ndim_zeta();
 
    // How many vertices do we have?
    unsigned n_vertices = 1;
    for (unsigned i = 0; i < n_lagrangian; i++)
    {
      n_vertices *= 2;
    }
    bin_vertex.resize(n_vertices);
 
    // Vectors for min [0] and max [1] coordinates of the bin in each
    // coordinate direction
    Vector<Vector<double>> zeta_vertex_bin(2);
    zeta_vertex_bin[0].resize(n_lagrangian);
    zeta_vertex_bin[1].resize(n_lagrangian);
 
    Vector<double> dzeta;
    unsigned count = 0;
    Vector<unsigned> i_1d;
 
    // Deal with different spatial dimensions separately
    switch (n_lagrangian)
    {
      case 1:
 
        // Assign vertex coordinates of the bin directly
        dzeta.resize(1);
        dzeta[0] = (Min_and_max_coordinates[0].second -
                    Min_and_max_coordinates[0].first) /
                   double(Dimensions_of_bin_array[0]);
        bin_vertex[0].resize(1);
        bin_vertex[0][0] =
          Min_and_max_coordinates[0].first + double(i_bin) * dzeta[0];
        bin_vertex[1].resize(1);
        bin_vertex[1][0] =
          Min_and_max_coordinates[0].first + double(i_bin + 1) * dzeta[0];
 
        break;
 
      case 2:
 
        dzeta.resize(2);
        dzeta[0] = (Min_and_max_coordinates[0].second -
                    Min_and_max_coordinates[0].first) /
                   double(Dimensions_of_bin_array[0]);
        dzeta[1] = (Min_and_max_coordinates[1].second -
                    Min_and_max_coordinates[1].first) /
                   double(Dimensions_of_bin_array[1]);
 
        i_1d.resize(2);
        i_1d[0] = i_bin % Dimensions_of_bin_array[0];
        i_1d[1] = (i_bin - i_1d[0]) / Dimensions_of_bin_array[0];
 
        // Max/min coordinates of the bin
        for (unsigned i = 0; i < n_lagrangian; i++)
        {
          zeta_vertex_bin[0][i] =
            Min_and_max_coordinates[i].first + double(i_1d[i]) * dzeta[i];
          zeta_vertex_bin[1][i] =
            Min_and_max_coordinates[i].first + double(i_1d[i] + 1) * dzeta[i];
        }
 
        // Build 4 vertex coordinates
        count = 0;
        for (unsigned i_min_max = 0; i_min_max < 2; i_min_max++)
        {
          for (unsigned j_min_max = 0; j_min_max < 2; j_min_max++)
          {
            bin_vertex[count].resize(2);
            bin_vertex[count][0] = zeta_vertex_bin[i_min_max][0];
            bin_vertex[count][1] = zeta_vertex_bin[j_min_max][1];
            count++;
          }
        }
 
        break;
 
      case 3:
 
        dzeta.resize(3);
        dzeta[0] = (Min_and_max_coordinates[0].second -
                    Min_and_max_coordinates[0].first) /
                   double(Dimensions_of_bin_array[0]);
        dzeta[1] = (Min_and_max_coordinates[1].second -
                    Min_and_max_coordinates[1].first) /
                   double(Dimensions_of_bin_array[1]);
        dzeta[2] = (Min_and_max_coordinates[2].second -
                    Min_and_max_coordinates[2].first) /
                   double(Dimensions_of_bin_array[2]);
 
        i_1d.resize(3);
        i_1d[0] = i_bin % Dimensions_of_bin_array[0];
        i_1d[1] = ((i_bin - i_1d[0]) / Dimensions_of_bin_array[0]) %
                  Dimensions_of_bin_array[1];
        i_1d[2] = (i_bin - (i_1d[1] * Dimensions_of_bin_array[0] + i_1d[0])) /
                  (Dimensions_of_bin_array[0] * Dimensions_of_bin_array[1]);
 
        // Max/min coordinates of the bin
        for (unsigned i = 0; i < n_lagrangian; i++)
        {
          zeta_vertex_bin[0][i] =
            Min_and_max_coordinates[i].first + double(i_1d[i]) * dzeta[i];
          zeta_vertex_bin[1][i] =
            Min_and_max_coordinates[i].first + double(i_1d[i] + 1) * dzeta[i];
        }
 
        // Build 8 vertex coordinates
        count = 0;
        for (unsigned i_min_max = 0; i_min_max < 2; i_min_max++)
        {
          for (unsigned j_min_max = 0; j_min_max < 2; j_min_max++)
          {
            for (unsigned k_min_max = 0; k_min_max < 2; k_min_max++)
            {
              bin_vertex[count].resize(3);
              bin_vertex[count][0] = zeta_vertex_bin[i_min_max][0];
              bin_vertex[count][1] = zeta_vertex_bin[j_min_max][1];
              bin_vertex[count][2] = zeta_vertex_bin[k_min_max][2];
              count++;
            }
          }
        }
 
        break;
 
      default:
 
        std::ostringstream error_message;
        error_message << "Can't deal with bins in dimension " << n_lagrangian
                      << "\n";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
    }
  }

References BinArray::Dimensions_of_bin_array, i, SamplePointContainer::Min_and_max_coordinates, BinArray::ndim_zeta(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by get_bin(), min_distance(), and output_bin_vertices().

get_fill_stats()

void NonRefineableBinArray::get_fill_stats	(	unsigned &	n_bin,
		unsigned &	max_n_entry,
		unsigned &	min_n_entry,
		unsigned &	tot_n_entry,
		unsigned &	n_empty
	)		const

Provide some stats on the fill level of the associated bin.

  {
    // Total number of bins
    n_bin = nbin();
    n_empty = n_bin - Bin_object_coord_pairs.nnz();
 
    // Get pointer to map-based representation
    const std::map<unsigned, Vector<std::pair<FiniteElement*, Vector<double>>>>*
      map_pt = Bin_object_coord_pairs.map_pt();
 
    // Initialise
    max_n_entry = 0;
    min_n_entry = UINT_MAX;
    tot_n_entry = 0;
 
    // Do stats
    typedef std::map<
      unsigned,
      Vector<std::pair<FiniteElement*, Vector<double>>>>::const_iterator IT;
    for (IT it = map_pt->begin(); it != map_pt->end(); it++)
    {
      unsigned nentry = (*it).second.size();
      if (nentry > max_n_entry) max_n_entry = nentry;
      if (nentry < min_n_entry) min_n_entry = nentry;
      tot_n_entry += nentry;
    }
  }

References Bin_object_coord_pairs, and nbin().

locate_zeta()

void NonRefineableBinArray::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.

Find the sub geometric object and local coordinate therein that corresponds to the intrinsic coordinate zeta. If sub_geom_object_pt=0 on return from this function, none of the constituent sub-objects contain the required coordinate.

Implements SamplePointContainer.

  {
    // Reset counter for number of sample points visited only if we're
    // starting from the beginning
    if (current_min_spiral_level() == 0)
    {
      Total_number_of_sample_points_visited_during_locate_zeta_from_top_level =
        0;
    }
 
    // Initialise return to null -- if it's still null when we're
    // leaving we've failed!
    sub_geom_object_pt = 0;
 
    // Get the lagrangian dimension
    const unsigned n_lagrangian = this->ndim_zeta();
 
    // Does the zeta coordinate lie within the current 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 < n_lagrangian; 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;
        }
      }
    }
 
    // Use the min and max coords of the bin structure, to find
    // the bin structure containing the current zeta cooordinate
    unsigned bin_number = 0;
 
    // Offset for rows/matrices in higher dimensions
    unsigned multiplier = 1;
 
    // Loop over the dimension
    for (unsigned i = 0; i < n_lagrangian; i++)
    {
      // Find the bin number of the current coordinate
      unsigned bin_number_i =
        int(Dimensions_of_bin_array[i] *
            ((zeta[i] - Min_and_max_coordinates[i].first) /
             (Min_and_max_coordinates[i].second -
              Min_and_max_coordinates[i].first)));
 
      // Buffer the case when we are exactly on the edge
      if (bin_number_i == Dimensions_of_bin_array[i])
      {
        bin_number_i -= 1;
      }
 
      // Now add to the bin number using the multiplier
      bin_number += multiplier * bin_number_i;
 
      // Increase the current row/matrix multiplier for the next loop
      multiplier *= Dimensions_of_bin_array[i];
    }
 
    // Loop over spirals that are to be visited in one go
    Vector<unsigned> neighbour_bin;
    unsigned min_level = current_min_spiral_level();
    unsigned max_level = current_max_spiral_level();
    for (unsigned i_level = min_level; i_level <= max_level; i_level++)
    {
      // Call helper function to find the neighbouring bins at this
      // level
      get_neighbouring_bins_helper(bin_number, i_level, neighbour_bin);
 
      // Total number of bins to be visited
      unsigned n_nbr_bin = neighbour_bin.size();
 
      // // keep around and add "false" as last argument to previous call
      // // to get_neighbouring_bins_helper(...) for annotation below to make
      // sense
      // {
      //  Vector<unsigned> old_neighbour_bin;
      //  get_neighbouring_bins_helper(bin_number,
      //                               i_level,
      //                               old_neighbour_bin,
      //                               true); // true=use old version!
      //  unsigned nbin_new = neighbour_bin.size();
      //  unsigned nbin_old = old_neighbour_bin.size();
      //  unsigned n=std::min(nbin_new,nbin_old);
      //  std::sort(old_neighbour_bin.begin(),
      //            old_neighbour_bin.end());
      //  std::sort(neighbour_bin.begin(),
      //            neighbour_bin.end());
      //  oomph_info << "# of neighbouring bins: "
      //             << nbin_new << " " << nbin_old;
      //  if (nbin_new!=nbin_old)
      //   {
      //    oomph_info << " DIFFERENT!";
      //   }
      //  oomph_info << std::endl;
      //  for (unsigned i=0;i<n;i++)
      //   {
      //    oomph_info << neighbour_bin[i] << " "
      //               << old_neighbour_bin[i] << " ";
      //    if (neighbour_bin[i]!=
      //        old_neighbour_bin[i])
      //     {
      //      oomph_info << "DIFFFFERENT";
      //     }
      //    oomph_info << std::endl;
      //   }
      //  if (nbin_new>nbin_old)
      //   {
      //    for (unsigned i=n;i<nbin_new;i++)
      //     {
      //      oomph_info << "NNEW:" << neighbour_bin[i]
      //                 << std::endl;
      //     }
      //   }
      //  if (nbin_old>nbin_new)
      //   {
      //    for (unsigned i=n;i<nbin_old;i++)
      //     {
      //      oomph_info << "OOLD:" << old_neighbour_bin[i]
      //                 << std::endl;
      //     }
      //   }
      // }
 
 
      // Set bool for finding zeta
      bool found_zeta = false;
      for (unsigned i_nbr = 0; i_nbr < n_nbr_bin; i_nbr++)
      {
        // Only search if bin is within the max. radius but min_distance
        // is expensive...
        bool do_it = true;
        if (Max_search_radius < DBL_MAX)
        {
          if (min_distance(neighbour_bin[i_nbr], zeta) > Max_search_radius)
          {
            do_it = false;
          }
        }
        if (do_it)
        {
          // Get the number of element-sample point pairs in this bin
          unsigned n_sample =
            Bin_object_coord_pairs[neighbour_bin[i_nbr]].size();
 
          // Don't do anything if this bin has no sample points
          if (n_sample > 0)
          {
            for (unsigned i_sam = 0; i_sam < n_sample; i_sam++)
            {
              // Get the element
              FiniteElement* el_pt =
                Bin_object_coord_pairs[neighbour_bin[i_nbr]][i_sam].first;
 
              // Get the local coordinate
              s = Bin_object_coord_pairs[neighbour_bin[i_nbr]][i_sam].second;
 
              // History of sample points visited
              if (BinArray::Visited_sample_points_file.is_open())
              {
                unsigned cached_dim_zeta = this->ndim_zeta();
                Vector<double> zeta_sample(cached_dim_zeta);
                if (this->use_eulerian_coordinates_during_setup())
                {
                  el_pt->interpolated_x(s, zeta_sample);
                }
                else
                {
                  el_pt->interpolated_zeta(s, zeta_sample);
                }
                double dist = 0.0;
                for (unsigned ii = 0; ii < cached_dim_zeta; ii++)
                {
                  BinArray::Visited_sample_points_file << zeta_sample[ii]
                                                       << " ";
                  dist +=
                    (zeta[ii] - zeta_sample[ii]) * (zeta[ii] - zeta_sample[ii]);
                }
                BinArray::Visited_sample_points_file
                  << total_number_of_sample_points_visited_during_locate_zeta_from_top_level()
                  << " " << sqrt(dist) << std::endl;
              }
 
              // Use this coordinate as the initial guess
              bool use_coordinate_as_initial_guess = true;
 
              // Attempt to find zeta within a sub-object
              el_pt->locate_zeta(
                zeta, sub_geom_object_pt, s, use_coordinate_as_initial_guess);
 
 
              Total_number_of_sample_points_visited_during_locate_zeta_from_top_level++;
 
              // Always fail? (Used for debugging, e.g. to trace out
              // spiral path)
              if (BinArray::Always_fail_elemental_locate_zeta)
              {
                sub_geom_object_pt = 0;
              }
 
 
#ifdef OOMPH_HAS_MPI
              // Ignore halos?
              if (Ignore_halo_elements_during_locate_zeta_search)
              {
                // Dynamic cast the result to a FiniteElement
                FiniteElement* test_el_pt =
                  dynamic_cast<FiniteElement*>(sub_geom_object_pt);
                if (test_el_pt != 0)
                {
                  // We only want to exit if this is a non-halo element
                  if (test_el_pt->is_halo())
                  {
                    sub_geom_object_pt = 0;
                  }
                }
              }
#endif
 
              // If the FiniteElement is non-halo and has been located, exit
              if (sub_geom_object_pt != 0)
              {
                found_zeta = true;
                break;
              }
            } // end loop over sample points
          }
 
 
          if (found_zeta)
          {
            return; // break;
          }
 
        } // end of don't search if outside search radius
      } // end loop over bins at this level
    } // End of loop over levels
  }

References SamplePointContainer::Always_fail_elemental_locate_zeta, Bin_object_coord_pairs, current_max_spiral_level(), current_min_spiral_level(), BinArray::Dimensions_of_bin_array, BinArray::get_neighbouring_bins_helper(), i, int(), SamplePointContainer::Max_search_radius, SamplePointContainer::Min_and_max_coordinates, min_distance(), Global_Physical_Variables::multiplier(), BinArray::ndim_zeta(), s, sqrt(), SamplePointContainer::total_number_of_sample_points_visited_during_locate_zeta_from_top_level(), SamplePointContainer::Total_number_of_sample_points_visited_during_locate_zeta_from_top_level, SamplePointContainer::use_eulerian_coordinates_during_setup(), SamplePointContainer::Visited_sample_points_file, and Eigen::zeta().

max_spiral_level()

unsigned& NonRefineableBinArray::max_spiral_level ( )

inline

Access function to max. spiral level during straight locate_zeta search (for efficiency; similar to max_search_radius())

  {
    return Max_spiral_level;
  }

References Max_spiral_level.

min_distance()

double NonRefineableBinArray::min_distance	(	const unsigned &	i_bin,
		const Vector< double > &	zeta
	)

Compute the minimum distance of any vertex in the specified bin from the specified Lagrangian coordinate zeta

Compute the minimum distance of any vertex in the specified bin from the specified Lagrangian coordinate zeta.

  {
    // Spatial dimension of bin
    const unsigned n_lagrangian = this->ndim_zeta();
 
    // Get bin vertices
    Vector<Vector<double>> bin_vertex;
    get_bin_vertices(i_bin, bin_vertex);
    double min_dist = DBL_MAX;
    unsigned nvertex = bin_vertex.size();
    for (unsigned v = 0; v < nvertex; v++)
    {
      double dist = 0.0;
      for (unsigned i = 0; i < n_lagrangian; i++)
      {
        dist += pow(bin_vertex[v][i] - zeta[i], 2);
      }
      dist = sqrt(dist);
      if (dist < min_dist) min_dist = dist;
    }
    return min_dist;
  }

References get_bin_vertices(), i, BinArray::ndim_zeta(), Eigen::bfloat16_impl::pow(), sqrt(), v, and Eigen::zeta().

Referenced by fill_bin_by_diffusion(), and locate_zeta().

n_spiral_chunk() [1/2]

unsigned& NonRefineableBinArray::n_spiral_chunk ( )

inline

Number of spirals to be searched in one go.

  {
    return Nspiral_chunk;
  }

References Nspiral_chunk.

n_spiral_chunk() [2/2]

unsigned NonRefineableBinArray::n_spiral_chunk ( ) const

inline

Number of spirals to be searched in one go const version.

  {
    return Nspiral_chunk;
  }

References Nspiral_chunk.

Referenced by oomph::Multi_domain_functions::aux_setup_multi_domain_interaction(), and check_locate_zeta().

nbin()

unsigned NonRefineableBinArray::nbin ( ) const

inlinevirtual

Total number of bins (empty or not)

Implements BinArray.

  {
    const unsigned n_lagrangian = ndim_zeta();
    unsigned ntotalbin = Dimensions_of_bin_array[0];
    for (unsigned i = 1; i < n_lagrangian; i++)
    {
      ntotalbin *= Dimensions_of_bin_array[i];
    }
    return ntotalbin;
  }

References BinArray::Dimensions_of_bin_array, i, and BinArray::ndim_zeta().

Referenced by fill_bin_array(), fill_bin_by_diffusion(), get_fill_stats(), and output_bin_vertices().

operator=()

void NonRefineableBinArray::operator= ( const NonRefineableBinArray &  )

delete

Broken assignment operator.

output_bin_vertices()

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

virtual

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

Implements BinArray.

  {
    // Store the lagrangian dimension
    const unsigned n_lagrangian = this->ndim_zeta();
 
    unsigned nbin = Dimensions_of_bin_array[0];
    if (n_lagrangian > 1) nbin *= Dimensions_of_bin_array[1];
    if (n_lagrangian > 2) nbin *= Dimensions_of_bin_array[2];
 
    for (unsigned i_bin = 0; i_bin < nbin; i_bin++)
    {
      // Get bin vertices
      Vector<Vector<double>> bin_vertex;
      get_bin_vertices(i_bin, bin_vertex);
      switch (n_lagrangian)
      {
        case 1:
          outfile << "ZONE I=2\n";
          break;
 
        case 2:
          outfile << "ZONE I=2, J=2\n";
          break;
 
        case 3:
          outfile << "ZONE I=2, J=2, K=2\n";
          break;
      }
 
      unsigned nvertex = bin_vertex.size();
      for (unsigned i = 0; i < nvertex; i++)
      {
        for (unsigned j = 0; j < n_lagrangian; j++)
        {
          outfile << bin_vertex[i][j] << " ";
        }
        outfile << std::endl;
      }
    }
  }

References BinArray::Dimensions_of_bin_array, get_bin_vertices(), i, j, nbin(), and BinArray::ndim_zeta().

output_bins() [1/2]

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

virtual

Output bins.

Implements BinArray.

  {
    // Spatial dimension of bin
    const unsigned n_lagrangian = this->ndim_zeta();
 
    unsigned nbin_x = Dimensions_of_bin_array[0];
    unsigned nbin_y = 1;
    if (n_lagrangian > 1) nbin_y = Dimensions_of_bin_array[1];
    unsigned nbin_z = 1;
    if (n_lagrangian > 2) nbin_z = Dimensions_of_bin_array[2];
 
    unsigned b = 0;
    for (unsigned iz = 0; iz < nbin_z; iz++)
    {
      for (unsigned iy = 0; iy < nbin_y; iy++)
      {
        for (unsigned ix = 0; ix < nbin_x; ix++)
        {
          unsigned nentry = Bin_object_coord_pairs[b].size();
          for (unsigned e = 0; e < nentry; e++)
          {
            FiniteElement* el_pt = Bin_object_coord_pairs[b][e].first;
            Vector<double> s(Bin_object_coord_pairs[b][e].second);
            Vector<double> zeta(n_lagrangian);
            if (Use_eulerian_coordinates_during_setup)
            {
              el_pt->interpolated_x(s, zeta);
            }
            else
            {
              el_pt->interpolated_zeta(s, zeta);
            }
            for (unsigned i = 0; i < n_lagrangian; i++)
            {
              outfile << zeta[i] << " ";
            }
            outfile << ix << " " << iy << " " << iz << " " << b << " "
                    << std::endl;
          }
          b++;
        }
      }
    }
  }

References b, Bin_object_coord_pairs, BinArray::Dimensions_of_bin_array, e(), i, BinArray::ndim_zeta(), s, SamplePointContainer::Use_eulerian_coordinates_during_setup, and Eigen::zeta().

Referenced by output_bins().

output_bins() [2/2]

void NonRefineableBinArray::output_bins ( std::string &  filename )

inline

Output bins.

  {
    std::ofstream outfile;
    outfile.open(filename.c_str());
    output_bins(outfile);
    outfile.close();
  }

References MergeRestartFiles::filename, and output_bins().

total_number_of_sample_points_computed_recursively()

unsigned NonRefineableBinArray::total_number_of_sample_points_computed_recursively ( ) const

virtual

Compute total number of sample points recursively.

Implements SamplePointContainer.

  {
    // Get pointer to map-based representation
    const std::map<unsigned, Vector<std::pair<FiniteElement*, Vector<double>>>>*
      map_pt = Bin_object_coord_pairs.map_pt();
 
    // Initialise
    unsigned count = 0;
 
    // loop...
    typedef std::map<
      unsigned,
      Vector<std::pair<FiniteElement*, Vector<double>>>>::const_iterator IT;
    for (IT it = map_pt->begin(); it != map_pt->end(); it++)
    {
      count += (*it).second.size();
    }
    return count;
  }

References Bin_object_coord_pairs.

Referenced by NonRefineableBinArray().

Member Data Documentation

Already_warned_about_large_number_of_bin_cells

bool NonRefineableBinArray::Already_warned_about_large_number_of_bin_cells

static

Initial value:

=
    false

Boolean flag to make sure that warning about large number of bin cells only gets triggered once.

Referenced by fill_bin_array().

Already_warned_about_small_number_of_bin_cells

bool NonRefineableBinArray::Already_warned_about_small_number_of_bin_cells

static

Initial value:

=
    false

Boolean flag to make sure that warning about small number of bin cells only gets triggered once.

Referenced by fill_bin_array().

Bin_object_coord_pairs

SparseVector<Vector<std::pair<FiniteElement*, Vector<double> > > > NonRefineableBinArray::Bin_object_coord_pairs

private

Storage for paired objects and coords in each bin.

Referenced by bin_content(), fill_bin_array(), fill_bin_by_diffusion(), flush_bins_of_objects(), get_all_bins_content(), get_fill_stats(), locate_zeta(), output_bins(), and total_number_of_sample_points_computed_recursively().

Current_max_spiral_level

unsigned NonRefineableBinArray::Current_max_spiral_level

private

Current max. spiralling level.

Referenced by current_max_spiral_level(), and NonRefineableBinArray().

Current_min_spiral_level

unsigned NonRefineableBinArray::Current_min_spiral_level

private

Current min. spiralling level.

Referenced by current_min_spiral_level(), and NonRefineableBinArray().

Default_n_bin_1d

unsigned NonRefineableBinArray::Default_n_bin_1d = 100

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; nonrefineable bin wants a much larger value than the refineable one!)

Referenced by NonRefineableBinArray(), and UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::UnstructuredFSIProblem().

Max_spiral_level

unsigned NonRefineableBinArray::Max_spiral_level

private

Max. spiralling level (for efficiency; effect similar to max_search_radius)

Referenced by max_spiral_level(), and NonRefineableBinArray().

Nspiral_chunk

unsigned NonRefineableBinArray::Nspiral_chunk

private

Number of spirals to be searched in one go.

Referenced by n_spiral_chunk(), and NonRefineableBinArray().

Suppress_warning_about_large_total_number_of_bins

bool NonRefineableBinArray::Suppress_warning_about_large_total_number_of_bins

static

Initial value:

=
      false

Boolean to supppress warnings about large number of bins.

Referenced by fill_bin_array().

Suppress_warning_about_small_number_of_bins

bool NonRefineableBinArray::Suppress_warning_about_small_number_of_bins

static

Initial value:

=
    false

Boolean to supppress warnings about small number of bins.

Referenced by fill_bin_array().

Threshold_for_elements_per_bin_warning

unsigned NonRefineableBinArray::Threshold_for_elements_per_bin_warning = 100

static

Fraction of elements/bin that triggers warning. Too many elements per bin can lead to very slow computations

Referenced by fill_bin_array().

Threshold_for_total_bin_cell_number_warning

unsigned long NonRefineableBinArray::Threshold_for_total_bin_cell_number_warning

static

Initial value:

=
      50000000

Total number of bins above which warning is issued. (Default assignment of 100^DIM bins per MeshAsGeomObject can be a killer if there are huge numbers of sub-meshes (e.g. in unstructured FSI).

Referenced by fill_bin_array().

Total_nbin_cells_counter

unsigned long NonRefineableBinArray::Total_nbin_cells_counter = 0

static

Counter for overall number of bins allocated – used to issue warning if this exceeds a threshhold. (Default assignment of 100^DIM bins per MeshAsGeomObject can be a killer if there are huge numbers of sub-meshes (e.g. in unstructured FSI).

Referenced by fill_bin_array(), and flush_bins_of_objects().

---

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

• sample_point_container.h
• sample_point_container.cc