potentials.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2021
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_POTENTIALS_H_
#define SRC_INCLUDE_SMASH_POTENTIALS_H_
 
#include <tuple>
#include <utility>
#include <vector>
 
#include "configuration.h"
#include "density.h"
#include "forwarddeclarations.h"
#include "particledata.h"
#include "threevector.h"
 
namespace smash {
 
class Potentials {
 public:
  Potentials(Configuration conf, const DensityParameters &parameters);
  virtual ~Potentials();
 
  double skyrme_pot(const double baryon_density) const;
 
  double symmetry_pot(const double baryon_isospin_density,
                      const double baryon_density) const;
 
  double symmetry_S(const double baryon_density) const;
 
  FourVector vdf_pot(double rhoB, const FourVector jmuB_net) const;
 
  double potential(const ThreeVector &r, const ParticleList &plist,
                   const ParticleType &acts_on) const;
 
  static std::pair<double, int> force_scale(const ParticleType &data);
 
  std::pair<ThreeVector, ThreeVector> skyrme_force(
      const double rhoB, const ThreeVector grad_j0B,
      const ThreeVector dvecjB_dt, const ThreeVector curl_vecjB) const;
 
  std::pair<ThreeVector, ThreeVector> symmetry_force(
      const double rhoI3, const ThreeVector grad_j0I3,
      const ThreeVector dvecjI3_dt, const ThreeVector curl_vecjI3,
      const double rhoB, const ThreeVector grad_j0B,
      const ThreeVector dvecjB_dt, const ThreeVector curl_vecjB) const;
 
  static ThreeVector E_field_integrand(ThreeVector pos,
                                       DensityOnLattice &charge_density,
                                       ThreeVector point) {
    ThreeVector dr = point - pos;
    if (dr.abs() < really_small) {
      return {0., 0., 0.};
    }
    return elementary_charge * charge_density.rho() * dr /
           std::pow(dr.abs(), 3);
  }
 
  static ThreeVector B_field_integrand(ThreeVector pos,
                                       DensityOnLattice &charge_density,
                                       ThreeVector point) {
    ThreeVector dr = point - pos;
    if (dr.abs() < really_small) {
      return {0., 0., 0.};
    }
    return elementary_charge *
           charge_density.jmu_net().threevec().cross_product(dr) /
           std::pow(dr.abs(), 3);
  }
  std::pair<ThreeVector, ThreeVector> vdf_force(
      double rhoB, const double drhoB_dt, const ThreeVector grad_rhoB,
      const ThreeVector gradrhoB_cross_vecjB, const double j0B,
      const ThreeVector grad_j0B, const ThreeVector vecjB,
      const ThreeVector dvecjB_dt, const ThreeVector curl_vecjB) const;
 
  std::pair<ThreeVector, ThreeVector> vdf_force(
      const ThreeVector grad_A_0, const ThreeVector dA_dt,
      const ThreeVector curl_vecA) const;
 
  virtual std::tuple<ThreeVector, ThreeVector, ThreeVector, ThreeVector>
  all_forces(const ThreeVector &r, const ParticleList &plist) const;
 
  virtual bool use_skyrme() const { return use_skyrme_; }
  virtual bool use_symmetry() const { return use_symmetry_; }
  virtual bool use_coulomb() const { return use_coulomb_; }
 
  double skyrme_a() const { return skyrme_a_; }
  double skyrme_b() const { return skyrme_b_; }
  double skyrme_tau() const { return skyrme_tau_; }
  double symmetry_S_pot() const { return symmetry_S_Pot_; }
 
  virtual bool use_vdf() const { return use_vdf_; }
  double saturation_density() const { return saturation_density_; }
  const std::vector<double> &coeffs() const { return coeffs_; }
  const std::vector<double> &powers() const { return powers_; }
  int number_of_terms() const { return powers_.size(); }
 
  double coulomb_r_cut() const { return coulomb_r_cut_; }
 
 private:
  const DensityParameters param_;
 
  bool use_skyrme_;
 
  bool use_symmetry_;
 
  bool use_coulomb_;
 
  bool use_vdf_;
 
  double skyrme_a_;
 
  double skyrme_b_;
 
  double skyrme_tau_;
 
  double symmetry_S_Pot_;
 
  bool symmetry_is_rhoB_dependent_ = false;
  double symmetry_gamma_;
 
  double coulomb_r_cut_;
 
  double saturation_density_;
  std::vector<double> coeffs_;
  std::vector<double> powers_;
 
  double dVsym_drhoI3(const double rhoB, const double rhoI3) const;
 
  double dVsym_drhoB(const double rhoB, const double rhoI3) const;
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_POTENTIALS_H_