Fragment emission ExitChannel that leads to the unbound continuum in the final state More...

#include <ExitChannel.hh>

Inheritance diagram for marley::FragmentContinuumExitChannel:

Classes
struct	FragmentSpinParityWidth

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

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::FragmentExitChannel
	FragmentExitChannel (const marley::Fragment &fragment)

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::FragmentExitChannel
double	max_Exf () const
	Helper function that returns that maximum possible excitation energy for the daughter nucleus after emission of the fragment.

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)

Protected Attributes inherited from marley::FragmentExitChannel
int	fragment_pdg_
	PDG code identifying the emitted fragment.

Detailed Description

Fragment emission ExitChannel that leads to the unbound continuum in the final state

Definition at line 403 of file ExitChannel.hh.

Constructor & Destructor Documentation

◆ FragmentContinuumExitChannel()

marley::FragmentContinuumExitChannel::FragmentContinuumExitChannel	(	int	pdgi,
		int	qi,
		double	Exi,
		int	twoJi,
		marley::Parity	Pi,
		double	rho_i,
		marley::StructureDatabase &	sdb,
		double	Ec_min,
		const marley::Fragment &	frag )

inline

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

Definition at line 428 of file ExitChannel.hh.

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

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

Member Function Documentation

◆ differential_width()

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

finaloverridevirtual

Implements marley::ContinuumExitChannel.

Definition at line 221 of file ExitChannel.cc.

{
  if ( store_jpi_widths ) this->clear_jpi_widths();
 
  int remnant_pdg = this->final_nucleus_pdg();
  marley::OpticalModel& om = sdb_->get_optical_model( remnant_pdg );
  marley::LevelDensityModel& ldm = sdb_->get_level_density_model( remnant_pdg );
 
  // Get the maximum accessible final excitation energy
  double Exf_max = this->max_Exf();
 
  // Initialize the return value to zero
  double diff_width = 0.;
 
  if ( Exf_max < E_c_min_ ) throw_continuum_bounds_error( E_c_min_, Exf_max );
 
  // Check that Exf lies within the continuum
  if ( Exf < (E_c_min_ - TINY_OFFSET) || Exf > (Exf_max + TINY_OFFSET) ) {
    // If it doesn't, complain and return zero
    issue_Exf_continuum_warning( Exf, E_c_min_, Exf_max );
    return 0.;
  }
 
  double total_KE_CM_frame = Exf_max - Exf;
 
  // Get information about the emitted fragment
  const marley::Fragment& f = *sdb_->get_fragment( fragment_pdg_ );
 
  int two_s = f.get_two_s(); // two times the fragment spin
  marley::Parity Pa = f.get_parity(); // intrinsic parity
 
 
 
  // Final nuclear parity
  marley::Parity Pf;
  // The orbital parity starts as (-1)^0 = 1. Rather than applying parity
  // conservation each time, just find the final state parity Pf for l = 0.
  // Then we can safely flip Pf without further thought for each new l value in
  // the loop.
  if (Pi_ == Pa) Pf = 1;
  else Pf = -1;
  // For each new iteration, increment l and flip the final-state parity
  for (int l = 0; l <= l_max_; ++l, !Pf) {
    int two_l = 2*l;
    for (int two_j = std::abs(two_l - two_s);
      two_j <= two_l + two_s; two_j += 2)
    {
 
      for (int twoJf = std::abs(twoJi_ - two_j);
        twoJf <= twoJi_ + two_j; twoJf += 2)
      {
 
        double Tlj = om.transmission_coefficient( total_KE_CM_frame,
          fragment_pdg_, two_j, l, two_s );
 
        double rho_f = ldm.level_density( Exf, twoJf, Pf );
 
        double term = one_over_two_pi_rho_i_ * Tlj * rho_f;
 
        diff_width += term;
 
        if ( store_jpi_widths ) {
 
          auto f_spw = std::make_unique< FragmentSpinParityWidth >(
            twoJf, Pf, term, two_j, l );
 
          jpi_widths_table_.push_back( std::move(f_spw) );
          // TODO: include (l, two_j) in cached term
        }
      }
    }
  }
  return diff_width;
}

◆ E_c_max()

virtual double marley::FragmentContinuumExitChannel::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 441 of file ExitChannel.hh.

442 { return this->max_Exf(); }

References E_c_max(), and marley::FragmentExitChannel::max_Exf().

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