Base class for all bin arrays. More...

#include <sample_point_container.h>

Inheritance diagram for BinArray:

Public Member Functions
	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...

virtual void	output_bins (std::ofstream &outfile)=0
	Output bins (boundaries and number of sample points in them) More...

virtual void	output_bin_vertices (std::ofstream &outfile)=0
	Output bin vertices (allowing display of bin boundaries as zones). More...

virtual unsigned	nbin () const =0

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 void	locate_zeta (const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s)=0

virtual unsigned &	total_number_of_sample_points_visited_during_locate_zeta_from_top_level ()

virtual unsigned	total_number_of_sample_points_computed_recursively () const =0

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

Protected Attributes
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

Additional Inherited Members
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...

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...

Detailed Description

Base class for all bin arrays.

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

Constructor & Destructor Documentation

◆ BinArray() [1/3]

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
	)

inline

Constructor.

     : SamplePointContainer(mesh_pt,
                            min_and_max_coordinates,
                            use_eulerian_coordinates_during_setup,
                            ignore_halo_elements_during_locate_zeta_search,
                            nsample_points_generated_per_element),
       Dimensions_of_bin_array(dimensions_of_bin_array)
   {
     // Note: Resizing of Dimensions_of_bin_array if no sizes are specified
     // is delayed to derived class since refineable and nonrefineable
     // bin arrays have different defaults.
   }

◆ BinArray() [2/3]

BinArray::BinArray ( )

inline

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

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

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ BinArray() [3/3]

BinArray::BinArray ( const BinArray & data )

delete

Broken copy constructor.

◆ ~BinArray()

virtual BinArray::~BinArray ( )

inlinevirtual

Virtual destructor.

440 {}

Member Function Documentation

◆ coords_to_bin_index()

unsigned BinArray::coords_to_bin_index ( const Vector< double > & zeta )

Get (linearly enumerated) bin index of bin that contains specified zeta

Update the coef and the bin index

   {
     unsigned coef = 1;
     unsigned n_bin = 0;
     const unsigned dim = ndim_zeta();
  
     // Loop over all the dimensions
     for (unsigned u = 0; u < dim; u++)
     {
       // for each one get the correct bin "coordinate"
       unsigned local_bin_number = 0;
  
       if (zeta[u] < Min_and_max_coordinates[u].first)
       {
         local_bin_number = 0;
       }
       else if (zeta[u] > Min_and_max_coordinates[u].second)
       {
         local_bin_number = dimensions_of_bin_array(u) - 1;
       }
       else
       {
         local_bin_number = (int(std::min(
           dimensions_of_bin_array(u) - 1,
           unsigned(floor(double(zeta[u] - Min_and_max_coordinates[u].first) /
                          double(Min_and_max_coordinates[u].second -
                                 Min_and_max_coordinates[u].first) *
                          double(dimensions_of_bin_array(u)))))));
       }
  
       n_bin += local_bin_number * coef;
       coef *= dimensions_of_bin_array(u);
     }
  
     // return the correct bin index
     return (n_bin);
   }

References dimensions_of_bin_array(), Eigen::bfloat16_impl::floor(), int(), min, SamplePointContainer::Min_and_max_coordinates, ndim_zeta(), and Eigen::zeta().

Referenced by RefineableBinArray::add_sample_point(), RefineableBinArray::fill_bin_array(), RefineableBinArray::locate_zeta(), and profile_get_neighbouring_bins_helper().

◆ coords_to_vectorial_bin_index()

void BinArray::coords_to_vectorial_bin_index	(	const Vector< double > &	zeta,
		Vector< unsigned > &	bin_index
	)

Get "coordinates" of bin that contains specified zeta.

   {
     unsigned dim = ndim_zeta();
     bin_index.resize(dim);
     for (unsigned u = 0; u < dim; u++)
     {
       if (zeta[u] < Min_and_max_coordinates[u].first)
       {
         bin_index[u] = 0;
       }
       else if (zeta[u] > Min_and_max_coordinates[u].second)
       {
         bin_index[u] = dimensions_of_bin_array(u) - 1;
       }
       else
       {
         bin_index[u] = (int(
           std::min(dimensions_of_bin_array(u) - 1,
                    unsigned(floor((zeta[u] - Min_and_max_coordinates[u].first) /
                                   double(Min_and_max_coordinates[u].second -
                                          Min_and_max_coordinates[u].first) *
                                   double(dimensions_of_bin_array(u)))))));
       }
     }
   }

