smash::DecayActionDilepton Class Reference

#include <decayactiondilepton.h>

DecayActionDilepton is special action created for particles that can decay into dileptons.

Such actions are never actually performed, but only written into the dilepton output according to our perturbative treatment.

Definition at line 24 of file decayactiondilepton.h.

Inheritance diagram for smash::DecayActionDilepton:

Public Member Functions
	DecayActionDilepton (const ParticleData &p, double time_of_execution, double shining_weight)
	Construct a DecayActionDilepton from a particle p. More...
double	get_total_weight () const override
	Return the total width of the decay process. More...
void	sample_manybody_phasespace () override
	Generates momenta of outgoing dileptons (for Dalitz dilepton decays only). More...
Public Member Functions inherited from smash::DecayAction
	DecayAction (const ParticleData &p, double time)
	Construct a DecayAction from a particle p. More...
void	add_decays (DecayBranchList pv)
	Add several new decays at once. More...
void	add_decay (DecayBranchPtr p)
	Add one new decay. More...
void	generate_final_state () override
	Generate the final state of the decay process. More...
std::pair< double, double >	sample_masses (double kinetic_energy_cm) const override
	Sample the masses of the final particles. More...
double	get_partial_weight () const override
	Get partial width of chosen channel. More...
double	total_width () const
	Get total decay width. More...
Public Member Functions inherited from smash::Action
	Action (const ParticleList &in_part, double time)
	Construct an action object with incoming particles and relative time. More...
	Action (const ParticleData &in_part, const ParticleData &out_part, double time, ProcessType type)
	Construct an action object with the incoming particles, relative time, and the already known outgoing particles and type of the process. More...
	Action (const ParticleList &in_part, const ParticleList &out_part, double absolute_execution_time, ProcessType type)
	Construct an action object with the incoming particles, absolute time, and the already known outgoing particles and type of the process. More...
	Action (const Action &)=delete
	Copying is disabled. Use pointers or create a new Action. More...
virtual	~Action ()
	Virtual Destructor. More...
bool	operator< (const Action &rhs) const
	Determine whether one action takes place before another in time. More...
virtual ProcessType	get_type () const
	Get the process type. More...
template<typename Branch >
void	add_process (ProcessBranchPtr< Branch > &p, ProcessBranchList< Branch > &subprocesses, double &total_weight)
	Add a new subprocess. More...
template<typename Branch >
void	add_processes (ProcessBranchList< Branch > pv, ProcessBranchList< Branch > &subprocesses, double &total_weight)
	Add several new subprocesses at once. More...
virtual double	perform (Particles *particles, uint32_t id_process)
	Actually perform the action, e.g. More...
bool	is_valid (const Particles &particles) const
	Check whether the action still applies. More...
bool	is_pauli_blocked (const std::vector< Particles > &ensembles, const PauliBlocker &p_bl) const
	Check if the action is Pauli-blocked. More...
const ParticleList &	incoming_particles () const
	Get the list of particles that go into the action. More...
void	update_incoming (const Particles &particles)
	Update the incoming particles that are stored in this action to the state they have in the global particle list. More...
const ParticleList &	outgoing_particles () const
	Get the list of particles that resulted from the action. More...
double	time_of_execution () const
	Get the time at which the action is supposed to be performed. More...
virtual double	check_conservation (const uint32_t id_process) const
	Check various conservation laws. More...
double	sqrt_s () const
	Determine the total energy in the center-of-mass frame [GeV]. More...
FourVector	total_momentum_of_outgoing_particles () const
	Calculate the total kinetic momentum of the outgoing particles. More...
FourVector	get_interaction_point () const
	Get the interaction point. More...
std::pair< FourVector, FourVector >	get_potential_at_interaction_point () const
	Get the skyrme and asymmetry potential at the interaction point. More...
void	set_stochastic_pos_idx ()
	Setter function that stores a random incoming particle index latter used to determine the interaction point. More...

