Class to represent particles embedded in a grid. More...

#include <particles.h>

Classes
class	update_ptcl_to_grd_host

Public Types
enum class	output_format : idx_t { csv = 0 , octave_ascii = 1 , json = 2 }
	Enumeration of available output format. More...
enum class	cell_color : idx_t { red = 0 , green = 1 , blue = 2 , black = 3 , all_colors = 4 }
	Enumeration of cell colors. More...
using	idx_t = quadgrid_t<vector_t<real_t>>::idx_t
	datatype for indexing into vectors of properties

Public Member Functions
real_t	default_x_generator ()
	The default generator function used to set up x-coordinates of particle positions if none is is specified.
real_t	default_y_generator ()
	The default generator function used to set up y-coordinates of particle positions if none is is specified.
template<output_format fmt>
void	print (std::ostream &os) const
	Template for export function.
	particles_t (idx_t n, const quadgrid_t< vector_t< real_t > > &grid_)
	Simplest form of constructor.
	particles_t (const nlohmann::json &j, const quadgrid_t< vector_t< real_t > > &grid_)
	Ctor to import data from json.
	particles_t (idx_t n, const vector_t< std::string > &ipropnames, const vector_t< std::string > &dpropnames, const quadgrid_t< vector_t< real_t > > &grid_)
	Constructor with default position generators.
	particles_t (idx_t n, const vector_t< std::string > &ipropnames, const vector_t< std::string > &dpropnames, const quadgrid_t< vector_t< real_t > > &grid_, const vector_t< real_t > &xv, const vector_t< real_t > &yv)
	Constructor with custom position vectors.
	particles_t (idx_t n, const vector_t< std::string > &ipropnames, const vector_t< std::string > &dpropnames, const quadgrid_t< vector_t< real_t > > &grid_, std::function< real_t()> xgen, std::function< real_t()> ygen)
	Constructor with custom position generators.
void	init_props (const vector_t< std::string > &ipropnames, const vector_t< std::string > &dpropnames)
	Initialize particle properties.
void	remove_in_region (std::function< bool(real_t, real_t)> fun)
	Erase particcles based on coordinates.
void	memcpy_host_to_device ()
	Copy Host To Device.
void	memcpy_device_to_host ()
	Copy Device To Host.
void	init_particle_mesh ()
	Build grid/particles connectivity.
template<class backend>
void	update_ptcl_to_grd ()
	Updates theptcl_to_grd map only, without changing.
void	mark_by_cell_color ()
	Mark particles by cell color.
void	reorder (vector_t< idx_t > &)
	Reorder coordinates an properties according to the ordering vvector.
void	init_particle_positions (std::function< real_t()> xgentr, std::function< real_t()> ygentr)
	Initialize particle positions with generator functions.
void	build_mass ()
	Construct a mass matrix.
real_t &	dp (const std::string &name, idx_t ii)
	shortcut for dprops.at (name) [ii]
const real_t &	dp (const std::string &name, idx_t ii) const
	shortcut for dprops.at (name) [ii]
idx_t &	ip (const std::string &name, idx_t ii)
	shortcut for iprops.at (name) [ii]
const idx_t &	ip (const std::string &name, idx_t ii) const
	shortcut for iprops.at (name) [ii]
void	p2g (std::map< std::string, device_vector_t< real_t > > &vars, bool apply_mass=false)
	Map particle variables to the grid.
template<typename GT, typename PT>
void	p2g (std::map< std::string, device_vector_t< real_t > > &vars, PT const &pvarnames, GT const &gvarnames, bool apply_mass=false)
	Map particle variables to the grid.
template<typename str>
void	p2g (std::map< std::string, device_vector_t< real_t > > &vars, std::initializer_list< str > const &pvarnames, std::initializer_list< str > const &gvarnames, bool apply_mass=false)
template<typename UnaryFunction>
void	p2g (std::map< std::string, device_vector_t< real_t > > &vars, UnaryFunction helper)
template<typename GT, typename PT>
void	p2g_print (std::map< std::string, vector_t< real_t > > &vars, PT const &pvarnames, GT const &gvarnames, bool apply_mass=false) const
template<typename str>
void	p2g_print (std::map< std::string, vector_t< real_t > > &vars, std::initializer_list< str > const &pvarnames, std::initializer_list< str > const &gvarnames, bool apply_mass=false) const
template<typename GT, typename PT>
void	p2gd (std::map< std::string, device_vector_t< real_t > > &vars, PT const &pxvarnames, PT const &pyvarnames, std::string const &area, GT const &gvarnames, bool apply_mass=false)
template<typename str>
void	p2gd (std::map< std::string, device_vector_t< real_t > > &vars, std::initializer_list< str > const &pxvarnames, std::initializer_list< str > const &pyvarnames, std::string const &area, std::initializer_list< str > const &gvarnames, bool apply_mass=false)
template<typename UnaryFunction>
void	p2gd (std::map< std::string, device_vector_t< real_t > > &vars, UnaryFunction helper)
void	g2p (const std::map< std::string, device_vector_t< real_t > > &vars, bool apply_mass=false)
template<typename str>
void	g2p (const std::map< std::string, device_vector_t< real_t > > &vars, std::initializer_list< str > const &gvarnames, std::initializer_list< str > const &pvarnames, bool apply_mass=false)
template<typename GT, typename PT>
void	g2p (const std::map< std::string, device_vector_t< real_t > > &vars, GT const &gvarnames, PT const &pvarnames, bool apply_mass=false)
template<typename UnaryFunction>
void	g2p (std::map< std::string, device_vector_t< real_t > > &vars, UnaryFunction helper)
template<typename GT, typename PT>
void	g2pd (const std::map< std::string, device_vector_t< real_t > > &vars, GT const &gvarnames, PT const &pxvarnames, PT const &pyvarnames, bool apply_mass=false)
template<typename str>
void	g2pd (const std::map< std::string, device_vector_t< real_t > > &vars, std::initializer_list< str > const &gvarnames, std::initializer_list< str > const &pxvarnames, std::initializer_list< str > const &pyvarnames, bool apply_mass=false)
template<typename UnaryFunction>
void	g2pd (std::map< std::string, device_vector_t< real_t > > &vars, UnaryFunction helper)