References dimensions_of_bin_array(), Eigen::bfloat16_impl::floor(), int(), min, SamplePointContainer::Min_and_max_coordinates, ndim_zeta(), and Eigen::zeta().

Referenced by RefineableBinArray::locate_zeta(), and profile_get_neighbouring_bins_helper().

◆ dimension_of_bin_array()

unsigned BinArray::dimension_of_bin_array ( const unsigned & i ) const

inline

Number of bins in coordinate direction i.

   {
     return Dimensions_of_bin_array[i];
   }

References Dimensions_of_bin_array, and i.

Referenced by RefineableBinArray::get_bin_boundaries().

◆ dimensions_of_bin_array() [1/2]

Vector<unsigned> BinArray::dimensions_of_bin_array ( ) const

inline

Number of bins in coordinate directions. Const vector-based version

   {
     return Dimensions_of_bin_array;
   }

References Dimensions_of_bin_array.

Referenced by coords_to_bin_index(), and coords_to_vectorial_bin_index().

◆ dimensions_of_bin_array() [2/2]

unsigned BinArray::dimensions_of_bin_array ( const unsigned & i ) const

inline

Number of bins in specified coordinate direction.

   {
     return Dimensions_of_bin_array[i];
   }

References Dimensions_of_bin_array, and i.

◆ get_neighbouring_bins_helper()

void BinArray::get_neighbouring_bins_helper	(	const unsigned &	bin_index,
		const unsigned &	radius,
		Vector< unsigned > &	neighbouring_bin_index,
		const bool &	use_old_version = `true`
	)

Helper function for computing the bin indices of neighbouring bins at a given "radius" of the specified bin. Final, optional boolean (default: true) chooses to use the old version which appears to be faster than Louis' new one after all (in the few cases where this functionality is still used – not all if we have cgal!)

