smash::decaytree Namespace Reference

Classes
struct	Node
	Node of a decay tree, representing a possible action (2-to-2 or 1-to-2). More...

Functions
static std::string	make_decay_name (const std::string &res_name, const DecayBranchPtr &decay, ParticleTypePtrList &final_state)
	Generate name for decay and update final state. More...
static void	add_decays (Node &node, double sqrts)
	Add nodes for all decays possible from the given node and all of its children. More...

Function Documentation

static std::string smash::decaytree::make_decay_name ( const std::string &  res_name, const DecayBranchPtr &  decay, ParticleTypePtrList &  final_state  )

static

Generate name for decay and update final state.

Parameters

[in]	res_name	Name of resonance.
[in]	decay	Decay branch.
[out]	final_state	Final state of decay.

Returns

Name of decay.

Definition at line 752 of file scatteractionsfinder.cc.

                                                                     {
  std::stringstream name;
  name << "[" << res_name << "->";
  for (const auto& p : decay->particle_types()) {
    name << p->name();
    final_state.push_back(p);
  }
  name << "]";
  return name.str();
}

Here is the caller graph for this function:

static void smash::decaytree::add_decays ( Node &  node, double  sqrts  )

static

Add nodes for all decays possible from the given node and all of its children.

Parameters

node	Starting node.

Definition at line 771 of file scatteractionsfinder.cc.

                                                 {
  // If there is more than one unstable particle in the current state, then
  // there will be redundant paths in the decay tree, corresponding to
  // reorderings of the decays. To avoid double counting, we normalize by the
  // number of possible decay orderings. Normalizing by the number of unstable
  // particles recursively corresponds to normalizing by the factorial that
  // gives the number of reorderings.
  //
  // Ideally, the redundant paths should never be added to the decay tree, but
  // we never have more than two redundant paths, so it probably does not matter
  // much.
  uint32_t n_unstable = 0;
  double sqrts_minus_masses = sqrts;
  for (const ParticleTypePtr ptype : node.state_) {
    if (!ptype->is_stable()) {
      n_unstable += 1;
    }
    sqrts_minus_masses -= ptype->mass();
  }
  const double norm =
      n_unstable != 0 ? 1. / static_cast<double>(n_unstable) : 1.;

  for (const ParticleTypePtr ptype : node.state_) {
    if (!ptype->is_stable()) {
      const double sqrts_decay = sqrts_minus_masses + ptype->mass();
      bool can_decay = false;
      for (const auto& decay : ptype->decay_modes().decay_mode_list()) {
        // Make sure to skip kinematically impossible decays.
        // In principle, we would have to integrate over the mass of the
        // resonance, but as an approximation we just assume it at its pole.
        double final_state_mass = 0.;
        for (const auto& p : decay->particle_types()) {
          final_state_mass += p->mass();
        }
        if (final_state_mass > sqrts_decay) {
          continue;
        }
        can_decay = true;

        ParticleTypePtrList parts;
        const auto name = make_decay_name(ptype->name(), decay, parts);
        auto& new_node = node.add_action(name, norm * decay->weight(), {ptype},
                                         std::move(parts));
        add_decays(new_node, sqrts_decay);
      }
      if (!can_decay) {
        // Remove final-state cross sections with resonances that cannot
        // decay due to our "mass = pole mass" approximation.
        node.weight_ = 0;
        return;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: