particles.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2012-2020
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_SMASH_PARTICLES_H_
#define SRC_INCLUDE_SMASH_PARTICLES_H_
 
#include <memory>
#include <type_traits>
#include <vector>
 
#include "macros.h"
#include "particledata.h"
#include "particletype.h"
#include "pdgcode.h"
 
namespace smash {
 
class Particles {
 public:
  Particles();
 
  Particles(const Particles &) = delete;
  Particles &operator=(const Particles &) = delete;
 
  ParticleList copy_to_vector() const {
    if (dirty_.empty()) {
      return {&data_[0], &data_[data_size_]};
    }
    return {begin(), end()};
  }
 
  const ParticleData &insert(const ParticleData &p);
 
  void create(size_t n, PdgCode pdg);
 
  ParticleData &create(const PdgCode pdg);
 
  size_t size() const { return data_size_ - dirty_.size(); }
 
  bool is_empty() const { return data_size_ == 0; }
 
  double time() const {
    assert(!is_empty());
    return front().position().x0();
  }
 
  void reset();
 
  bool is_valid(const ParticleData &copy) const {
    if (data_size_ <= copy.index_) {
      return false;
    }
    /* Check if the particles still exists. If it decayed
     * or scattered inelastically it is gone. */
    return data_[copy.index_].id() == copy.id()
           /* If the particle has scattered
            * elastically, its id_process has
            * changed and we consider it invalid. */
           && data_[copy.index_].id_process() == copy.id_process();
  }
 
  void remove(const ParticleData &p);
 
  void replace(const ParticleList &to_remove, ParticleList &to_add);
 
  const ParticleData &update_particle(const ParticleData &p,
                                      const ParticleData &new_state) {
    assert(is_valid(p));
    assert(p.type() == new_state.type());
    ParticleData &original = data_[p.index_];
    new_state.copy_to(original);
    return original;
  }
 
  void update(const ParticleList &old_state, ParticleList &new_state,
              bool do_replace) {
    if (do_replace) {
      replace(old_state, new_state);
    } else {
      for (std::size_t i = 0; i < old_state.size(); ++i) {
        new_state[i] = update_particle(old_state[i], new_state[i]);
      }
    }
  }
 
  const ParticleData &lookup(const ParticleData &old_state) const {
    assert(is_valid(old_state));
    return data_[old_state.index_];
  }
 
  template <typename T>
  class GenericIterator
      : public std::iterator<std::bidirectional_iterator_tag, T> {
    friend class Particles;
 
   public:
    using value_type = typename std::remove_const<T>::type;
    using pointer = typename std::add_pointer<T>::type;
    using reference = typename std::add_lvalue_reference<T>::type;
    using const_pointer = typename std::add_const<pointer>::type;
    using const_reference = typename std::add_const<reference>::type;
 
   private:
    GenericIterator(pointer p) : ptr_(p) {}  // NOLINT(runtime/explicit)
 
    pointer ptr_;
 
   public:
    GenericIterator &operator++() {
      do {
        ++ptr_;
      } while (ptr_->hole_);
      return *this;
    }
    GenericIterator operator++(int) {
      GenericIterator old = *this;
      operator++();
      return old;
    }
 
    GenericIterator &operator--() {
      do {
        --ptr_;
      } while (ptr_->hole_);
      return *this;
    }
    GenericIterator operator--(int) {
      GenericIterator old = *this;
      operator--();
      return old;
    }
 
    reference operator*() { return *ptr_; }
    const_reference operator*() const { return *ptr_; }
 
    pointer operator->() { return ptr_; }
    const_pointer operator->() const { return ptr_; }
 
    bool operator==(const GenericIterator &rhs) const {
      return ptr_ == rhs.ptr_;
    }
    bool operator!=(const GenericIterator &rhs) const {
      return ptr_ != rhs.ptr_;
    }
    bool operator<(const GenericIterator &rhs) const { return ptr_ < rhs.ptr_; }
    bool operator>(const GenericIterator &rhs) const { return ptr_ > rhs.ptr_; }
    bool operator<=(const GenericIterator &rhs) const {
      return ptr_ <= rhs.ptr_;
    }
    bool operator>=(const GenericIterator &rhs) const {
      return ptr_ >= rhs.ptr_;
    }
  };
  using iterator = GenericIterator<ParticleData>;
  using const_iterator = GenericIterator<const ParticleData>;
 
  ParticleData &front() { return *begin(); }
  const ParticleData &front() const { return *begin(); }
 
  ParticleData &back() { return *(--end()); }
  const ParticleData &back() const { return *(--end()); }
 
  iterator begin() {
    ParticleData *first = &data_[0];
    while (first->hole_) {
      ++first;
    }
    return first;
  }
  const_iterator begin() const {
    ParticleData *first = &data_[0];
    while (first->hole_) {
      ++first;
    }
    return first;
  }
 
  iterator end() { return &data_[data_size_]; }
  const_iterator end() const { return &data_[data_size_]; }
 
  const_iterator cbegin() const { return begin(); }
  const_iterator cend() const { return end(); }
 
  friend std::ostream &operator<<(std::ostream &out,
                                  const Particles &particles);
 
 private:
  int id_max_ = -1;
 
  void increase_capacity(unsigned new_capacity);
  inline void ensure_capacity(unsigned to_add);
  inline void copy_in(ParticleData &to, const ParticleData &from);
 
  unsigned data_size_ = 0u;
  unsigned data_capacity_ = 100u;
  std::unique_ptr<ParticleData[]> data_;
 
  std::vector<unsigned> dirty_;
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_PARTICLES_H_