Static Public Member Functions
static const std::string &	getkey (std::map< std::string, device_vector_t< real_t > > const &varnames, std::size_t ivar)
static const std::string &	getkey (vector_t< std::string > const &varnames, std::size_t ivar)
static const char *	getkey (std::initializer_list< const char * > const &varnames, std::size_t ivar)

Public Attributes
idx_t	num_particles
	number of particles.
vector_t< real_t >	x
	x coordinate of particle positions.
vector_t< real_t >	y
	y coordinate of particle positions.
std::map< std::string, vector_t< idx_t > >	iprops
	integer type quantities associated with the particles.
std::map< std::string, vector_t< real_t > >	dprops
	double type quantities associated with the particles.
vector_t< real_t >	M
	Mass matrix to be used for transfers if required.
std::map< idx_t, vector_t< idx_t > >	grd_to_ptcl
	grid->particles connectivity.
vector_t< idx_t >	ptcl_to_grd
	particles->grid connectivity.
vector_t< idx_t >	ptcl_grd_color
	color of particle's cell.
const quadgrid_t< vector_t< real_t > > &	grid
	refernce to a grid object.

Detailed Description

Class to represent particles embedded in a grid.

Offers methods for transfer of quantities from particles to grid or vice-versa (particles_t::p2g, g2p, p2gd, g2pd). Initial positions of the particles are chosen at random unless otherwise specified. To each particle a set one can associate a set of double and one of int which are stored in the std::map variables dprops and iprops, respectively. Can compute a (lumped) mass matrix to be used in the transfer functions. If particles are moved, the connectivity must be updated invoking the method init_particle_mesh ()

Definition at line 28 of file particles.h.

Member Typedef Documentation

◆ idx_t

using particles_t::idx_t = quadgrid_t<vector_t<real_t>>::idx_t

datatype for indexing into vectors of properties

Definition at line 32 of file particles.h.

Member Enumeration Documentation

◆ cell_color

enum class particles_t::cell_color : idx_t

strong

Enumeration of cell colors.

Enumerator
red
green
blue
black
all_colors

Definition at line 77 of file particles.h.

             : idx_t {
    red   = 0,
    green = 1,
    blue  = 2,
    black = 3,
    all_colors = 4
  };

◆ output_format

enum class particles_t::output_format : idx_t

strong

Enumeration of available output format.

Enumerator
csv	comma separated ascii file with headers, can be read by common spreadsheet apps or by Paraview or Octave.
octave_ascii	GNU Octave ascii data format, can be loaded via the load command in GNU Octave.
json

Definition at line 63 of file particles.h.

                : idx_t {
    csv = 0,           
 
    octave_ascii = 1,  
 
    json = 2           
  };

Constructor & Destructor Documentation

◆ particles_t() [1/5]

particles_t::particles_t	(	idx_t	n,
		const quadgrid_t< vector_t< real_t > > &	grid_ )

inline

Simplest form of constructor.

Particle positions are not assigned, they must be set manually later.

Parameters

n	number of particles
grid_	quadgrid_t object, sizes need to have been already set up.

Definition at line 118 of file particles.h.

119 : num_particles(n), grid(grid_) { }

particles_t::num_particles

idx_t num_particles

number of particles.

Definition particles.h:34

particles_t::grid

const quadgrid_t< vector_t< real_t > > & grid

refernce to a grid object.

Definition particles.h:48

◆ particles_t() [2/5]

particles_t::particles_t	(	const nlohmann::json &	j,
		const quadgrid_t< vector_t< real_t > > &	grid_ )

inline

Ctor to import data from json.

Grid data may be stored in the same json object but must be read separately before invoking this constructor.

Definition at line 125 of file particles.h.

    :  grid(grid_)
  {
    j["dprops"].get_to<std::map<std::string, vector_t<real_t>>> (dprops);
    j["iprops"].get_to<std::map<std::string, vector_t<int>>> (iprops);
    j["x"].get_to<vector_t<real_t>> (x);
    j["y"].get_to<vector_t<real_t>> (y);
    j["num_particles"].get_to<idx_t> (num_particles);
  }

◆ particles_t() [3/5]

particles_t::particles_t	(	idx_t	n,
		const vector_t< std::string > &	ipropnames,
		const vector_t< std::string > &	dpropnames,
		const quadgrid_t< vector_t< real_t > > &	grid_ )

Constructor with default position generators.

Distributes particles randomly over the grid.

Parameters

