nucleus.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2014-2018
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_NUCLEUS_H_
#define SRC_INCLUDE_NUCLEUS_H_

#include <map>
#include <stdexcept>
#include <vector>

#include "configuration.h"
#include "constants.h"
#include "forwarddeclarations.h"
#include "fourvector.h"
#include "particledata.h"
#include "threevector.h"

namespace smash {

class Nucleus {
 public:
  Nucleus(Configuration &config, int nTest);

  Nucleus(const std::map<PdgCode, int> &particle_list, int nTest);
  virtual ~Nucleus() = default;

  double mass() const;

  virtual ThreeVector distribute_nucleon() const;

  double woods_saxon(double x);

  void arrange_nucleons();

  virtual void set_parameters_automatic();

  virtual void set_parameters_from_config(Configuration &config);

  virtual void generate_fermi_momenta();

  void boost(double beta_scalar);

  void fill_from_list(const std::map<PdgCode, int> &particle_list,
                      int testparticles);

  void shift(double z_offset, double x_offset, double simulation_time);

  virtual void rotate() {}

  void copy_particles(Particles *particles);

  inline size_t size() const { return particles_.size(); }

  inline size_t number_of_particles() const {
    size_t nop = particles_.size() / testparticles_;
    /* if size() is not a multiple of testparticles_, this will throw an
     * error. */
    if (nop * testparticles_ != particles_.size()) {
      throw TestparticleConfusion(
          "Number of test particles and test particles"
          "per particle are incompatible");
    }
    return nop;
  }

  FourVector center() const;

  void align_center() {
    FourVector centerpoint = center();
    for (auto p = particles_.begin(); p != particles_.end(); ++p) {
      p->set_4position(p->position() - centerpoint);
    }
  }

  struct TestparticleConfusion : public std::length_error {
    using std::length_error::length_error;
  };

 private:
  double diffusiveness_;
  double saturation_density_ = nuclear_density;
  double nuclear_radius_;
  double proton_radius_ = 1.2;
  size_t testparticles_ = 1;
  std::vector<ParticleData> particles_;

 public:
  inline std::vector<ParticleData>::iterator begin() {
    return particles_.begin();
  }
  inline std::vector<ParticleData>::iterator end() { return particles_.end(); }
  inline std::vector<ParticleData>::const_iterator cbegin() const {
    return particles_.cbegin();
  }
  inline std::vector<ParticleData>::const_iterator cend() const {
    return particles_.cend();
  }
  inline void set_diffusiveness(double diffuse) { diffusiveness_ = diffuse; }
  inline double get_diffusiveness() const { return diffusiveness_; }
  inline void set_saturation_density(double density) {
    saturation_density_ = density;
  }
  inline double get_saturation_density() const { return saturation_density_; }
  inline double default_nuclear_radius() {
    return proton_radius_ * std::pow(number_of_particles(), 1. / 3.);
  }
  inline void set_nuclear_radius(double rad) { nuclear_radius_ = rad; }
  inline double get_nuclear_radius() const { return nuclear_radius_; }
  friend std::ostream &operator<<(std::ostream &, const Nucleus &);
};

}  // namespace smash

#endif  // SRC_INCLUDE_NUCLEUS_H_