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>
 
using assignment_t = std::function <double& (double&, const double&)>;
 
namespace ASSIGNMENT_OPS {
  extern assignment_t EQ; // = [] (double& TO, const double& FROM) -> double& { return TO = FROM; };
  extern assignment_t PLUS_EQ; // = [] (double& TO, const double& FROM) -> double& { return TO += FROM; };
  extern assignment_t TIMES_EQ; // = [] (double& TO, const double& FROM) -> double& { return TO *= FROM; };
}
 
 
 
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;   
  const quadgrid_t<std::vector<double>>& grid;       
 
  enum class
  output_format : idx_t {
    csv = 0,           
      
    octave_ascii = 1,  
 
    json = 2           
  };
 
 
  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 ();
 
  
  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,
       assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ) 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,
       assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ) 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,
    assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ) 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,
    assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ) const;
 
  void
  g2p (const std::map<std::string, std::vector<double>>& vars,
       bool apply_mass = false, assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ) {
    g2p (vars, vars, vars, apply_mass, OP);
  }
 
  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,
       assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ);
 
  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,
       assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ);
 
  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,
    assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ);
 
  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,
    assignment_t OP = ASSIGNMENT_OPS::PLUS_EQ);
 
};
 
void
to_json (nlohmann::json &j, const particles_t &p);
 
 
#include "particles_imp.h"
 
#endif /* PARTICLES_H */