Helper function for computing the bin indices of neighbouring bins at a given "radius" of the specified bin

   {
     // OLD VERSION
     if (use_old_version)
     {
       neighbouring_bin_index.clear();
  
       // Quick return (slightly hacky -- the machinery below adds the
       // "home" bin twice...)
       if (radius == 0)
       {
         neighbouring_bin_index.push_back(bin_index);
         return;
       }
  
       // translate old code
       unsigned level = radius;
       unsigned bin = bin_index;
  
       // Dimension
       const unsigned n_lagrangian = this->ndim_zeta();
  
       // This will be different depending on the number of Lagrangian
       // coordinates
       if (n_lagrangian == 1)
       {
         // Reserve memory for the container where we return the indices
         // of the neighbouring bins (2 bins max, left and right)
         neighbouring_bin_index.reserve(2);
  
         // Single "loop" in one direction - always a vector of max size 2
         unsigned nbr_bin_left = bin - level;
         if (nbr_bin_left < Dimensions_of_bin_array[0])
         {
           unsigned nbr_bin = nbr_bin_left;
           neighbouring_bin_index.push_back(nbr_bin);
         }
         unsigned nbr_bin_right = bin + level;
         if ((nbr_bin_right < Dimensions_of_bin_array[0]) &&
             (nbr_bin_right != nbr_bin_left))
         {
           unsigned nbr_bin = nbr_bin_right;
           neighbouring_bin_index.push_back(nbr_bin);
         }
       }
       else if (n_lagrangian == 2)
       {
         // Reserve memory for the container where we return the indices
         // of the neighbouring bins
         const unsigned n_max_neighbour_bins = 8 * level;
         neighbouring_bin_index.reserve(n_max_neighbour_bins);
  
         const unsigned n_total_bin =
           Dimensions_of_bin_array[0] * Dimensions_of_bin_array[1];
  
         // Which row of the bin structure is the current bin on?
         // This is just given by the integer answer of dividing bin
         // by Nbin_x (the number of bins in a single row)
         // e.g. in a 6x6 grid, bins 6 through 11 would all have bin_row=1
         const unsigned bin_row = bin / Dimensions_of_bin_array[0];
  
         // The neighbour_bin vector contains all bin numbers at the
         // specified "distance" (level) away from the current bin
  
         // Row/column length
         const unsigned n_length = (level * 2) + 1;
  
         {
           // Visit all the bins at the specified distance (level) away
           // from the current bin. In order to obtain the same order in
           // the visited bins as the previous algorithm we visit all the
           // bins at the specified distance (level) as follows:
  
           // Suppose we want the bins at distance (level=2) of the
           // specified bin, then we visit them as indicated below
  
           // 01 02 03 04 05   // First row
           // 06          07
           // 08    B     09
           // 10          11
           // 12 13 14 15 16   // Last row
           // ^--------------- First column
           //              ^-- Last column
  
           // ----------------------------------------------------------------
           // Visit all the bins in the first row at the specified
           // distance (level) away from the current bin
  
           // ------------------ FIRST ROW ------------------------
           // Pre-compute the distance in the j-direction
           const unsigned j_precomputed = level * Dimensions_of_bin_array[0];
           // Pre-compute the row where the bin should lie on
           const unsigned j_initial_row = bin_row - level;
  
           // Loop over the columns (of the first row)
           for (unsigned i = 0; i < n_length; i++)
           {
             // --------- First row ------------------------------------------
             const unsigned initial_neighbour_bin =
               bin - (level - i) - j_precomputed;
             // This number might fall on the wrong row of the bin
             // structure; this needs to be tested? Not sure why, but leave
             // the test!
  
             // Which row is this number on? (see above)
             const unsigned initial_neighbour_bin_row =
               initial_neighbour_bin / Dimensions_of_bin_array[0];
             // These numbers for the rows must match; if it is then add
             // initial_neighbour_bin to the neighbour scheme (The bin
             // number must also be greater than zero and less than the
             // total number of bins)
             if ((j_initial_row == initial_neighbour_bin_row) &&
                 (initial_neighbour_bin < n_total_bin))
             {
               neighbouring_bin_index.push_back(initial_neighbour_bin);
             }
  
           } // for (unsigned i=0;i<n_length;i++)
  
           // Then visit all the bins in the first and last column at the
           // specified distance (level) away from the current bin
  
           // ------------------ FIRST AND LAST COLUMNS ---------------------
           // Loop over the rows (of the first and last column)
           for (unsigned j = 1; j < n_length - 1; j++)
           {
             // --------- First column ---------------------------------------
             const unsigned initial_neighbour_bin =
               bin - (level) - ((level - j) * Dimensions_of_bin_array[0]);
             // This number might fall on the wrong row of the bin
             // structure; this needs to be tested? Not sure why, but leave
             // the test!
  
             // Which row is this number on? (see above)
             const unsigned initial_neighbour_bin_row =
               initial_neighbour_bin / Dimensions_of_bin_array[0];
  
             // Which row should it be on?
             const unsigned initial_row = bin_row - (level - j);
  
             // These numbers for the rows must match; if it is then add
             // initial_neighbour_bin to the neighbour scheme (The bin
             // number must also be greater than zero and less than the
             // total number of bins)
             if ((initial_row == initial_neighbour_bin_row) &&
                 (initial_neighbour_bin < n_total_bin))
             {
               neighbouring_bin_index.push_back(initial_neighbour_bin);
             }
  
             // --------- Last column -----------------------------------------
             const unsigned final_neighbour_bin =
               bin + (level) - ((level - j) * Dimensions_of_bin_array[0]);
             // This number might fall on the wrong row of the bin
             // structure; this needs to be tested? Not sure why, but leave
             // the test!
  
             // Which row is this number on? (see above)
             const unsigned final_neighbour_bin_row =
               final_neighbour_bin / Dimensions_of_bin_array[0];
  
             // Which row should it be on?
             const unsigned final_row = bin_row - (level - j);
  
             // These numbers for the rows must match; if it is then add
             // initial_neighbour_bin to the neighbour scheme (The bin
             // number must also be greater than zero and less than the
             // total number of bins)
             if ((final_row == final_neighbour_bin_row) &&
                 (final_neighbour_bin < n_total_bin))
             {
               neighbouring_bin_index.push_back(final_neighbour_bin);
             }
  
           } // for (unsigned j=1;j<n_length-1;j++)
  
           // ------------------ LAST ROW ------------------------
           // Pre-compute the row where the bin should lie on
           const unsigned j_final_row = bin_row + level;
  
           // Loop over the columns (of the last row)
           for (unsigned i = 0; i < n_length; i++)
           {
             // --------- Last row ------------------------------------------
             const unsigned final_neighbour_bin =
               bin - (level - i) + j_precomputed;
             // This number might fall on the wrong row of the bin
             // structure; this needs to be tested? Not sure why, but leave
             // the test!
  
             // Which row is this number on? (see above)
             const unsigned final_neighbour_bin_row =
               final_neighbour_bin / Dimensions_of_bin_array[0];
             // These numbers for the rows must match; if it is then add
             // initial_neighbour_bin to the neighbour scheme (The bin
             // number must also be greater than zero and less than the
             // total number of bins)
             if ((j_final_row == final_neighbour_bin_row) &&
                 (final_neighbour_bin < n_total_bin))
             {
               neighbouring_bin_index.push_back(final_neighbour_bin);
             }
  
           } // for (unsigned i=0;i<n_length;i++)
         }
       }
       else if (n_lagrangian == 3)
       {
         // Reserve memory for the container where we return the indices
         // of the neighbouring bins
         const unsigned n_max_neighbour_bins =
           8 * level * (3 + 2 * (level - 1)) +
           2 * (2 * (level - 1) + 1) * (2 * (level - 1) + 1);
         neighbouring_bin_index.reserve(n_max_neighbour_bins);
  
         unsigned n_total_bin = Dimensions_of_bin_array[0] *
                                Dimensions_of_bin_array[1] *
                                Dimensions_of_bin_array[2];
  
         // Which layer of the bin structure is the current bin on?
         // This is just given by the integer answer of dividing bin
         // by Nbin_x*Nbin_y (the number of bins in a single layer
         // e.g. in a 6x6x6 grid, bins 72 through 107 would all have bin_layer=2
         unsigned bin_layer =
           bin / (Dimensions_of_bin_array[0] * Dimensions_of_bin_array[1]);
  
         // Which row in this layer is the bin number on?
         unsigned bin_row = (bin / Dimensions_of_bin_array[0]) -
                            (bin_layer * Dimensions_of_bin_array[1]);
  
         // The neighbour_bin vector contains all bin numbers at the
         // specified "distance" (level) away from the current bin
  
         // Row/column/layer length
         unsigned n_length = (level * 2) + 1;
  
         // Loop over the layers
         for (unsigned k = 0; k < n_length; k++)
         {
           // Loop over the rows
           for (unsigned j = 0; j < n_length; j++)
           {
             // Loop over the columns
             for (unsigned i = 0; i < n_length; i++)
             {
               // Only do this for the end points of every row/layer/column
               if ((k == 0) || (k == n_length - 1) || (j == 0) ||
                   (j == n_length - 1) || (i == 0) || (i == n_length - 1))
               {
                 unsigned nbr_bin = bin - level + i -
                                    ((level - j) * Dimensions_of_bin_array[0]) -
                                    ((level - k) * Dimensions_of_bin_array[0] *
                                     Dimensions_of_bin_array[1]);
                 // This number might fall on the wrong
                 // row or layer of the bin structure; this needs to be tested
  
                 // Which layer is this number on?
                 unsigned nbr_bin_layer = nbr_bin / (Dimensions_of_bin_array[0] *
                                                     Dimensions_of_bin_array[1]);
  
                 // Which row is this number on? (see above)
                 unsigned nbr_bin_row =
                   (nbr_bin / Dimensions_of_bin_array[0]) -
                   (nbr_bin_layer * Dimensions_of_bin_array[1]);
  
                 // Which layer and row should it be on, given level?
                 unsigned layer = bin_layer - level + k;
                 unsigned row = bin_row - level + j;
  
                 // These layers and rows must match up:
                 // if so then add nbr_bin to the neighbour schemes
                 // (The bin number must also be greater than zero
                 //  and less than the total number of bins)
                 if ((row == nbr_bin_row) && (layer == nbr_bin_layer) &&
                     (nbr_bin < n_total_bin))
                 {
                   neighbouring_bin_index.push_back(nbr_bin);
                 }
               }
             }
           }
         }
       }
     }
     // LOUIS'S VERSION
     else
     {
       neighbouring_bin_index.clear();
  
       // Just testing if the radius is equal to 0
       if (radius == 0)
       {
         // in this case we only have to push back the bin
         neighbouring_bin_index.push_back(bin_index);
       }
       // Else, if the radius is different from 0
       else
       {
         unsigned dim = ndim_zeta();
  
         // The vector which will store the coordinates of the bin in the bin
         // arrray
         Vector<int> vector_of_positions(3);
  
         // Will store locally the dimension of the bin array
         Vector<int> vector_of_dimensions(3);
  
         // Will store the radiuses for each dimension
         // If it is 0, that means the dimension is not vector_of_active_dim
         Vector<int> vector_of_radiuses(3);
  
         // Stores true if the dimension is "active" or false if the
         // dimension is inactive (for example the third dimension is inactive in
         // a 2D mesh).
         std::vector<bool> vector_of_active_dim(3);
  
         // Will store the coefficients you have to multiply each bin coordinate
         // to have the correct unsigned corresponding to the bin index.
         Vector<int> vector_of_coef(3);
  
  
         // First initializing this MyArrays for the active dimensions
         unsigned coef = 1;
         for (unsigned u = 0; u < dim; u++)
         {
           vector_of_positions[u] =
             (((bin_index / coef) % (Dimensions_of_bin_array[u])));
           vector_of_coef[u] = coef;
           coef *= Dimensions_of_bin_array[u];
           vector_of_dimensions[u] = Dimensions_of_bin_array[u];
           vector_of_radiuses[u] = radius;
           vector_of_active_dim[u] = true;
         }
         // Filling the rest with default values
         for (unsigned u = dim; u < 3; u++)
         {
           vector_of_positions[u] = 0;
           vector_of_coef[u] = 0;
           vector_of_dimensions[u] = 1;
           vector_of_radiuses[u] = 0;
           vector_of_active_dim[u] = false;
         }
  
         // First we fill the bins which corresponds to x+radius and x-radius in
         // the bin array (x being the first coordinate/dimension).
         // For j equal to radius or -radius
         for (int j = -vector_of_radiuses[0]; j <= vector_of_radiuses[0];
              j += 2 * vector_of_radiuses[0]) // j corresponds to x
         {
           int local_tempj =
             vector_of_positions[0] + j; // Corresponding bin index
           // if we are in the bin array
           if (local_tempj >= 0 && local_tempj < vector_of_dimensions[0])
           {
             // Loop over all the bins
             for (int i = -vector_of_radiuses[1]; i <= vector_of_radiuses[1];
                  i++)
             {
               // i corresponds to y (2nd dim)
               int local_tempi = vector_of_positions[1] + i;
               // if we are still in the bin array
               if (local_tempi >= 0 && local_tempi < vector_of_dimensions[1])
               {
                 for (int k = -vector_of_radiuses[2]; k <= vector_of_radiuses[2];
                      k++)
                 {
                   // k corresponds to z (third dimension)
                   int local_tempk = vector_of_positions[2] + k;
                   // if we are still in the bin array
                   if (local_tempk >= 0 && local_tempk < vector_of_dimensions[2])
                   {
                     neighbouring_bin_index.push_back(
                       local_tempj * vector_of_coef[0] +
                       local_tempi * vector_of_coef[1] +
                       local_tempk * vector_of_coef[2]);
                   }
                 }
               }
             }
           }
         }
         // Secondly we get the bins corresponding to y+radius and y-radius
         // only if the second dimension is active
         if (vector_of_active_dim[1])
         {
           // For i equal to radius or -radius (i corresponds to y)
           for (int i = -vector_of_radiuses[1]; i <= vector_of_radiuses[1];
                i += 2 * vector_of_radiuses[1])
           {
             int local_tempi = vector_of_positions[1] + i;
             if (local_tempi >= 0 && local_tempi < vector_of_dimensions[1])
             {
               // We loop over all the surface
               for (int j = -vector_of_radiuses[0] + 1;
                    j <= vector_of_radiuses[0] - 1;
                    j++)
               {
                 int local_tempj = vector_of_positions[0] + j;
                 if (local_tempj >= 0 && local_tempj < vector_of_dimensions[0])
                 {
                   for (int k = -vector_of_radiuses[2];
                        k <= vector_of_radiuses[2];
                        k++)
                   {
                     int local_tempk = vector_of_positions[2] + k;
                     if (local_tempk >= 0 &&
                         local_tempk < vector_of_dimensions[2])
                     {
                       neighbouring_bin_index.push_back(
                         local_tempj * vector_of_coef[0] +
                         local_tempi * vector_of_coef[1] +
                         local_tempk * vector_of_coef[2]);
                     }
                   }
                 }
               }
             }
           }
         }
         // Thirdly we get the bins corresponding to z+radius and z-radius
         // if the third dimension is active.
         if (vector_of_active_dim[2])
         {
           // for k equal to radius or -radius (k corresponds to z)
           for (int k = -vector_of_radiuses[2]; k <= vector_of_radiuses[2];
                k += 2 * vector_of_radiuses[2])
           {
             int local_tempk = vector_of_positions[2] + k;
             if (local_tempk >= 0 && local_tempk < vector_of_dimensions[2])
             {
               // We loop over all the surface
               for (int j = -vector_of_radiuses[0] + 1;
                    j <= vector_of_radiuses[0] - 1;
                    j++)
               {
                 int local_tempj = vector_of_positions[0] + j;
                 if (local_tempj >= 0 && local_tempj < vector_of_dimensions[0])
                 {
                   for (int i = -vector_of_radiuses[1] + 1;
                        i <= vector_of_radiuses[1] - 1;
                        i++)
                   {
                     int local_tempi = vector_of_positions[1] + i;
                     if (local_tempi >= 0 &&
                         local_tempi < vector_of_dimensions[1])
                     {
                       neighbouring_bin_index.push_back(
                         local_tempj * vector_of_coef[0] +
                         local_tempi * vector_of_coef[1] +
                         local_tempk * vector_of_coef[2]);
                     }
                   }
                 }
               }
             }
           }
         }
       }
     } // end new version
   }

