Gamma emission exit channel that leads to the unbound continuum in the final state More...

#include <ExitChannel.hh>

Inheritance diagram for marley::GammaContinuumExitChannel:

Classes
struct	GammaSpinParityWidth

Public Member Functions
	GammaContinuumExitChannel (int pdgi, int qi, double Exi, int twoJi, marley::Parity Pi, double rho_i, marley::StructureDatabase &sdb, double Ec_min)

virtual double	differential_width (double Exf, bool store_jpi_widths=false) const final override

virtual double	E_c_max () const final override
	Returns the maximum accessible excitation energy to be used when integrating over the continuum.

Public Member Functions inherited from marley::ContinuumExitChannel
	ContinuumExitChannel (double Ec_min, int lmax)

virtual void	compute_total_width () final override

virtual void	do_decay (double &Ex, int &two_J, marley::Parity &Pi, const std::shared_ptr< HepMC3::GenParticle > &compound_nucleus, std::shared_ptr< HepMC3::GenParticle > &emitted_particle, std::shared_ptr< HepMC3::GenParticle > &residual_nucleus, int &qIon, marley::Generator &gen) const final override
	Simulates a nuclear decay into this channel.

double	E_c_min () const
	Returns the minimum excitation energy bound for the continuum.

const SpinParityWidth *	get_last_sampled_spw () const
	Returns a pointer to the last sampled SpinParityWidth object.

const std::vector< std::unique_ptr< SpinParityWidth > > &	get_spw_table () const
	Grants const access to the vector of SpinParityWidth objects.

virtual bool	is_continuum () const final override
	Returns true if this channel accesses the particle-unbound continuum of nuclear levels or false otherwise.

double	sample_Exf (marley::Generator &gen) const

void	sample_spin_parity (double Exf, int &two_Jf, marley::Parity &Pf, marley::Generator &gen) const

void	set_skip_jpi_sampling (bool skip_it) const
	Sets the flag that will skip sampling of a final-state nuclear spin-parity value in do_decay()

Public Member Functions inherited from marley::ExitChannel
	ExitChannel ()=default

	ExitChannel (int pdgi, int qi, double Exi, int twoJi, marley::Parity Pi, double rho_i, marley::StructureDatabase &sdb)

double	width () const
	Get the total decay width into this channel (MeV)

Public Member Functions inherited from marley::GammaExitChannel
virtual bool	emits_fragment () const final override
	Returns true if this channel involves fragment emission or false if it involves gamma-ray emission.

virtual int	emitted_particle_pdg () const final override
	Returns the PDG code for the particle (gamma-ray or nuclear fragment) emitted by decays into this ExitChannel.

virtual int	final_nucleus_pdg () const final override
	Returns the PDG code for the final nucleus.

Additional Inherited Members
Static Public Member Functions inherited from marley::ExitChannel
template<typename It>
static marley::IteratorToPointerMember< It, double >	make_width_iterator (It it)
	Convert an iterator that points to an ExitChannel object into an iterator to the ExitChannel's width_ member variable.

Protected Member Functions inherited from marley::ContinuumExitChannel
void	clear_jpi_widths () const
	Helper function that resets the table of SpinParityWidth objects.

Protected Member Functions inherited from marley::ExitChannel
virtual void	prepare_products (const std::shared_ptr< HepMC3::GenParticle > &compound_nucleus, std::shared_ptr< HepMC3::GenParticle > &emitted_particle, std::shared_ptr< HepMC3::GenParticle > &residual_nucleus, double Exf, int &qf, marley::Generator &gen) const
	Helper function that prepares Particle objects representing the products of the two-body decay.

Protected Member Functions inherited from marley::GammaExitChannel
double	gamma_energy (double Exf) const

marley::GammaStrengthFunctionModel::TransitionType	get_transition_type (int mpol, marley::Parity Pf) const

Protected Attributes inherited from marley::ContinuumExitChannel
double	E_c_min_
	Minimum accessible nuclear excitation energy (MeV) in the continuum.

std::unique_ptr< marley::ChebyshevInterpolatingFunction >	Exf_cdf_
	Chebyshev polynomial interpolant to the cumulative density function for the final-state nuclear excitation energy.

std::vector< std::unique_ptr< SpinParityWidth > >	jpi_widths_table_
	Table of possible final-state spin-parities together with their partial differential decay widths.

int	l_max_

SpinParityWidth *	last_sampled_spw_ = nullptr
	Points to the last SpinParityWidth object sampled in a previous call to sample_spin_parity()

bool	skip_jpi_sampling_ = false
	Flag that allows skipping the sampling of a final nuclear spin-parity (useful only for testing purposes)