Private Attributes
const double	shining_weight_
	The shining weight is a weight you apply to every dilepton decay. More...
double	branching_ = 1.
	An additional branching factor that is multiplied with the shining weight. More...

Additional Inherited Members
Static Public Member Functions inherited from smash::Action
static double	lambda_tilde (double a, double b, double c)
	Little helper function that calculates the lambda function (sometimes written with a tilde to better distinguish it) that appears e.g. More...
static void	sample_manybody_phasespace_impl (double sqrts, const std::vector< double > &m, std::vector< FourVector > &sampled_momenta)
	Implementation of the full n-body phase-space sampling (masses, momenta, angles) in the center-of-mass frame for the final state particles. More...
Protected Member Functions inherited from smash::DecayAction
void	format_debug_output (std::ostream &out) const override
	Writes information about this decay action to the out stream. More...
Protected Member Functions inherited from smash::Action
FourVector	total_momentum () const
	Sum of 4-momenta of incoming particles. More...
template<typename Branch >
const Branch *	choose_channel (const ProcessBranchList< Branch > &subprocesses, double total_weight)
	Decide for a particular final-state channel via Monte-Carlo and return it as a ProcessBranch. More...
virtual void	sample_angles (std::pair< double, double > masses, double kinetic_energy_cm)
	Sample final-state momenta in general X->2 processes (here: using an isotropical angular distribution). More...
void	sample_2body_phasespace ()
	Sample the full 2-body phase-space (masses, momenta, angles) in the center-of-mass frame for the final state particles. More...
void	assign_formation_time_to_outgoing_particles ()
	Assign the formation time to the outgoing particles. More...
Protected Attributes inherited from smash::DecayAction
DecayBranchList	decay_channels_
	List of possible decays. More...
double	total_width_
	total decay width More...
double	partial_width_
	partial decay width to the chosen outgoing channel More...
int	L_ = 0
	Angular momentum of the decay. More...
Protected Attributes inherited from smash::Action
ParticleList	incoming_particles_
	List with data of incoming particles. More...
ParticleList	outgoing_particles_
	Initially this stores only the PDG codes of final-state particles. More...
const double	time_of_execution_
	Time at which the action is supposed to be performed (absolute time in the lab frame in fm). More...
ProcessType	process_type_
	type of process More...
double	box_length_ = -1.0
	Box length: needed to determine coordinates of collision correctly in case of collision through the wall. More...
int	stochastic_position_idx_ = -1
	This stores a randomly-chosen index to an incoming particle. More...

Constructor & Destructor Documentation

DecayActionDilepton()

smash::DecayActionDilepton::DecayActionDilepton	(	const ParticleData &	p,
		double	time_of_execution,
		double	shining_weight
	)

Construct a DecayActionDilepton from a particle p.

It does not initialize the list of possible decay processes. You need to call add_processes after construction.

Parameters

[in]	p	The particle that should decay if the action is performed.
[in]	time_of_execution	Time at which the action is supposed to take place
[in]	shining_weight	The weight of the dilepton decay accroding to the shining method.

Definition at line 16 of file decayactiondilepton.cc.

    : DecayAction({p}, time), shining_weight_(shining_weight) {}

Member Function Documentation

get_total_weight()

double smash::DecayActionDilepton::get_total_weight ( ) const

inlineoverridevirtual

Return the total width of the decay process.

Reimplemented from smash::DecayAction.

Definition at line 41 of file decayactiondilepton.h.

                                           {
    return shining_weight_ * branching_;
  }

sample_manybody_phasespace()

void smash::DecayActionDilepton::sample_manybody_phasespace ( )

overridevirtual

Generates momenta of outgoing dileptons (for Dalitz dilepton decays only).

Reimplemented from smash::Action.