References Dimensions_of_bin_array, i, j, k, ndim_zeta(), UniformPSDSelfTest::radius, and row().

Referenced by NonRefineableBinArray::fill_bin_by_diffusion(), RefineableBinArray::locate_zeta(), NonRefineableBinArray::locate_zeta(), RefineableBinArray::output_neighbouring_bins(), and profile_get_neighbouring_bins_helper().

◆ max_bin_dimension()

unsigned BinArray::max_bin_dimension ( ) const

Max. bin dimension (number of bins in coordinate directions)

   {
     unsigned dim = ndim_zeta();
     unsigned n_max_level = Dimensions_of_bin_array[0];
     if (dim >= 2)
     {
       if (Dimensions_of_bin_array[1] > n_max_level)
       {
         n_max_level = Dimensions_of_bin_array[1];
       }
     }
     if (dim == 3)
     {
       if (Dimensions_of_bin_array[2] > n_max_level)
       {
         n_max_level = Dimensions_of_bin_array[2];
       }
     }
     return n_max_level;
   }

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

◆ nbin()

virtual unsigned BinArray::nbin ( ) const

pure virtual

Number of bins (not taking recursion into account for refineable versions)

Implemented in NonRefineableBinArray, and RefineableBinArray.

◆ ndim_zeta()

