smash::DecayActionsFinderDilepton Class Reference

#include <decayactionsfinderdilepton.h>

A dilepton decay finder: Loops through all particles and if they can decay into dileptons, it treats the decays with the shining method.

This means in every timestep it stores every possible decay in an extra action and later in the write_dilepton_action routine in experiment.cc these decays are written in the DileptonOutput. Because too many dileptons are produced this way, every decay is weighted with the so called "shining_weight". See Schmidt:2008hm, chapter 2D. The finder works with two body dilepton decays as well as with dalitz dilepton decays.

Definition at line 30 of file decayactionsfinderdilepton.h.

Public Member Functions
	DecayActionsFinderDilepton ()
	Initialize the finder. More...
void	shine (const Particles &search_list, OutputInterface *output, double dt) const
	Check the whole particles list and print out possible dilepton decays. More...
void	shine_final (const Particles &search_list, OutputInterface *output, bool only_res=false) const
	Shine dileptons from resonances at the end of the simulation. More...

Constructor & Destructor Documentation

DecayActionsFinderDilepton()

smash::DecayActionsFinderDilepton::DecayActionsFinderDilepton ( )

inline

Initialize the finder.

Definition at line 33 of file decayactionsfinderdilepton.h.

{}

Member Function Documentation

shine()

void smash::DecayActionsFinderDilepton::shine	(	const Particles &	search_list,
		OutputInterface *	output,
		double	dt
	)		const

Check the whole particles list and print out possible dilepton decays.

Parameters

[in]	search_list	List of all particles.
[in]	output	Pointer to the dilepton output.
[in]	dt	Length of timestep [fm]

Definition at line 20 of file decayactionsfinderdilepton.cc.

                                                        {
  if (!output->is_dilepton_output()) {
    return;
  }
  for (const auto &p : search_list) {
    // effective mass of decaying particle
    const double m_eff = p.effective_mass();
    const auto n_all_modes = p.type().get_partial_widths(m_eff).size();
    if (n_all_modes == 0) {
      continue;
    }

    const double inv_gamma = p.inverse_gamma();
    DecayBranchList dil_modes = p.type().get_partial_widths_dilepton(m_eff);

    /* if particle can only decay into dileptons or is stable, use shining only
     * in find_final_actions and ignore them here, also unformed
     * resonances cannot decay */
    if (dil_modes.size() == n_all_modes || p.type().is_stable() ||
        (p.formation_time() > p.position().x0())) {
      continue;
    }

    for (DecayBranchPtr &mode : dil_modes) {
      // SHINING as described in \iref{Schmidt:2008hm}, chapter 2D
      const double shining_weight = dt * inv_gamma * mode->weight() / hbarc;

      if (shining_weight > 0.0) {  // decays that can happen
        DecayActionDilepton act(p, 0., shining_weight);
        act.add_decay(std::move(mode));
        act.generate_final_state();
        output->at_interaction(act, 0.0);
      }
    }
  }
}

Here is the call graph for this function:

shine_final()

void smash::DecayActionsFinderDilepton::shine_final	(	const Particles &	search_list,
		OutputInterface *	output,
		bool	only_res = false
	)		const

Shine dileptons from resonances at the end of the simulation.

This is special, because the shining time is now until the resonance would decay and not for some fixed dt interval.

Parameters

[in]	search_list	List of all particles.
[in]	output	Pointer to the dilepton output.
[in]	only_res	optional parameter that requests that only actions regarding resonances are considered (disregarding stable particles)

Definition at line 59 of file decayactionsfinderdilepton.cc.

                                                                  {
  if (!output->is_dilepton_output()) {
    return;
  }
  for (const auto &p : search_list) {
    const ParticleType &t = p.type();
    if (t.decay_modes().decay_mode_list().empty() ||
        (only_res && t.is_stable())) {
      continue;
    }

    // effective mass of decaying particle
    const double m_eff = p.effective_mass();
    DecayBranchList dil_modes = t.get_partial_widths_dilepton(m_eff);

    // total decay width, also hadronic decays
    const double width_tot =
        total_weight<DecayBranch>(t.get_partial_widths(m_eff));

    for (DecayBranchPtr &mode : dil_modes) {
      const double shining_weight = mode->weight() / width_tot;

      if (shining_weight > 0.0) {  // decays that can happen
        DecayActionDilepton act(p, 0., shining_weight);
        act.add_decay(std::move(mode));
        act.generate_final_state();
        output->at_interaction(act, 0.0);
      }
    }
  }
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• src/include/smash/decayactionsfinderdilepton.h
• src/decayactionsfinderdilepton.cc