n	number of particles
grid_	quadgrid_t object, sizes need to have been already set up.
ipropnames	keys for entries in the particles_t::iprops map.
dpropnames	keys for entries in the particles_t::dprops map.

Definition at line 27 of file particles.cpp.

   :  particles_t (n, grid_) {
 
  init_props (ipropnames, dpropnames);
 
  init_particle_positions
    (
     [this] { return this->default_x_generator (); },
     [this] { return this->default_y_generator (); }
     );
 
  init_particle_mesh ();
}

◆ particles_t() [4/5]

particles_t::particles_t	(	idx_t	n,
		const vector_t< std::string > &	ipropnames,
		const vector_t< std::string > &	dpropnames,
		const quadgrid_t< vector_t< real_t > > &	grid_,
		const vector_t< real_t > &	xv,
		const vector_t< real_t > &	yv )

Constructor with custom position vectors.

Distributes particles based on the given vectors xv and yv. The vectors are copied, and left unchangend they can be deleted to reclaim memory if needed.

Parameters

n	number of particles
grid_	quadgrid_t object, sizes need to have been already set up.
ipropnames	keys for entries in the particles_t::iprops map.
dpropnames	keys for entries in the particles_t::dprops map.
xv	the x-coordinates of new particles.
yv	the y-coordinates of new particles.

Definition at line 46 of file particles.cpp.

   : particles_t (n, grid_) {
 
  x = xgen;
  y = ygen;
 
  init_props (ipropnames, dpropnames);
 
  init_particle_mesh ();
}

◆ particles_t() [5/5]

particles_t::particles_t	(	idx_t	n,
		const vector_t< std::string > &	ipropnames,
		const vector_t< std::string > &	dpropnames,
		const quadgrid_t< vector_t< real_t > > &	grid_,
		std::function< real_t()>	xgen,
		std::function< real_t()>	ygen )

Constructor with custom position generators.

Distributes particles based on the given generator functions xgen and ygen. Each call to these functions should return the x- and y-coordinate of a new particle.

Parameters

n	number of particles
grid_	quadgrid_t object, sizes need to have been already set up.
ipropnames	keys for entries in the particles_t::iprops map.
dpropnames	keys for entries in the particles_t::dprops map.
xgen	generator function for the x-coordinates of new particles.
ygen	generator function for the y-coordinates of new particles.

Definition at line 63 of file particles.cpp.

   : particles_t (n, grid_) {
 
  init_props (ipropnames, dpropnames);
 
  init_particle_positions (xgen, ygen);
 
  init_particle_mesh ();
}

Member Function Documentation

◆ build_mass()

void particles_t::build_mass ( )

Construct a mass matrix.

Must be invoked manually before invoking any of the transfer methods with flag use_mass set to true

Definition at line 208 of file particles.cpp.

                         {
  M.assign (grid.num_global_nodes (), 0.0);
  for (auto icell = grid.begin_cell_sweep ();
       icell != grid.end_cell_sweep (); ++icell) {
    for (auto inode = 0;
     inode < quadgrid_t<vector_t<real_t>>::cell_t::nodes_per_cell;
     ++inode) {
      M[icell->gt (inode)] += (grid.hx () / 2.) * (grid.hy () / 2.);
    }
  }
}

◆ default_x_generator()

real_t particles_t::default_x_generator ( )

The default generator function used to set up x-coordinates of particle positions if none is is specified.

Generates a uniform random distribution.

Definition at line 12 of file particles.cpp.

                                  {
  static std::random_device rd;
  static std::mt19937 gen (rd ());
  static std::uniform_real_distribution<> dis (0.0, 1.0);
  return dis (gen) * grid.num_cols () * grid.hx ();
}

◆ default_y_generator()

real_t particles_t::default_y_generator ( )

The default generator function used to set up y-coordinates of particle positions if none is is specified.

Generates a uniform random distribution.

Definition at line 20 of file particles.cpp.

                                  {
  static std::random_device rd;
  static std::mt19937 gen (rd ());
  static std::uniform_real_distribution<> dis (0.0, 1.0);
  return dis (gen) * grid.num_rows () * grid.hy ();
}

◆ dp() [1/2]

real_t & particles_t::dp	(	const std::string &	name,
		idx_t	ii )

inline

shortcut for dprops.at (name) [ii]

Definition at line 282 of file particles.h.

                                        {
    return dprops.at (name) [ii];
  }

◆ dp() [2/2]

const real_t & particles_t::dp	(	const std::string &	name,
		idx_t	ii ) const

inline

shortcut for dprops.at (name) [ii]

Definition at line 288 of file particles.h.

                                              {
    return dprops.at (name) [ii];
  }

◆ g2p() [1/4]

void particles_t::g2p	(	const std::map< std::string, device_vector_t< real_t > > &	vars,
		bool	apply_mass = false )

inline

Definition at line 401 of file particles.h.

                              {
    g2p (vars, vars, vars, apply_mass);
  }

◆ g2p() [2/4]

template<typename GT, typename PT>

void particles_t::g2p	(	const std::map< std::string, device_vector_t< real_t > > &	vars,
		GT const &	gvarnames,
		PT const &	pvarnames,
		bool	apply_mass = false )