Protected Attributes inherited from marley::ExitChannel
double	Exi_
	Initial nuclear excitation energy \( E_x \) (MeV)

double	one_over_two_pi_rho_i_

int	pdgi_
	PDG code for the initial nucleus.

marley::Parity	Pi_
	Initial nuclear parity \( \Pi \).

int	qi_

marley::StructureDatabase *	sdb_
	StructureDatabase to use in calculations.

int	twoJi_
	Two times the initial nuclear spin \( J \).

double	width_
	Total decay width into this channel (MeV)

Detailed Description

Gamma emission exit channel that leads to the unbound continuum in the final state

Definition at line 447 of file ExitChannel.hh.

Constructor & Destructor Documentation

◆ GammaContinuumExitChannel()

marley::GammaContinuumExitChannel::GammaContinuumExitChannel	(	int	pdgi,
		int	qi,
		double	Exi,
		int	twoJi,
		marley::Parity	Pi,
		double	rho_i,
		marley::StructureDatabase &	sdb,
		double	Ec_min )

inline

Note: This line keeps old versions (4.9.3) of GCC happy

Definition at line 467 of file ExitChannel.hh.

                       : ExitChannel( pdgi, qi, Exi, twoJi, Pi, rho_i, sdb ),
        ContinuumExitChannel( Ec_min, sdb.get_gamma_l_max() ),
        GammaExitChannel()
      {
        this->compute_total_width();
      }

References marley::ContinuumExitChannel::ContinuumExitChannel(), and marley::ContinuumExitChannel::compute_total_width().

Member Function Documentation

◆ differential_width()

double marley::GammaContinuumExitChannel::differential_width	(	double	Exf,
		bool	store_jpi_widths = false ) const

finaloverridevirtual

Implements marley::ContinuumExitChannel.

Definition at line 327 of file ExitChannel.cc.

{
  if ( store_jpi_widths ) this->clear_jpi_widths();
 
  auto& ldm = sdb_->get_level_density_model( pdgi_ );
  auto& gsfm = sdb_->get_gamma_strength_function_model( pdgi_ );
 
  // Initialize the return value to zero
  double diff_width = 0.;
 
  // Check that the continuum bounds make sense
  if ( Exi_ < E_c_min_ ) throw_continuum_bounds_error( E_c_min_, Exi_ );
 
  // Check that Exf lies within the continuum
  if ( Exf < (E_c_min_ - TINY_OFFSET) || Exf > (Exi_ + TINY_OFFSET) ) {
    // If it doesn't, complain and return zero
    issue_Exf_continuum_warning( Exf, E_c_min_, Exi_ );
    return 0.;
  }
 
  // Compute the energy of the emitted gamma-ray
  double E_gamma = this->gamma_energy( Exf );
 
  // Array containing both possible parity values. It is used in
  // the loop below.
  constexpr std::array<marley::Parity, 2>
    parities = { marley::Parity(true), marley::Parity(false) };
 
  // Sum over multipolarities. There is no monopole radiation, so
  // the sum begins at mpol = 1.
  for ( int mpol = 1; mpol <= l_max_; ++mpol ) {
 
    int two_mpol = 2 * mpol;
 
    for ( int twoJf = std::abs(twoJi_ - two_mpol); twoJf <= twoJi_ + two_mpol;
      twoJf += 2 )
    {
      for ( const auto& Pf : parities ) {
 
        // Use the multipolarity and final-state nuclear parity to determine
        // whether the current partial differential width represents an
        // electric or magnetic transition
        TrType type = this->get_transition_type( mpol, Pf );
 
        double Txl = gsfm.transmission_coefficient( type, mpol, E_gamma );
        double rho_f = ldm.level_density(Exf, twoJf, Pf);
 
        double term = one_over_two_pi_rho_i_ * Txl * rho_f;
 
        if ( store_jpi_widths ) {
 
          auto g_spw = std::make_unique< GammaSpinParityWidth >(
            twoJf, Pf, term, mpol );
 
          jpi_widths_table_.push_back( std::move(g_spw) );
        }
 
        diff_width += term;
      }
    }
  }
  return diff_width;
}

◆ E_c_max()

virtual double marley::GammaContinuumExitChannel::E_c_max ( ) const

inlinefinaloverridevirtual

Returns the maximum accessible excitation energy to be used when integrating over the continuum.

Implements marley::ContinuumExitChannel.

Definition at line 479 of file ExitChannel.hh.

480 { return Exi_; }

References E_c_max(), and marley::ExitChannel::Exi_.

Referenced by E_c_max().

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

/home/sjg/Desktop/marley/include/marley/ExitChannel.hh
/home/sjg/Desktop/marley/src/ExitChannel.cc

Classes