processbranch.h

Go to the documentation of this file.

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

#include <iostream>
#include <memory>
#include <utility>
#include <vector>

#include "decaytype.h"
#include "forwarddeclarations.h"
#include "particletype.h"

namespace smash {

enum class ProcessType {
  None = 0,
  Elastic = 1,
  TwoToOne = 2,
  TwoToTwo = 3,
  Decay = 5,
  Wall = 6,
  Thermalization = 7,
  StringSoftSingleDiffractiveAX = 41,
  StringSoftSingleDiffractiveXB = 42,
  StringSoftDoubleDiffractive = 43,
  StringSoftAnnihilation = 44,
  StringSoftNonDiffractive = 45,
  StringHard = 46
};

bool is_string_soft_process(ProcessType p);

std::ostream &operator<<(std::ostream &os, ProcessType process_type);

class ProcessBranch {
 public:
  ProcessBranch() : branch_weight_(0.) {}

  explicit ProcessBranch(double w) : branch_weight_(w) {}

  ProcessBranch(const ProcessBranch &) = delete;

  virtual ~ProcessBranch() = default;

  inline void set_weight(double process_weight);

  virtual ProcessType get_type() const = 0;

  virtual const ParticleTypePtrList &particle_types() const = 0;

  ParticleList particle_list() const;

  inline double weight() const;

  double threshold() const;

  virtual unsigned int particle_number() const = 0;

 protected:
  double branch_weight_;
  mutable double threshold_ = -1.;
};

inline void ProcessBranch::set_weight(double process_weight) {
  branch_weight_ = process_weight;
}

inline double ProcessBranch::weight() const { return branch_weight_; }

template <typename Branch>
inline double total_weight(const ProcessBranchList<Branch> &l) {
  double sum = 0.;
  for (const auto &p : l) {
    sum += p->weight();
  }
  return sum;
}

class CollisionBranch : public ProcessBranch {
 public:
  CollisionBranch(double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {}
  CollisionBranch(const ParticleType &type, double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {
    particle_types_.reserve(1);
    particle_types_.push_back(&type);
  }
  CollisionBranch(const ParticleType &type_a, const ParticleType &type_b,
                  double w, ProcessType p_type)
      : ProcessBranch(w), process_type_(p_type) {
    particle_types_.reserve(2);
    particle_types_.push_back(&type_a);
    particle_types_.push_back(&type_b);
  }
  CollisionBranch(ParticleTypePtrList new_types, double w, ProcessType p_type)
      : ProcessBranch(w),
        particle_types_(std::move(new_types)),
        process_type_(p_type) {}
  CollisionBranch(CollisionBranch &&rhs)
      : ProcessBranch(rhs.branch_weight_),
        particle_types_(std::move(rhs.particle_types_)),
        process_type_(rhs.process_type_) {}
  const ParticleTypePtrList &particle_types() const override {
    return particle_types_;
  }
  inline void set_type(ProcessType p_type) { process_type_ = p_type; }
  inline ProcessType get_type() const override { return process_type_; }
  unsigned int particle_number() const override {
    return particle_types_.size();
  }

 private:
  ParticleTypePtrList particle_types_;
  ProcessType process_type_;
};

std::ostream &operator<<(std::ostream &os, const CollisionBranch &cbranch);

class DecayBranch : public ProcessBranch {
 public:
  DecayBranch(const DecayType &t, double w) : ProcessBranch(w), type_(t) {}
  DecayBranch(DecayBranch &&rhs)
      : ProcessBranch(rhs.branch_weight_), type_(rhs.type_) {}
  inline int angular_momentum() const { return type_.angular_momentum(); }
  const ParticleTypePtrList &particle_types() const override {
    return type_.particle_types();
  }
  unsigned int particle_number() const override {
    return type_.particle_number();
  }
  inline const DecayType &type() const { return type_; }
  inline ProcessType get_type() const override { return ProcessType::Decay; }

 private:
  const DecayType &type_;
};

}  // namespace smash

#endif  // SRC_INCLUDE_PROCESSBRANCH_H_