Definition at line 324 of file particles_imp.h.

                  {
 
  using idx_t = particles_t::idx_t;
  //real_t N = 0.0, xx = 0.0, yy = 0.0;
  //idx_t idx = 0;
 
  for (std::size_t ivar = 0; ivar < std::size (gvarnames); ++ivar) {
 
    #ifdef USE_THRUST
    auto & device_dprop = device_dprops.at(getkey(pvarnames, ivar));
    auto const & device_gvar = device_grid_vars[getkey(gvarnames, ivar)];
    thrust::counting_iterator<idx_t> first_p(0), last_p(this -> num_particles);
    g2p_helper_t helper(thrust::raw_pointer_cast(device_x.data()), thrust::raw_pointer_cast(device_y.data()), device_grid_M.cbegin(), device_gvar.cbegin(),
    device_ptcl_to_grd.cbegin(), grid.num_rows (), grid.hx (), grid.hy (), thrust::raw_pointer_cast(device_dprop.data()), apply_mass);
    #else
    auto & dprop = dprops.at (getkey (pvarnames, ivar));
    auto const & gvar = vars.at (getkey (gvarnames, ivar));
    range<idx_t> rng (0, this->num_particles);
    range<idx_t>::iterator first_p = rng.begin(), last_p = rng.end();
    g2p_helper_t helper (x.begin (), y.begin (), M.cbegin(),
                 gvar.cbegin (), ptcl_to_grd.cbegin (),
                 grid.num_rows (), grid.hx (), grid.hy (),
                 dprop.begin (), apply_mass);
    #endif
    
    algorithm_namespace::for_each(device_exec_policy, first_p, last_p, helper);
    
  }
}

◆ g2p() [3/4]

template<typename str>

void particles_t::g2p	(	const std::map< std::string, device_vector_t< real_t > > &	vars,
		std::initializer_list< str > const &	gvarnames,
		std::initializer_list< str > const &	pvarnames,
		bool	apply_mass = false )

Definition at line 266 of file particles_imp.h.

                  {
  using strlist = std::initializer_list<str> const &;
  g2p<strlist, strlist> (vars, gvarnames,
                         pvarnames, apply_mass);
}

◆ g2p() [4/4]

template<typename UnaryFunction>

void particles_t::g2p	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		UnaryFunction	helper )

Definition at line 361 of file particles_imp.h.

                      {
 
  #ifdef USE_THRUST
  thrust::counting_iterator<idx_t> first_p(0), last_p(this -> num_particles);
  #else
  range<idx_t> rng (0, this->num_particles);
  range<idx_t>::iterator first_p = rng.begin(), last_p = rng.end();
  #endif
 
  algorithm_namespace::for_each(device_exec_policy, first_p, last_p, helper);
 
};

◆ g2pd() [1/3]

template<typename GT, typename PT>

void particles_t::g2pd	(	const std::map< std::string, device_vector_t< real_t > > &	vars,
		GT const &	gvarnames,
		PT const &	pxvarnames,
		PT const &	pyvarnames,
		bool	apply_mass = false )

Definition at line 446 of file particles_imp.h.

                  {
 
  using idx_t = quadgrid_t<vector_t<real_t>>::idx_t;
  //real_t Nx = 0.0, Ny = 0.0, xx = 0.0, yy = 0.0;
 
  for (std::size_t ivar = 0; ivar < std::size (gvarnames); ++ivar) {
 
 
    // for (idx_t ip = 0; ip <= this->num_particles; ++ip) {
    //   xx = x[ip];
    //   yy = y[ip];
    //   auto icell = grid[ptcl_to_grd[ip]];
    //   for (idx_t inode = 0; inode < 4; ++inode) {
    //     Nx = apply_mass ?
    //       icell.shg(xx, yy, 0, inode) * M[icell.gt(inode)] :
    //       icell.shg(xx, yy, 0, inode);
    //     Ny = apply_mass ?
    //       icell.shg(xx, yy, 1, inode) * M[icell.gt(inode)] :
    //       icell.shg(xx, yy, 1, inode);
    //     dpropx[ip] += Nx * gvar[icell.gt(inode)];
    //     dpropy[ip] += Ny * gvar[icell.gt(inode)];
    //   }
    // }
 
 
     
    #ifdef USE_THRUST
    auto const & device_gvar = device_grid_vars.at (getkey (gvarnames, ivar));
    auto & device_dpropx = device_dprops.at (getkey (pxvarnames, ivar));
    auto & device_dpropy = device_dprops.at (getkey (pyvarnames, ivar));
    thrust::counting_iterator<idx_t> first_p(0), last_p(this -> num_particles);
    g2pd_helper_t helper(thrust::raw_pointer_cast(device_x.data()), thrust::raw_pointer_cast(device_y.data()), device_grid_M.cbegin(), device_gvar.cbegin(),
    device_ptcl_to_grd.cbegin(), grid.num_rows (), grid.hx (), grid.hy (), thrust::raw_pointer_cast(device_dpropx.data()), 
    thrust::raw_pointer_cast(device_dpropy.data()), apply_mass);
 
    #else
    auto const & gvar = vars.at (getkey (gvarnames, ivar));
    auto & dpropx = dprops.at (getkey (pxvarnames, ivar));
    auto & dpropy = dprops.at (getkey (pyvarnames, ivar));
 
    range<idx_t> rng (0, this->num_particles);
    range<idx_t>::iterator first_p = rng.begin(), last_p = rng.end();
    g2pd_helper_t helper (x.begin (), y.begin (), M.cbegin (),
                 gvar.cbegin (), ptcl_to_grd.cbegin (),
                 grid.num_rows (), grid.hx (), grid.hy (),
                 dpropx.begin (), dpropy.begin (), apply_mass);
    #endif
    
    algorithm_namespace::for_each(first_p, last_p, helper);
 
  }
}