Definition at line 20 of file decayactiondilepton.cc.

                                                     {
  // Only Dalitz decays implemented
  if (outgoing_particles_.size() != 3) {
    throw std::runtime_error(
        "Error in DecayActionDilepton::sample_manybody_phasespace: Incorrrect "
        "number of outgoing particles in Dalitz decay");
  }
  // find the non-lepton particle position
  int non_lepton_position = -1;
  for (int i = 0; i < 3; ++i) {
    if (!(outgoing_particles_[i].type().is_lepton())) {
      non_lepton_position = i;
      break;
    }
  }
 
  if (non_lepton_position == -1) {
    throw std::runtime_error(
        "Error in DecayActionDilepton::sample_3body_phasespace: No "
        "non-leptonic outgoing particle in dilepton Dalitz decay found.");
  }
 
  ParticleData &nl = outgoing_particles_[non_lepton_position];
  ParticleData &l1 = outgoing_particles_[(non_lepton_position + 1) % 3];
  ParticleData &l2 = outgoing_particles_[(non_lepton_position + 2) % 3];
 
  const double mass_l1 = l1.type().mass();  // (pole) mass of first lepton
  const double mass_l2 = l2.type().mass();  // (pole) mass of second lepton
  const double mass_nl = nl.type().mass();  // (pole) mass of non-lepton
 
  const double cms_energy = total_momentum_of_outgoing_particles().abs();
 
  // randomly select a dilepton mass
  const double dil_mass =
      random::uniform(mass_l1 + mass_l2, cms_energy - mass_nl);
  const double delta_m = cms_energy - mass_nl - mass_l1 - mass_l2;
 
  const double diff_width = ThreeBodyDecayDilepton::diff_width(
      cms_energy, mass_l1, dil_mass, mass_nl, &nl.type(),
      &incoming_particles_[0].type());
 
  /* Branching factor, which corrects the shining weight for the differential
   * width at a particular dilepton mass. We do an implicit Monte-Carlo
   * integration over the dilepton mass here, and delta_m is simply the
   * integration volume. */
  branching_ = delta_m * diff_width / decay_channels_[0]->weight();
 
  // perform decay into non-lepton and virtual photon (dilepton)
  const double dil_mom = pCM(cms_energy, dil_mass, mass_nl);
 
  // Here we assume an isotropic angular distribution.
  Angles phitheta;
  phitheta.distribute_isotropically();
 
  FourVector dil_4mom(std::sqrt(dil_mass * dil_mass + dil_mom * dil_mom),
                      phitheta.threevec() * dil_mom);
  nl.set_4momentum(mass_nl, -phitheta.threevec() * dil_mom);
 
  // perform decay of virtual photon into two leptons
  const double mom_lep = pCM(dil_mass, mass_l1, mass_l2);
 
  // Here we assume an isotropic angular distribution.
  phitheta.distribute_isotropically();
 
  l1.set_4momentum(mass_l1, phitheta.threevec() * mom_lep);
  l2.set_4momentum(mass_l2, -phitheta.threevec() * mom_lep);
 
  // Boost Dileptons back in parent particle rest frame
  ThreeVector velocity_CM = dil_4mom.velocity();
  l1.boost_momentum(-velocity_CM);
  l2.boost_momentum(-velocity_CM);
}

Member Data Documentation

shining_weight_

const double smash::DecayActionDilepton::shining_weight_

private

The shining weight is a weight you apply to every dilepton decay.

Because we radiate dileptons at every timestep to increase statistics, we afterwards weight them to correct the dilepton decay yields.

Definition at line 56 of file decayactiondilepton.h.

branching_

double smash::DecayActionDilepton::branching_ = 1.

private

An additional branching factor that is multiplied with the shining weight.

For Dalitz decays, the primary shining weight is based on the integrated width for the channel, and the branching factor corrects for the differential width (evaluated at a particular dilepton mass), relative to the integrated width. It is determined after the dilepton mass is fixed. For direct (2-body) decays, the branching factor equals one.

Definition at line 65 of file decayactiondilepton.h.

---

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

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