unsigned BinArray::ndim_zeta ( ) const

inlinevirtual

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

Implements SamplePointContainer.

   {
     return Dimensions_of_bin_array.size();
   }

References Dimensions_of_bin_array.

◆ operator=()

void BinArray::operator= ( const BinArray & )

delete

Broken assignment operator.

◆ output_bin_vertices()

virtual void BinArray::output_bin_vertices ( std::ofstream & outfile )

pure virtual

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

Implemented in NonRefineableBinArray, and RefineableBinArray.

◆ output_bins()

virtual void BinArray::output_bins ( std::ofstream & outfile )

pure virtual

Output bins (boundaries and number of sample points in them)

Implemented in NonRefineableBinArray, and RefineableBinArray.

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

◆ profile_get_neighbouring_bins_helper()

void BinArray::profile_get_neighbouring_bins_helper ( )

Profiling function to compare performance of two different versions of the get_neighbouring_bins_helper(...) function

   {
     unsigned old_faster = 0;
     unsigned new_faster = 0;
     double t_total_new = 0.0;
     double t_total_old = 0.0;
  
     unsigned dim = ndim_zeta();
  
     // Choose bin in middle of the domain
     Vector<double> zeta(dim);
     for (unsigned i = 0; i < dim; i++)
     {
       zeta[i] = 0.5 * (Min_and_max_coordinates[i].first +
                        Min_and_max_coordinates[i].second);
     }
  
     // 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_old;
     Vector<unsigned> bin_index_at_current_radius_new;
     while (radius <= max_radius)
     {
       // Get the neighbouring bins
       bin_index_at_current_radius_old.clear();
       double t_start = TimingHelpers::timer();
       get_neighbouring_bins_helper(
         bin_index, radius, bin_index_at_current_radius_old, true);
       unsigned nbin_at_current_radius_old =
         bin_index_at_current_radius_old.size();
       double t_end = TimingHelpers::timer();
       double t_old = t_end - t_start;
  
       bin_index_at_current_radius_new.clear();
       double t_start_new = TimingHelpers::timer();
       get_neighbouring_bins_helper(
         bin_index, radius, bin_index_at_current_radius_new, false);
       unsigned nbin_at_current_radius_new =
         bin_index_at_current_radius_new.size();
       double t_end_new = TimingHelpers::timer();
  
       double t_new = t_end_new - t_start_new;
  
       if (nbin_at_current_radius_new != nbin_at_current_radius_old)
       {
         oomph_info << "Number of bins don't match: new = "
                    << nbin_at_current_radius_new
                    << "old = " << nbin_at_current_radius_old
                    << " radius = " << radius << std::endl;
         oomph_info << "Old: " << std::endl;
         for (unsigned i = 0; i < nbin_at_current_radius_old; i++)
         {
           oomph_info << bin_index_at_current_radius_old[i] << " ";
         }
         oomph_info << std::endl;
         oomph_info << "New: " << std::endl;
         for (unsigned i = 0; i < nbin_at_current_radius_new; i++)
         {
           oomph_info << bin_index_at_current_radius_new[i] << " ";
         }
         oomph_info << std::endl;
       }
  
       t_total_new += t_new;
       t_total_old += t_old;
  
       if (t_new < t_old)
       {
         new_faster++;
       }
       else
       {
         old_faster++;
       }
       radius++;
     }
  
  
     oomph_info << "Number of times old/new version was faster: " << old_faster
                << " " << new_faster << std::endl
                << "Total old/new time: " << t_total_old << " " << t_total_new
                << " " << std::endl;
   }

References coords_to_bin_index(), coords_to_vectorial_bin_index(), Dimensions_of_bin_array, get_neighbouring_bins_helper(), i, k, max, SamplePointContainer::Min_and_max_coordinates, ndim_zeta(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, UniformPSDSelfTest::radius, and Eigen::zeta().

Member Data Documentation

◆ Dimensions_of_bin_array

Vector<unsigned> BinArray::Dimensions_of_bin_array

protected

Number of bins in each coordinate direction.

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

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BinArray() [1/3]

◆ BinArray() [2/3]

◆ BinArray() [3/3]

◆ ~BinArray()

Member Function Documentation

◆ coords_to_bin_index()

◆ coords_to_vectorial_bin_index()

◆ dimension_of_bin_array()

◆ dimensions_of_bin_array() [1/2]

◆ dimensions_of_bin_array() [2/2]

◆ get_neighbouring_bins_helper()

◆ max_bin_dimension()

◆ nbin()

◆ ndim_zeta()

◆ operator=()

◆ output_bin_vertices()

◆ output_bins()

◆ profile_get_neighbouring_bins_helper()

Member Data Documentation

◆ Dimensions_of_bin_array