◆ g2pd() [2/3]

template<typename str>

void particles_t::g2pd	(	const std::map< std::string, device_vector_t< real_t > > &	vars,
		std::initializer_list< str > const &	gvarnames,
		std::initializer_list< str > const &	pxvarnames,
		std::initializer_list< str > const &	pyvarnames,
		bool	apply_mass = false )

Definition at line 380 of file particles_imp.h.

                  {
  using strlist = std::initializer_list<str> const &;
  g2pd<strlist, strlist> (vars, gvarnames, pxvarnames,
                          pyvarnames, apply_mass);
}

◆ g2pd() [3/3]

template<typename UnaryFunction>

void particles_t::g2pd	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		UnaryFunction	helper )

Definition at line 508 of file particles_imp.h.

                      {
 
 #ifdef USE_THRUST
 thrust::counting_iterator<idx_t> first_p(0), last_p(this -> num_particles);
 #else
 range<idx_t> rng (0, this->num_particles);
 range<idx_t>::iterator first_p = rng.begin(), last_p = rng.end();
 #endif
 
 algorithm_namespace::for_each(device_exec_policy, first_p, last_p, helper);
 };

◆ getkey() [1/3]

const char * particles_t::getkey	(	std::initializer_list< const char * > const &	varnames,
		std::size_t	ivar )

inlinestatic

Definition at line 320 of file particles.h.

                          {
    return *(std::next (varnames.begin (), ivar));
  };

◆ getkey() [2/3]

const std::string & particles_t::getkey	(	std::map< std::string, device_vector_t< real_t > > const &	varnames,
		std::size_t	ivar )

inlinestatic

Definition at line 306 of file particles.h.

                          {
    return std::next (varnames.begin (), ivar)->first;
  };

◆ getkey() [3/3]

const std::string & particles_t::getkey	(	vector_t< std::string > const &	varnames,
		std::size_t	ivar )

inlinestatic

Definition at line 313 of file particles.h.

                          {
    return varnames[ivar];
  };

◆ init_particle_mesh()

void particles_t::init_particle_mesh ( )

Build grid/particles connectivity.

Builds/updates the grd_to_ptcl and ptcl_to_grd maps. Must be used whenever particles cross cell boundaries.

Definition at line 131 of file particles.cpp.

                                 {
  static idx_t loop = 0;
  ++loop;
 
  for (auto & igrid : grd_to_ptcl)
    igrid.second.clear ();
 
  ptcl_to_grd.assign (this->num_particles, 0);
 
  for (auto ii = 0; ii < this->num_particles; ++ii) {
    idx_t c = static_cast<idx_t> (std::floor (x[ii] / grid.hx ()));
    idx_t r = static_cast<idx_t> (std::floor (y[ii] / grid.hy ()));
 
    grd_to_ptcl[grid.sub2gind (r, c)].push_back (ii);
 
  }
 
  update_ptcl_to_grd<update_ptcl_to_grd_host> ();
  
  /*
    std::cout << "grd_to_ptcl" << "\n";
 
    for (auto const & ii : grd_to_ptcl) {
    for (auto const & jj : ii.second) {
    std::cout << ii.first << " " << jj << "\n";
    }
    }
 
    std::cout << "ptcl_to_grd" << "\n";
    for (idx_t ii = 0; ii < this->num_particles; ++ii) {
    std::cout << ptcl_to_grd[ii] << " " << ii << "\n";
    }
 
    assert (false);
  */
}

◆ init_particle_positions()

void particles_t::init_particle_positions	(	std::function< real_t()>	xgentr,
		std::function< real_t()>	ygentr )

Initialize particle positions with generator functions.

Invoked automatically if the generators are passed to the CTOR, must be invoked manually otherwise.

Definition at line 194 of file particles.cpp.

   {
  x.resize (num_particles);
  y.resize (num_particles);
 
  std::generate (x.begin (), x.end (), xgentr);
  std::generate (y.begin (), y.end (), ygentr);
}

◆ init_props()

void particles_t::init_props	(	const vector_t< std::string > &	ipropnames,
		const vector_t< std::string > &	dpropnames )

Initialize particle properties.

Allocates vectors to store particle properties, this is invoked automatically if the CTOR is invoked specifying property names, must be invoked manually otherwise.

Parameters

ipropnames	keys for entries in the particles_t::iprops map.
dpropnames	keys for entries in the particles_t::dprops map.

Definition at line 81 of file particles.cpp.

   {
 
  for (idx_t ii = 0; ii < ipropnames.size (); ++ii) {
    iprops[ipropnames[ii]].assign (num_particles, 0);
  }
 
  for (idx_t ii = 0; ii < dpropnames.size (); ++ii) {
    dprops[dpropnames[ii]].assign (num_particles, 0.0);
  }
}

◆ ip() [1/2]

idx_t & particles_t::ip	(	const std::string &	name,
		idx_t	ii )

inline

shortcut for iprops.at (name) [ii]

Definition at line 294 of file particles.h.

                                        {
    return iprops.at (name) [ii];
  }

