#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:

[legend]

Collaboration diagram for smash::DecayActionDilepton:

[legend]

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_3body_phasespace () override
	Sample the full 3-body phase-space (masses, momenta, angles) in the center-of-mass frame for the final state particles. 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 void	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 Particles &particles, 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...

void	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...

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
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...

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/c). More...

ProcessType	process_type_
	type of process More...

Constructor & Destructor Documentation

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 17 of file decayactiondilepton.cc.

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

smash::DecayAction::DecayAction

DecayAction(const ParticleData &p, double time)

Construct a DecayAction from a particle p.

Definition: decayaction.cc:21

smash::DecayActionDilepton::shining_weight_

const double shining_weight_

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

Definition: decayactiondilepton.h:53

smash::pdg::p

constexpr int p

Proton.

Definition: pdgcode_constants.h:28

Member Function Documentation

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_;
   }

Here is the call graph for this function:

void smash::DecayActionDilepton::sample_3body_phasespace ( )

overridevirtual

Sample the full 3-body phase-space (masses, momenta, angles) in the center-of-mass frame for the final state particles.

Reimplemented from smash::Action.

Definition at line 21 of file decayactiondilepton.cc.

                                                   {
   // 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.");
   }
 
   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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

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 53 of file decayactiondilepton.h.

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 62 of file decayactiondilepton.h.

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation