particles.h

Go to the documentation of this file.

#ifndef PARTICLES_H
#define PARTICLES_H
 
#include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <json.hpp>
#include <map>
#include <quadgrid_cpp.h>
#include <string>
 


 
struct
particles_t {

  using idx_t = quadgrid_t<std::vector<double>>::idx_t;
 
  idx_t num_particles;    
  std::vector<double> x;  
  std::vector<double> y;  

  std::map<std::string, std::vector<idx_t>> iprops;

  std::map<std::string, std::vector<double>> dprops;
 
  std::vector<double> M; 
  std::map<idx_t, std::vector<idx_t>> grd_to_ptcl;   
  std::vector<idx_t> ptcl_to_grd;                    
  std::vector<idx_t> ptcl_grd_color;                 
  const quadgrid_t<std::vector<double>>& grid;       

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

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

  double
  default_x_generator ();


  double
  default_y_generator ();


  template<output_format fmt>
  void
  print (std::ostream & os) const {
    os << "output format not implementd" << std::endl;
  }


  particles_t (idx_t n, const quadgrid_t<std::vector<double>>& grid_)
    : num_particles(n), grid(grid_) { }


  particles_t (const nlohmann::json &j,
               const quadgrid_t<std::vector<double>>& grid_)
    :  grid(grid_)
  {
    j["dprops"].get_to<std::map<std::string, std::vector<double>>> (dprops);
    j["iprops"].get_to<std::map<std::string, std::vector<int>>> (iprops);
    j["x"].get_to<std::vector<double>> (x);
    j["y"].get_to<std::vector<double>> (y);
    j["num_particles"].get_to<idx_t> (num_particles);
  }


  particles_t (idx_t n, const std::vector<std::string>& ipropnames,
               const std::vector<std::string>& dpropnames,
               const quadgrid_t<std::vector<double>>& grid_);


  particles_t (idx_t n, const std::vector<std::string>& ipropnames,
               const std::vector<std::string>& dpropnames,
               const quadgrid_t<std::vector<double>>& grid_,
               const std::vector<double> & xv,
               const std::vector<double> & yv);


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


  void
  init_props (const std::vector<std::string>& ipropnames,
              const std::vector<std::string>& dpropnames);


  void
  remove_in_region (std::function<bool (double, double)> fun) {
    std::vector<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;
    }
  };


  void
  init_particle_mesh ();

  //  `grd_to_ptcl`, if not needed.
  void
  update_ptcl_to_grd ();
  
 
  void
  mark_by_cell_color ();

  void
  reorder (std::vector<idx_t> &);


  void
  init_particle_positions (std::function<double ()> xgentr,
                           std::function<double ()> ygentr);


  void
  build_mass ();

  double &
  dp (const std::string & name, idx_t ii) {
    return dprops.at (name) [ii];
  }

  const double &
  dp (const std::string & name, idx_t ii) const {
    return dprops.at (name) [ii];
  }

  idx_t &
  ip (const std::string & name, idx_t ii) {
    return iprops.at (name) [ii];
  }

  const idx_t &
  ip (const std::string & name, idx_t ii) const {
    return iprops.at (name) [ii];
  }
 
  static
  const std::string &
  getkey(std::map<std::string, std::vector<double>> const &varnames,
         std::size_t ivar)  {
    return std::next (varnames.begin (), ivar)->first;
  };
 
  static
  const std::string &
  getkey(std::vector<std::string> const &varnames,
         std::size_t ivar)  {
    return varnames[ivar];
  };
 
  static
  const char*
  getkey(std::initializer_list<const char *> const &varnames,
         std::size_t ivar)  {
    return *(std::next (varnames.begin (), ivar));
  };


  void
  p2g (std::map<std::string, std::vector<double>> & vars,
       bool apply_mass = false) const {
    p2g (vars, vars, vars, apply_mass);
  }


  template<typename GT, typename PT>
  void
  p2g (std::map<std::string, std::vector<double>> & vars,
       PT const & pvarnames,
       GT const & gvarnames,
       bool apply_mass = false) const;
 
  template<typename str>
  void
  p2g (std::map<std::string, std::vector<double>> & 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, std::vector<double>> & vars,
        PT const & pxvarnames,
        PT const & pyvarnames,
        std::string const &area,
        GT const & gvarnames,
        bool apply_mass = false) const;
 
  template<typename str>
  void
  p2gd (std::map<std::string, std::vector<double>> & 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) const;
 
  void
  g2p (const std::map<std::string, std::vector<double>>& vars,
       bool apply_mass = false) {
    g2p (vars, vars, vars, apply_mass);
  }
 
  template<typename str>
  void
  g2p (const std::map<std::string, std::vector<double>>& 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, std::vector<double>>& vars,
       GT const & gvarnames,
       PT const & pvarnames,
       bool apply_mass = false);
 
  template<typename GT, typename PT>
  void
  g2pd (const std::map<std::string, std::vector<double>>& vars,
        GT const & gvarnames,
        PT const & pxvarnames,
        PT const & pyvarnames,
        bool apply_mass = false);
 
  template<typename str>
  void
  g2pd (const std::map<std::string, std::vector<double>>& vars,
        std::initializer_list<str> const & gvarnames,
        std::initializer_list<str> const &pxvarnames,
        std::initializer_list<str> const & pyvarnames,
        bool apply_mass = false);
 
};

void
to_json (nlohmann::json &j, const particles_t &p);

template<typename P2G_t, typename COORD_t>
class
ptcl_to_grd_update_t {
 
  using idx_t=particles_t::idx_t;
  P2G_t ptcl_to_grd;
  const COORD_t x;
  const COORD_t y;
  const double hx;
  const double hy;
  const idx_t nrows;
  
public :
  ptcl_to_grd_update_t (P2G_t ptcl_to_grd_,
            const COORD_t x_, const COORD_t y_,
            double hx_, double hy_, const idx_t nrows_)
    : ptcl_to_grd(ptcl_to_grd_), x(x_), y(y_), hx(hx_), hy(hy_), nrows(nrows_) { }
 
  void operator() (particles_t::idx_t ii) {
    ptcl_to_grd[ii] = quadgrid_t<COORD_t>::sub2gind (static_cast<idx_t> (std::floor (y[ii] / hy)),
                             static_cast<idx_t> (std::floor (x[ii] / hx)),
                             nrows);
  }
};
 
 
#include "particles_imp.h"
 
#endif /* PARTICLES_H */