◆ ip() [2/2]

const idx_t & particles_t::ip	(	const std::string &	name,
		idx_t	ii ) const

inline

shortcut for iprops.at (name) [ii]

Definition at line 300 of file particles.h.

                                              {
    return iprops.at (name) [ii];
  }

◆ mark_by_cell_color()

void particles_t::mark_by_cell_color ( )

Mark particles by cell color.

◆ memcpy_device_to_host()

void particles_t::memcpy_device_to_host ( )

Copy Device To Host.

◆ memcpy_host_to_device()

void particles_t::memcpy_host_to_device ( )

Copy Host To Device.

◆ p2g() [1/4]

void particles_t::p2g	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		bool	apply_mass = false )

inline

Map particle variables to the grid.

Assume all fields of vars are to be mapped, and use the same field names for particle and grid variables.

Definition at line 331 of file particles.h.

                               {
    p2g (vars, vars, vars, apply_mass);
  }

◆ p2g() [2/4]

template<typename GT, typename PT>

void particles_t::p2g	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		PT const &	pvarnames,
		GT const &	gvarnames,
		bool	apply_mass = false )

Map particle variables to the grid.

Choose which quantities need to be mapped according to the strings in gvarnames, and use the same field names for particle and grid variables.

Definition at line 65 of file particles_imp.h.

                   {
 
  using idx_t = quadgrid_t<device_vector_t<real_t>>::idx_t;
  //real_t N = 0.0, xx = 0.0, yy = 0.0;
  //idx_t idx = 0;
 
 
  for (std::size_t ivar = 0; ivar < std::size(gvarnames); ++ivar) {
 
    #ifdef USE_THRUST
    auto & device_gvar = device_grid_vars[getkey(gvarnames, ivar)];
    auto const & device_dprop = device_dprops.at(getkey(pvarnames, ivar));
    thrust::counting_iterator<idx_t> first_p(0), last_p(this -> num_particles);
    p2g_helper_t helper(device_x.cbegin(), device_y.cbegin(), thrust::raw_pointer_cast(device_grid_M.data()), 
    thrust::raw_pointer_cast(device_gvar.data()), device_ptcl_to_grd.cbegin(), grid.num_rows(), grid.hx(),
    grid.hy(), device_dprop.cbegin(), apply_mass);
    #else
    auto & gvar = vars[getkey(gvarnames, ivar)];
    auto const & dprop = dprops.at (getkey(pvarnames, ivar));
    range<idx_t> rng (0, this->num_particles);
    range<idx_t>::iterator first_p = rng.begin(), last_p = rng.end();
    p2g_helper_t helper(x.cbegin(), y.cbegin(), M.begin(), gvar.begin(),  ptcl_to_grd.cbegin(), grid.num_rows(), grid.hx(), grid.hy(), dprop.cbegin(), apply_mass);
    #endif
 
    algorithm_namespace::for_each(device_exec_policy, first_p, last_p, helper);
 
  }
 
}

◆ p2g() [3/4]

template<typename str>

void particles_t::p2g	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		std::initializer_list< str > const &	pvarnames,
		std::initializer_list< str > const &	gvarnames,
		bool	apply_mass = false )

Definition at line 7 of file particles_imp.h.

                   {
  using strlist = std::initializer_list<str> const &;
  p2g<strlist, strlist>
    (vars, pvarnames, gvarnames, apply_mass);
}

◆ p2g() [4/4]

template<typename UnaryFunction>

void particles_t::p2g	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		UnaryFunction	helper )

Definition at line 102 of file particles_imp.h.

                      {
 
 #ifdef USE_THRUST
 thrust::counting_iterator<idx_t> first_p(0), last_p(this -> num_particles);
 #else
 range<idx_t> rng (0, this->num_particles);
 range<idx_t>::iterator first_p = rng.begin(), last_p = rng.end();
 #endif
 
 algorithm_namespace::for_each(device_exec_policy, first_p, last_p, helper); 
 
};

◆ p2g_print() [1/2]

template<typename GT, typename PT>

void particles_t::p2g_print	(	std::map< std::string, vector_t< real_t > > &	vars,
		PT const &	pvarnames,
		GT const &	gvarnames,
		bool	apply_mass = false ) const

Definition at line 580 of file particles_imp.h.

                        {
 
  using idx_t = quadgrid_t<std::vector<double>>::idx_t;
  double N = 0.0, xx = 0.0, yy = 0.0;
 
 
  for (std::size_t ivar = 0; ivar < std::size(gvarnames); ++ivar) {
    auto & gvar = vars[getkey(gvarnames, ivar)];
    auto const & dprop = dprops.at (getkey(pvarnames, ivar));
 
    for (idx_t ip = 0; ip <= this->num_particles; ++ip) {
      xx = x[ip];
      yy = y[ip];
      auto icell = grid[ptcl_to_grd[ip]];
      for (idx_t inode = 0; inode < 4; ++inode) {
        N = icell.shp(xx, yy, inode) * dprop[ip];
    gvar[icell.gt(inode)] += N;
      }
    }
  }
 
  if (apply_mass)
    for (std::size_t ivar = 0; ivar < std::size (gvarnames); ++ivar)
      for (idx_t ii = 0; ii < M.size (); ++ii) {
        vars[getkey(gvarnames, ivar)][ii]  /= M[ii];
      }
}

◆ p2g_print() [2/2]

template<typename str>

void particles_t::p2g_print	(	std::map< std::string, vector_t< real_t > > &	vars,
		std::initializer_list< str > const &	pvarnames,
		std::initializer_list< str > const &	gvarnames,
		bool	apply_mass = false ) const

Definition at line 568 of file particles_imp.h.

                        {
  using strlist = std::initializer_list<str> const &;
  p2g_print<strlist, strlist>
    (vars, pvarnames, gvarnames, apply_mass);
}

◆ p2gd() [1/3]

template<typename GT, typename PT>

void particles_t::p2gd	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		PT const &	pxvarnames,
		PT const &	pyvarnames,
		std::string const &	area,
		GT const &	gvarnames,
		bool	apply_mass = false )

Definition at line 185 of file particles_imp.h.

                   {
 
  using idx_t = quadgrid_t<device_vector_t<real_t>>::idx_t;
  //real_t xx = 0.0, yy = 0.0, Nx = 0.0, Ny = 0.0;
 
  for (std::size_t ivar = 0; ivar < std::size (gvarnames); ++ivar) {
 
    #ifdef USE_THRUST
    auto & device_gvar = device_grid_vars[getkey(gvarnames, ivar)];
    auto const & device_dpropx = device_dprops.at (getkey(pxvarnames, ivar));
    auto const & device_dpropy = device_dprops.at (getkey(pyvarnames, ivar));
    auto const & device_dproparea = device_dprops.at (area);
 
    thrust::counting_iterator<idx_t> first_p(0), last_p(this -> num_particles);
    
    p2gd_helper_t helper(device_x.cbegin(), device_y.cbegin(), thrust::raw_pointer_cast(device_grid_M.data()), 
    thrust::raw_pointer_cast(device_gvar.data()), device_ptcl_to_grd.cbegin(), grid.num_rows(), grid.hx(),
    grid.hy(), device_dpropx.cbegin(), device_dpropy.cbegin(), device_dproparea.cbegin(), apply_mass);
 
    #else
    auto & gvar = vars[getkey(gvarnames, ivar)];
    auto const & dpropx = dprops.at (getkey(pxvarnames, ivar));
    auto const & dpropy = dprops.at (getkey(pyvarnames, ivar));
    auto const & dproparea = dprops.at (area);
 
    range<idx_t> rng (0, this->num_particles);
    range<idx_t>::iterator first_p = rng.begin(), last_p = rng.end();
    p2gd_helper_t helper(x.cbegin(), y.cbegin(), M.cbegin(), gvar.begin(), ptcl_to_grd.cbegin(), grid.num_rows(), grid.hx(), grid.hy(), 
    dpropx.begin(), dpropy.begin(), dproparea.begin(), apply_mass);
    #endif
 
    algorithm_namespace::for_each(first_p, last_p, helper);
 
    /*for (idx_t ip = 0; ip <= this->num_particles; ++ip) {
      xx = x[ip];
      yy = y[ip];
      auto icell = grid[ptcl_to_grd[ip]];
      for (idx_t inode = 0; inode < 4; ++inode) {
        Nx = icell.shg (xx, yy, 0, inode);
        Ny = icell.shg (xx, yy, 1, inode);
        gvar[icell.gt(inode)] += (Nx * dpropx[ip] + Ny * dpropy[ip]) * dproparea[ip];
      }
    }*/
 
  }
 
  /*if (apply_mass)
    for (std::size_t ivar = 0; ivar < std::size (gvarnames); ++ivar)
      for (idx_t ii = 0; ii < M.size (); ++ii) {
        vars[getkey(gvarnames, ivar)][ii]  /= M[ii];
      }*/
 
}

◆ p2gd() [2/3]

template<typename str>

void particles_t::p2gd	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		std::initializer_list< str > const &	pxvarnames,
		std::initializer_list< str > const &	pyvarnames,
		std::string const &	area,
		std::initializer_list< str > const &	gvarnames,
		bool	apply_mass = false )

Definition at line 120 of file particles_imp.h.

                   {
  using strlist = std::initializer_list<str> const &;
  p2gd<strlist, strlist>
    (vars, pxvarnames, pyvarnames, area, gvarnames, apply_mass);
}

◆ p2gd() [3/3]

template<typename UnaryFunction>

void particles_t::p2gd	(	std::map< std::string, device_vector_t< real_t > > &	vars,
		UnaryFunction	helper )

Definition at line 248 of file particles_imp.h.

                      {
 
 #ifdef USE_THRUST
 thrust::counting_iterator<idx_t> first_p(0), last_p(this -> num_particles);
 #else
 range<idx_t> rng (0, this->num_particles);
 range<idx_t>::iterator first_p = rng.begin(), last_p = rng.end();
 #endif
 
 algorithm_namespace::for_each(device_exec_policy, first_p, last_p, helper);
 
 };

◆ print()

template<output_format fmt>

void particles_t::print ( std::ostream & os ) const

inline

Template for export function.

If a format is not specified, just outputs an error message.

Definition at line 109 of file particles.h.

                                {
    os << "output format not implementd" << std::endl;
  }

◆ remove_in_region()

void particles_t::remove_in_region ( std::function< bool(real_t, real_t)> fun )

inline

Erase particcles based on coordinates.

Given a function to decide whether a particle lies inside a region or not, remove all particles for which the function returns true, and also erase corresponding entries in dprops and iprops.

Definition at line 200 of file particles.h.

                                                            {
    vector_t<idx_t> vin{};
    for (idx_t i = 0; i < num_particles; ++i) {
      if (fun (x[i], y[i])) {
        vin.push_back (i);
      }
    }
 
    for (auto &dprop : dprops) {
      for (auto id = vin.rbegin (); id != vin.rend (); ++id) {
        dprop.second.erase (dprop.second.begin () + (*id));
      }
    }
 
    for (auto &iprop : iprops) {
      for (auto id = vin.rbegin (); id != vin.rend (); ++id) {
        iprop.second.erase (iprop.second.begin () + (*id));
      }
    }
 
    for (auto id = vin.rbegin (); id != vin.rend (); ++id) {
      x.erase (x.begin () + (*id));
      y.erase (y.begin () + (*id));
      --num_particles;
    }
  };

◆ reorder()

void particles_t::reorder ( vector_t< idx_t > & ordering )

Reorder coordinates an properties according to the ordering vvector.

Definition at line 335 of file particles.cpp.

                                               {
 
  for (idx_t ii = 0; ii < num_particles - 1; ++ii) {
    if (ii != ordering[ii]) {
 
      for (auto &dprop : dprops) {
    auto &col = dprop.second;
    std::swap (col[ii], col[ordering[ii]]);
      }
 
      for (auto &iprop : iprops) {
    auto &col = iprop.second;
    std::swap (col[ii], col[ordering[ii]]);
      }
 
      std::swap (x[ii], x[ordering[ii]]);
      std::swap (y[ii], y[ordering[ii]]);
 
      for (int jj = ii; jj < ordering.size (); ++jj) {
    if (ordering[jj] == ii) {
      ordering[jj] = ordering[ii];
      ordering[ii] = ii;
      break;
    }
      }
 
    }
  }
 
}

◆ update_ptcl_to_grd()

template<class backend>

void particles_t::update_ptcl_to_grd ( )

Updates theptcl_to_grd map only, without changing.

Definition at line 561 of file particles_imp.h.

                                 {
  backend::update(*this);
};

Member Data Documentation

◆ dprops

std::map<std::string, vector_t<real_t> > particles_t::dprops

double type quantities associated with the particles.

Definition at line 42 of file particles.h.

◆ grd_to_ptcl

std::map<idx_t, vector_t<idx_t> > particles_t::grd_to_ptcl

grid->particles connectivity.

Definition at line 45 of file particles.h.

◆ grid

const quadgrid_t<vector_t<real_t> >& particles_t::grid

refernce to a grid object.

Definition at line 48 of file particles.h.

◆ iprops

std::map<std::string, vector_t<idx_t> > particles_t::iprops

integer type quantities associated with the particles.

Definition at line 39 of file particles.h.

◆ M

vector_t<real_t> particles_t::M

Mass matrix to be used for transfers if required.

Definition at line 44 of file particles.h.

◆ num_particles

idx_t particles_t::num_particles

number of particles.

Definition at line 34 of file particles.h.

◆ ptcl_grd_color

vector_t<idx_t> particles_t::ptcl_grd_color

color of particle's cell.

Definition at line 47 of file particles.h.

◆ ptcl_to_grd

vector_t<idx_t> particles_t::ptcl_to_grd

particles->grid connectivity.

Definition at line 46 of file particles.h.

◆ x

vector_t<real_t> particles_t::x

x coordinate of particle positions.

Definition at line 35 of file particles.h.

◆ y

vector_t<real_t> particles_t::y

y coordinate of particle positions.

Definition at line 36 of file particles.h.

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ idx_t

Member Enumeration Documentation

◆ cell_color

◆ output_format

Constructor & Destructor Documentation

◆ particles_t() [1/5]

◆ particles_t() [2/5]

◆ particles_t() [3/5]

◆ particles_t() [4/5]

◆ particles_t() [5/5]

Member Function Documentation

◆ build_mass()

◆ default_x_generator()

◆ default_y_generator()

◆ dp() [1/2]

◆ dp() [2/2]

◆ g2p() [1/4]

◆ g2p() [2/4]

◆ g2p() [3/4]

◆ g2p() [4/4]

◆ g2pd() [1/3]

◆ g2pd() [2/3]

◆ g2pd() [3/3]

◆ getkey() [1/3]

◆ getkey() [2/3]

◆ getkey() [3/3]

◆ init_particle_mesh()

◆ init_particle_positions()

◆ init_props()

◆ ip() [1/2]

◆ ip() [2/2]

◆ mark_by_cell_color()

◆ memcpy_device_to_host()

◆ memcpy_host_to_device()

◆ p2g() [1/4]

◆ p2g() [2/4]

◆ p2g() [3/4]

◆ p2g() [4/4]

◆ p2g_print() [1/2]

◆ p2g_print() [2/2]

◆ p2gd() [1/3]

◆ p2gd() [2/3]

◆ p2gd() [3/3]

◆ print()

◆ remove_in_region()

◆ reorder()

◆ update_ptcl_to_grd()

Member Data Documentation

◆ dprops

◆ grd_to_ptcl

◆ grid

◆ iprops

◆ M

◆ num_particles

◆ ptcl_grd_color

◆ ptcl_to_grd

◆ x

◆ y