#include <MCGIDI.hpp>

Public Member Functions
LUPI_HOST_DEVICE	Reaction ()
LUPI_HOST	Reaction (GIDI::Reaction const &a_reaction, SetupInfo &a_setupInfo, Transporting::MC const &a_settings, GIDI::Transporting::Particles const &a_particles, GIDI::Styles::TemperatureInfos const &a_temperatureInfos)
LUPI_HOST_DEVICE	~Reaction ()
LUPI_HOST_DEVICE void	updateProtareSingleInfo (ProtareSingle *a_protareSingle, std::size_t a_reactionIndex)
LUPI_HOST_DEVICE ProtareSingle const *	protareSingle () const
LUPI_HOST_DEVICE std::size_t	reactionIndex () const
LUPI_HOST_DEVICE std::size_t	GIDI_reactionIndex () const
LUPI_HOST_DEVICE String const &	label () const
LUPI_HOST_DEVICE int	ENDF_MT () const
LUPI_HOST_DEVICE int	ENDL_C () const
LUPI_HOST_DEVICE int	ENDL_S () const
LUPI_HOST_DEVICE int	initialStateIndex () const
LUPI_HOST_DEVICE double	finalQ (double a_energy) const
LUPI_HOST_DEVICE bool	hasFission () const
LUPI_HOST_DEVICE double	projectileMass () const
LUPI_HOST_DEVICE double	targetMass () const
LUPI_HOST_DEVICE double	crossSectionThreshold () const
LUPI_HOST_DEVICE double	twoBodyThreshold () const
LUPI_HOST_DEVICE double	crossSection (URR_protareInfos const &a_URR_protareInfos, std::size_t a_hashIndex, double a_temperature, double a_energy) const
LUPI_HOST_DEVICE double	crossSection (URR_protareInfos const &a_URR_protareInfos, double a_temperature, double a_energy) const
LUPI_HOST GIDI::Functions::XYs1d	crossSectionAsGIDI_XYs1d (double a_temperature) const
LUPI_HOST_DEVICE Vector< int > const &	productIntids () const
LUPI_HOST_DEVICE Vector< int > const &	productIndices () const
LUPI_HOST_DEVICE Vector< int > const &	userProductIndices () const
LUPI_HOST_DEVICE std::size_t	numberOfProducts () const
LUPI_HOST_DEVICE Product const *	product (std::size_t a_index) const
LUPI_HOST_DEVICE int	productMultiplicity (int a_index) const
LUPI_HOST_DEVICE int	productMultiplicityViaIntid (int a_intid) const
LUPI_HOST_DEVICE int	productMultiplicities (int a_index) const
LUPI_HOST_DEVICE double	productAverageMultiplicity (int a_index, double a_projectileEnergy) const
LUPI_HOST_DEVICE double	productAverageMultiplicityViaIntid (int a_intid, double a_projectileEnergy) const
LUPI_HOST_DEVICE Vector< int > const &	productIntidsTransportable () const
LUPI_HOST_DEVICE Vector< int > const &	productIndicesTransportable () const
LUPI_HOST_DEVICE Vector< int > const &	userProductIndicesTransportable () const
LUPI_HOST_DEVICE Vector< std::size_t >	associatedOrphanProductIndices () const
LUPI_HOST void	addOrphanProductToProductList (std::vector< Product * > &a_associatedOrphanProducts) const
LUPI_HOST_DEVICE void	addOrphanProductToProductList (Vector< Product * > &a_associatedOrphanProducts) const
LUPI_HOST_DEVICE void	addOrphanProductToProductList (Vector< Reaction * > &a_orphanProducts)
LUPI_HOST void	setOrphanProductData (std::vector< std::size_t > const &a_associatedOrphanProductIndcies, std::vector< Product * > const &a_associatedOrphanProducts)
LUPI_HOST void	setUserParticleIndex (int a_particleIndex, int a_userParticleIndex)
LUPI_HOST void	setUserParticleIndexViaIntid (int a_particleIntid, int a_userParticleIndex)
LUPI_HOST void	setModelDBRC_data (Sampling::Upscatter::ModelDBRC_data *a_modelDBRC_data)
template<typename RNG, typename PUSHBACK>
LUPI_HOST_DEVICE void	sampleProducts (Protare const *a_protare, Sampling::Input &a_input, RNG &&a_rng, PUSHBACK &&a_push_back, Sampling::ProductHandler &a_products, bool a_checkOrphanProducts=true) const
template<typename RNG>
LUPI_HOST_DEVICE double	angleBiasing (int a_pid, double a_temperature, double a_energy_in, double a_mu_lab, double &a_energy_out, RNG &&a_rng, double *a_cumulative_weight=nullptr, bool a_checkOrphanProducts=true) const
template<typename RNG>
LUPI_HOST_DEVICE double	angleBiasingViaIntid (int a_intid, double a_temperature, double a_energy_in, double a_mu_lab, double &a_energy_out, RNG &&a_rng, double *a_cumulative_weight=nullptr, bool a_checkOrphanProducts=true) const
LUPI_HOST_DEVICE void	serialize (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)

Static Public Member Functions
template<typename RNG, typename PUSHBACK>
static LUPI_HOST_DEVICE void	sampleNullProducts (Protare const &a_protare, double a_projectileEnergy, Sampling::Input &a_input, RNG &&a_rng, PUSHBACK &&a_push_back, Sampling::ProductHandler &a_products)

Detailed Description

Class representing a GNDS <reaction> node with only data needed for Monte Carlo transport.

Definition at line 1335 of file MCGIDI.hpp.

Constructor & Destructor Documentation

◆ Reaction() [1/2]

LUPI_HOST_DEVICE MCGIDI::Reaction::Reaction ( )

Default constructor used when broadcasting a Reaction as needed by MPI or GPUs.

Definition at line 22 of file MCGIDI_reaction.cc.

                                     :
        m_protareSingle( nullptr ),
        m_reactionIndex( MCGIDI_nullReaction ),
        m_GIDI_reactionIndex( MCGIDI_nullReaction ),
        m_label( ),
        m_ENDF_MT( 0 ),
        m_ENDL_C( 0 ),
        m_ENDL_S( 0 ),
        m_initialStateIndex( -1 ),
        m_neutronIndex( -1 ),
        m_hasFission( false ),
        m_projectileMass( 0.0 ),
        m_targetMass( 0.0 ),
        m_crossSectionThreshold( 0.0 ),
        m_twoBodyThreshold( 0.0 ),
        m_hasFinalStatePhotons( false ),
        m_fissionResiduaIntid( -1 ),
        m_fissionResiduaIndex( -1 ),
        m_fissionResiduaUserIndex( -1 ),
        m_fissionResiduals( GIDI::Construction::FissionResiduals::none ),
        m_fissionResidualMass( 0.0 ),
        m_totalDelayedNeutronMultiplicity( nullptr ),
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
        m_outputChannel( nullptr ),
#endif
 
// GRIN extras:
        m_GRIN_specialSampleProducts( false ),
        m_GRIN_inelasticThreshold( 0.0 ),
        m_GRIN_maximumCaptureIncidentEnergy( 0.0 ),
        m_GRIN_inelastic( nullptr ),
        m_GRIN_capture( nullptr ) {
}

Referenced by addOrphanProductToProductList().

◆ Reaction() [2/2]

LUPI_HOST MCGIDI::Reaction::Reaction	(	GIDI::Reaction const &	a_reaction,
		SetupInfo &	a_setupInfo,
		Transporting::MC const &	a_settings,
		GIDI::Transporting::Particles const &	a_particles,
		GIDI::Styles::TemperatureInfos const &	a_temperatureInfos )

◆ ~Reaction()

LUPI_HOST_DEVICE MCGIDI::Reaction::~Reaction ( )

Definition at line 178 of file MCGIDI_reaction.cc.

                                      {
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    delete m_outputChannel;
#else
    delete m_totalDelayedNeutronMultiplicity;
    for( auto iter = m_products.begin( ); iter != m_products.end( ); ++iter ) delete *iter;
    for( auto iter = m_delayedNeutrons.begin( ); iter != m_delayedNeutrons.end( ); ++iter ) delete *iter;
    for( auto iter = m_Qs.begin( ); iter != m_Qs.end( ); ++iter ) delete *iter;
#endif
}

Member Function Documentation

◆ addOrphanProductToProductList() [1/3]

LUPI_HOST void MCGIDI::Reaction::addOrphanProductToProductList ( std::vector< Product * > & a_associatedOrphanProducts ) const

Adds the associated orphan products of an orphan product reaction to a_associatedOrphanProducts.

Parameters

a_associatedOrphanProducts [in] A list where the associated orphan products are added to.

Definition at line 460 of file MCGIDI_reaction.cc.

                                                                                                               {
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    m_outputChannel->addOrphanProductToProductList( a_associatedOrphanProducts );
#else
    for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
        a_associatedOrphanProducts.push_back( *productIter );
    }
#endif
}

Referenced by addOrphanProductToProductList().

◆ addOrphanProductToProductList() [2/3]

LUPI_HOST_DEVICE void MCGIDI::Reaction::addOrphanProductToProductList ( Vector< Product * > & a_associatedOrphanProducts ) const

Adds the associated orphan products of an orphan product reaction to a_associatedOrphanProducts.

Parameters

a_associatedOrphanProducts [in] A list where the associated orphan products are added to.

Definition at line 477 of file MCGIDI_reaction.cc.

                                                                                                                   {
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    m_outputChannel->addOrphanProductToProductList( a_associatedOrphanProducts );
#else
    for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
        a_associatedOrphanProducts.push_back( *productIter );
    }
#endif
}

◆ addOrphanProductToProductList() [3/3]

LUPI_HOST_DEVICE void MCGIDI::Reaction::addOrphanProductToProductList ( Vector< Reaction * > & a_orphanProducts )

Adds the associated orphan products of an orphan product to a_associatedOrphanProducts.

Parameters

a_associatedOrphanProducts [in] A list where the associated orphan products are added to.

Definition at line 494 of file MCGIDI_reaction.cc.

                                                                                                    {
 
    for( auto associatedOrphanProductIndex = m_associatedOrphanProductIndices.begin( );
            associatedOrphanProductIndex != m_associatedOrphanProductIndices.end( ); ++associatedOrphanProductIndex ) {
        Reaction *orphanProduct = a_orphanProducts[*associatedOrphanProductIndex];
        orphanProduct->addOrphanProductToProductList( m_associatedOrphanProducts );
    }
}

◆ angleBiasing()

template<typename RNG>

LUPI_HOST_DEVICE double MCGIDI::Reaction::angleBiasing	(	int	a_index,
		double	a_temperature,
		double	a_energy_in,
		double	a_mu_lab,
		double &	a_energy_out,
		RNG &&	a_rng,
		double *	a_cumulative_weight = nullptr,
		bool	a_checkOrphanProducts = true ) const

inline

Returns the weight for a project with energy a_energy_in to cause this reaction to emitted a particle of index a_index at angle a_mu_lab as seen in the lab frame. If a particle is emitted, a_energy_out is its sampled outgoing energy.

Parameters

a_index	[in] The index of the particle to emit.
a_temperature	[in] Specifies the temperature of the material.
a_energy_in	[in] The energy of the incident particle.
a_mu_lab	[in] The desired mu in the lab frame for the emitted particle.
a_energy_out	[in] The energy of the emitted outgoing particle.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).
a_cumulative_weight	[in] The cumulative multiplicity.
a_checkOrphanProducts	[in] If true, associated orphan products are also sampled.

Returns: The weight that the particle is emitted into mu a_mu_lab.

Definition at line 3274 of file MCGIDI_headerSource.hpp.

                                                                                              {
 
    double cumulative_weight1 = 0.0;
    if( a_cumulative_weight == nullptr ) a_cumulative_weight = &cumulative_weight1;
    double weight1 = 0.0;
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    m_outputChannel->angleBiasing( this, a_index, a_temperature, a_energy_in, a_mu_lab, weight1, a_energy_out, a_rng, *a_cumulative_weight );
#else
 
    for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
        (*productIter)->angleBiasing( this, a_index, a_temperature, a_energy_in, a_mu_lab, weight1, a_energy_out, a_rng, *a_cumulative_weight );
    }
 
    if( ( m_totalDelayedNeutronMultiplicity != nullptr ) && ( a_index == m_neutronIndex ) ) {
        for( std::size_t i1 = 0; i1 < (std::size_t) m_delayedNeutrons.size( ); ++i1 ) {
            DelayedNeutron const *delayedNeutron1 = m_delayedNeutrons[i1];
            Product const &product = delayedNeutron1->product( );
 
            product.angleBiasing( this, a_index, a_temperature, a_energy_in, a_mu_lab, weight1, a_energy_out, a_rng, *a_cumulative_weight );
        }
    }
#endif
 
    if( a_checkOrphanProducts ) {
        for( auto productIter = m_associatedOrphanProducts.begin( ); productIter != m_associatedOrphanProducts.end( ); ++productIter ) {
            (*productIter)->angleBiasing( this, a_index, a_temperature, a_energy_in, a_mu_lab, weight1, a_energy_out, a_rng, 
                    *a_cumulative_weight );
        }
    }
 
    return( weight1 );
}

◆ angleBiasingViaIntid()

template<typename RNG>

LUPI_HOST_DEVICE double MCGIDI::Reaction::angleBiasingViaIntid	(	int	a_intid,
		double	a_temperature,
		double	a_energy_in,
		double	a_mu_lab,
		double &	a_energy_out,
		RNG &&	a_rng,
		double *	a_cumulative_weight = nullptr,
		bool	a_checkOrphanProducts = true ) const

inline

Returns the weight for a project with energy a_energy_in to cause this reaction to emitted a particle of intid a_intid at angle a_mu_lab as seen in the lab frame. If a particle is emitted, a_energy_out is its sampled outgoing energy.

Parameters

a_intid	[in] The intid of the particle to emit.
a_temperature	[in] Specifies the temperature of the material.
a_energy_in	[in] The energy of the incident particle.
a_mu_lab	[in] The desired mu in the lab frame for the emitted particle.
a_energy_out	[in] The energy of the emitted outgoing particle.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).
a_cumulative_weight	[in] The cumulative multiplicity.
a_checkOrphanProducts	[in] If true, associated orphan products are also sampled.

Returns: The weight that the particle is emitted into mu a_mu_lab.

Definition at line 3326 of file MCGIDI_headerSource.hpp.

                                                                                              {
 
    double cumulative_weight1 = 0.0;
    if( a_cumulative_weight == nullptr ) a_cumulative_weight = &cumulative_weight1;
    double weight1 = 0.0;
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    m_outputChannel->angleBiasingViaIntid( this, a_intid, a_temperature, a_energy_in, a_mu_lab, weight1, a_energy_out, a_rng, *a_cumulative_weight );
#else
 
    for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
        (*productIter)->angleBiasingViaIntid( this, a_intid, a_temperature, a_energy_in, a_mu_lab, weight1, a_energy_out, a_rng, *a_cumulative_weight );
    }
 
    if( ( m_totalDelayedNeutronMultiplicity != nullptr ) && ( a_intid == PoPI::Intids::neutron ) ) {
        for( std::size_t i1 = 0; i1 < (std::size_t) m_delayedNeutrons.size( ); ++i1 ) {
            DelayedNeutron const *delayedNeutron1 = m_delayedNeutrons[i1];
            Product const &product = delayedNeutron1->product( );
 
            product.angleBiasingViaIntid( this, a_intid, a_temperature, a_energy_in, a_mu_lab, weight1, a_energy_out, a_rng, *a_cumulative_weight );
        }
    }
#endif
 
    if( a_checkOrphanProducts ) {
        for( auto productIter = m_associatedOrphanProducts.begin( ); productIter != m_associatedOrphanProducts.end( ); ++productIter ) {
            (*productIter)->angleBiasingViaIntid( this, a_intid, a_temperature, a_energy_in, a_mu_lab, weight1, a_energy_out, a_rng,
                    *a_cumulative_weight );
        }
    }
 
    return( weight1 );
}

◆ associatedOrphanProductIndices()

LUPI_HOST_DEVICE Vector< std::size_t > MCGIDI::Reaction::associatedOrphanProductIndices ( ) const

inline

Returns the value of the m_associatedOrphanProductIndicex member.

Definition at line 1439 of file MCGIDI.hpp.

◆ crossSection() [1/2]

LUPI_HOST_DEVICE double MCGIDI::Reaction::crossSection	(	URR_protareInfos const &	a_URR_protareInfos,
		double	a_temperature,
		double	a_energy_in ) const

Returns the reaction's cross section for target temperature a_temperature and projectile energy a_energy_in.

Parameters

a_URR_protareInfos	[in] URR information.
a_temperature	[in] The temperature of the target.
a_energy_in	[in] The energy of the projectile.

Definition at line 232 of file MCGIDI_reaction.cc.

                                                                                                                                           {
 
    return( m_protareSingle->reactionCrossSection( m_reactionIndex, a_URR_protareInfos, a_temperature, a_energy_in ) );
}

◆ crossSection() [2/2]

LUPI_HOST_DEVICE double MCGIDI::Reaction::crossSection	(	URR_protareInfos const &	a_URR_protareInfos,
		std::size_t	a_hashIndex,
		double	a_temperature,
		double	a_energy_in ) const

Returns the reaction's cross section for target temperature a_temperature and projectile energy a_energy_in.

Parameters

a_URR_protareInfos	[in] URR information.
a_hashIndex	[in] Specifies the continuous energy or multi-group index.
a_temperature	[in] The temperature of the target.
a_energy_in	[in] The energy of the projectile.

Definition at line 219 of file MCGIDI_reaction.cc.

                                                                                                                                                                  {
 
    return( m_protareSingle->reactionCrossSection( m_reactionIndex, a_URR_protareInfos, a_hashIndex, a_temperature, a_energy_in, false ) );
}

◆ crossSectionAsGIDI_XYs1d()

LUPI_HOST GIDI::Functions::XYs1d MCGIDI::Reaction::crossSectionAsGIDI_XYs1d ( double a_temperature ) const

Returns the reaction's cross section as a pointer to a GIDI::Functions::XYs1d instance.

Returns: A GIDI::Functions::XYs1d instance.

Definition at line 243 of file MCGIDI_reaction.cc.

                                                                                            {
 
    return( m_protareSingle->heatedCrossSections( ).reactionCrossSectionAsGIDI_XYs1d( m_reactionIndex, a_temperature ) );
}

◆ crossSectionThreshold()

LUPI_HOST_DEVICE double MCGIDI::Reaction::crossSectionThreshold ( ) const

inline

Returns the value of the m_crossSectionThreshold.

Definition at line 1411 of file MCGIDI.hpp.

◆ ENDF_MT()

LUPI_HOST_DEVICE int MCGIDI::Reaction::ENDF_MT ( ) const

inline

Returns the value of the m_ENDF_MT.

Definition at line 1403 of file MCGIDI.hpp.

◆ ENDL_C()

LUPI_HOST_DEVICE int MCGIDI::Reaction::ENDL_C ( ) const

inline

Returns the value of the m_ENDL_C.

Definition at line 1404 of file MCGIDI.hpp.

◆ ENDL_S()

LUPI_HOST_DEVICE int MCGIDI::Reaction::ENDL_S ( ) const

inline

Returns the value of the m_ENDL_S.

Definition at line 1405 of file MCGIDI.hpp.

◆ finalQ()

LUPI_HOST_DEVICE double MCGIDI::Reaction::finalQ ( double a_energy ) const

Returns the Q-value for projectile energy a_energy.

Parameters

a_URR_protareInfos	[in] URR information.
a_hashIndex	[in] Specifies the continuous energy or multi-group index.
a_temperature	[in] The temperature of the target.
a_energy_in	[in] The energy of the projectile.

Definition at line 198 of file MCGIDI_reaction.cc.

                                                                { 
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    return( m_outputChannel->finalQ( a_energy ) );
#else
    double Q = 0.0;
    for( auto Q_iter = m_Qs.begin( ); Q_iter != m_Qs.end( ); ++Q_iter ) Q += (*Q_iter)->evaluate( a_energy );
 
    return( Q );
#endif
}

◆ GIDI_reactionIndex()

LUPI_HOST_DEVICE std::size_t MCGIDI::Reaction::GIDI_reactionIndex ( ) const

inline

Returns the value of the m_GIDI_reactionIndex member.

Definition at line 1401 of file MCGIDI.hpp.

◆ hasFission()

LUPI_HOST_DEVICE bool MCGIDI::Reaction::hasFission ( ) const

inline

Returns the value of the m_hasFission.

Definition at line 1408 of file MCGIDI.hpp.

◆ initialStateIndex()

LUPI_HOST_DEVICE int MCGIDI::Reaction::initialStateIndex ( ) const

inline

Returns the value of the m_initialStateIndex member.

Definition at line 1406 of file MCGIDI.hpp.

◆ label()

LUPI_HOST_DEVICE String const & MCGIDI::Reaction::label ( ) const

inline

Returns the value of the m_label.

Definition at line 1402 of file MCGIDI.hpp.

◆ numberOfProducts()

LUPI_HOST_DEVICE std::size_t MCGIDI::Reaction::numberOfProducts ( ) const

inline

Returns the number of products in the m_products member.

Definition at line 1421 of file MCGIDI.hpp.

◆ product()

LUPI_HOST_DEVICE Product const * MCGIDI::Reaction::product ( std::size_t a_index ) const

inline

Definition at line 1422 of file MCGIDI.hpp.

1422{ return( m_products[a_index] ); }

Referenced by angleBiasing(), angleBiasingViaIntid(), and sampleProducts().

◆ productAverageMultiplicity()

LUPI_HOST_DEVICE double MCGIDI::Reaction::productAverageMultiplicity	(	int	a_index,
		double	a_projectileEnergy ) const

Returns the energy dependent multiplicity for outgoing particle with pops index a_index. The returned value may not be an integer. Energy dependent multiplicity mainly occurs for photons and fission neutrons.

Parameters

a_index	[in] The PoPs index of the requested particle.
a_projectileEnergy	[in] The energy of the projectile.

Returns: The multiplicity value for the requested particle.

Definition at line 297 of file MCGIDI_reaction.cc.

                                                                                                           {
 
    double multiplicity = 0.0;
 
    if( m_crossSectionThreshold > a_projectileEnergy ) return( multiplicity );
 
    std::size_t i1 = 0;
    for( Vector<int>::iterator iter = m_productIndices.begin( ); iter != m_productIndices.end( ); ++iter, ++i1 ) {
        if( *iter == a_index ) {
            multiplicity = m_productMultiplicities[i1];
            break;
        }
    }
 
    if( multiplicity < 0 ) {
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
        multiplicity = m_outputChannel->productAverageMultiplicity( a_index, a_projectileEnergy );
#else
        multiplicity = 0.0;
        for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
            multiplicity += (*productIter)->productAverageMultiplicity( a_index, a_projectileEnergy );
        }
 
        if( ( m_totalDelayedNeutronMultiplicity != nullptr ) && ( a_index == m_neutronIndex ) ) {
            multiplicity += m_totalDelayedNeutronMultiplicity->evaluate( a_projectileEnergy );
        }
#endif
    }
 
    return( multiplicity );
}

◆ productAverageMultiplicityViaIntid()

LUPI_HOST_DEVICE double MCGIDI::Reaction::productAverageMultiplicityViaIntid	(	int	a_intid,
		double	a_projectileEnergy ) const

Returns the energy dependent multiplicity for outgoing particle with pops intid a_intid. The returned value may not be an integer. Energy dependent multiplicity mainly occurs for photons and fission neutrons.

Parameters

a_intid	[in] The PoPs intid of the requested particle.
a_projectileEnergy	[in] The energy of the projectile.

Returns: The multiplicity value for the requested particle.

Definition at line 339 of file MCGIDI_reaction.cc.

                                                                                                                   {
 
    double multiplicity = 0.0;
 
    if( m_crossSectionThreshold > a_projectileEnergy ) return( multiplicity );
 
    std::size_t i1 = 0;
    for( Vector<int>::iterator iter = m_productIntids.begin( ); iter != m_productIntids.end( ); ++iter, ++i1 ) {
        if( *iter == a_intid ) {
            multiplicity = m_productMultiplicities[i1];
            break;
        }
    }
 
    if( multiplicity < 0 ) {
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
        multiplicity = m_outputChannel->productAverageMultiplicityViaIntid( a_intid, a_projectileEnergy );
#else
        multiplicity = 0.0;
        for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
            multiplicity += (*productIter)->productAverageMultiplicityViaIntid( a_intid, a_projectileEnergy );
        }
 
        if( ( m_totalDelayedNeutronMultiplicity != nullptr ) && ( a_intid == PoPI::Intids::neutron ) ) {
            multiplicity += m_totalDelayedNeutronMultiplicity->evaluate( a_projectileEnergy );
        }
#endif
    }
 
    return( multiplicity );
}

◆ productIndices()

LUPI_HOST_DEVICE Vector< int > const & MCGIDI::Reaction::productIndices ( ) const

inline

Returns a const reference to the m_productIntids member.

Definition at line 1419 of file MCGIDI.hpp.

◆ productIndicesTransportable()

LUPI_HOST_DEVICE Vector< int > const & MCGIDI::Reaction::productIndicesTransportable ( ) const

inline

Returns a const reference to the m_productIndicesTransportable member.

Definition at line 1432 of file MCGIDI.hpp.

◆ productIntids()

LUPI_HOST_DEVICE Vector< int > const & MCGIDI::Reaction::productIntids ( ) const

inline

Definition at line 1418 of file MCGIDI.hpp.

1418{ return( m_productIntids ); }

◆ productIntidsTransportable()

LUPI_HOST_DEVICE Vector< int > const & MCGIDI::Reaction::productIntidsTransportable ( ) const

inline

Returns a const reference to the m_productIntidsTransportable member.

Definition at line 1430 of file MCGIDI.hpp.

◆ productMultiplicities()

LUPI_HOST_DEVICE int MCGIDI::Reaction::productMultiplicities ( int a_index ) const

inline

This method is deprecated. Please use productMultiplicity instead.

Definition at line 1425 of file MCGIDI.hpp.

◆ productMultiplicity()

LUPI_HOST_DEVICE int MCGIDI::Reaction::productMultiplicity ( int a_index ) const

Returns the multiplicity for outgoing particle with pops index a_index. If the multiplicity is energy dependent, the returned value is -1. For energy dependent multiplicities it is better to use the method productAverageMultiplicity.

Parameters

a_index [in] The PoPs index of the requested particle.

Returns: The multiplicity value for the requested particle.

Definition at line 257 of file MCGIDI_reaction.cc.

                                                                      {
 
    std::size_t i1 = 0;
 
    for( Vector<int>::iterator iter = m_productIndices.begin( ); iter != m_productIndices.end( ); ++iter, ++i1 ) {
        if( *iter == a_index ) return( m_productMultiplicities[i1] );
    }
 
    return( 0 );
}

Referenced by productMultiplicities().

◆ productMultiplicityViaIntid()

LUPI_HOST_DEVICE int MCGIDI::Reaction::productMultiplicityViaIntid ( int a_intid ) const

Returns the multiplicity for outgoing particle with pops intid a_intid. If the multiplicity is energy dependent, the returned value is -1. For energy dependent multiplicities it is better to use the method productAverageMultiplicity.

Parameters

a_intid [in] The PoPs intid of the requested particle.

Returns: The multiplicity value for the requested particle.

Definition at line 276 of file MCGIDI_reaction.cc.

                                                                              {
 
    std::size_t i1 = 0;
 
    for( Vector<int>::iterator iter = m_productIntids.begin( ); iter != m_productIntids.end( ); ++iter, ++i1 ) {
        if( *iter == a_intid ) return( m_productMultiplicities[i1] );
    }
 
    return( 0 );
}

◆ projectileMass()

LUPI_HOST_DEVICE double MCGIDI::Reaction::projectileMass ( ) const

inline

Returns the value of the m_projectileMass.

Definition at line 1409 of file MCGIDI.hpp.

◆ protareSingle()

LUPI_HOST_DEVICE ProtareSingle const * MCGIDI::Reaction::protareSingle ( ) const

inline

Returns the value of the m_protareSingle.

Definition at line 1399 of file MCGIDI.hpp.

Referenced by MCGIDI::Distributions::CoherentPhotoAtomicScattering::angleBiasing(), MCGIDI::Distributions::IncoherentBoundToFreePhotoAtomicScattering::angleBiasing(), and MCGIDI::Distributions::IncoherentPhotoAtomicScattering::angleBiasing().

◆ reactionIndex()

LUPI_HOST_DEVICE std::size_t MCGIDI::Reaction::reactionIndex ( ) const

inline

Returns the value of the m_reactionIndex.

Definition at line 1400 of file MCGIDI.hpp.

Referenced by MCGIDI::Distributions::CoherentPhotoAtomicScattering::angleBiasing(), MCGIDI::Distributions::IncoherentBoundToFreePhotoAtomicScattering::angleBiasing(), and MCGIDI::Distributions::IncoherentPhotoAtomicScattering::angleBiasing().

◆ sampleNullProducts()

template<typename RNG, typename PUSHBACK>

LUPI_HOST_DEVICE void MCGIDI::Reaction::sampleNullProducts	(	Protare const &	a_protare,
		double	a_projectileEnergy,
		Sampling::Input &	a_input,
		RNG &&	a_rng,
		PUSHBACK &&	a_push_back,
		Sampling::ProductHandler &	a_products )

inlinestatic

This method adds a null product to a_products. When running in multi-group mode, a sampled reaction may be rejected if the threshold is in the multi-group that the projectile is in. If this happens, only null products should be returned. This type of behavior was need in MCAPM but is probably not needed for MCGIDI.

Parameters

a_protare	[in] The Protare this Reaction belongs to.
a_projectileEnergy	[in] The energy of the projectile.
a_input	[in] Sample options requested by user.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).
a_products	[in] The object to add all sampled products to.

Definition at line 3240 of file MCGIDI_headerSource.hpp.

                                                                                    {
 
    a_input.m_GRIN_intermediateResidual = -1;
    a_input.setSampledType( Sampling::SampledType::uncorrelatedBody );
    a_input.m_dataInTargetFrame = false;
    a_input.m_frame = GIDI::Frame::lab;
    a_input.m_delayedNeutronIndex = -1;
    a_input.m_delayedNeutronDecayRate = 0.0;
 
    a_input.m_energyOut1 = a_projectileEnergy;
    a_input.m_mu = 1.0;
    a_input.m_phi = 0.0;
 
    a_products.add( a_projectileEnergy, a_protare.projectileIntid( ), a_protare.projectileIndex( ), a_protare.projectileUserIndex( ), a_protare.projectileMass( ), a_input, a_rng, a_push_back, false );
}

◆ sampleProducts()

template<typename RNG, typename PUSHBACK>

LUPI_HOST_DEVICE void MCGIDI::Reaction::sampleProducts	(	Protare const *	a_protare,
		Sampling::Input &	a_input,
		RNG &&	a_rng,
		PUSHBACK &&	a_push_back,
		Sampling::ProductHandler &	a_products,
		bool	a_checkOrphanProducts = true ) const

inline

This method adds sampled products to a_products.

Parameters

a_protare	[in] The Protare this Reaction belongs to.
a_input	[in] Sample options requested by user.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).
a_products	[in] The object to add all sampled products to.
a_checkOrphanProducts	[in] If true, associated orphan products are also sampled.

Definition at line 2966 of file MCGIDI_headerSource.hpp.

                                                                                                                              {
 
    double projectileEnergy = a_input.modelEnergy( );
 
    a_input.m_GRIN_intermediateResidual = -1;
    a_input.m_reaction = this;
    a_input.m_projectileMass = m_projectileMass;
    a_input.m_targetMass = m_targetMass;
    a_input.m_relativeBeta = MCGIDI_particleBeta( m_projectileMass, projectileEnergy );
 
    if( m_GRIN_specialSampleProducts ) {
        if( m_GRIN_capture != nullptr ) {
            if( projectileEnergy < m_GRIN_maximumCaptureIncidentEnergy ) {
                if( m_GRIN_capture->sampleProducts( (ProtareSingle const *) a_protare, projectileEnergy, a_input, a_rng, a_push_back, a_products ) ) {
                    return;
                }
            } }
        else if( m_GRIN_inelastic != nullptr ) {
            if( m_GRIN_inelastic->sampleProducts( (ProtareSingle const *) a_protare, projectileEnergy, a_input, a_rng, a_push_back, a_products ) ) {
                return;
            }
        }
    }
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    m_outputChannel->sampleProducts( m_protareSingle, projectileEnergy, a_input, a_rng, a_push_back, a_products );
#else
    if( m_hasFinalStatePhotons ) {
        double random = a_rng( );
        double cumulative = 0.0;
        bool sampled = false;
        for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
            cumulative += (*productIter)->multiplicity( )->evaluate( projectileEnergy );
            if( cumulative >= random ) {
                (*productIter)->sampleFinalState( m_protareSingle, projectileEnergy, a_input, a_rng, a_push_back, a_products );
                sampled = true;
                break;
            }
        }
        if( !sampled ) {     // BRB: FIXME: still need to code for continuum photon.
        } }
    else {
        for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
            (*productIter)->sampleProducts( m_protareSingle, projectileEnergy, a_input, a_rng, a_push_back, a_products );
        }
    }
 
    if( m_totalDelayedNeutronMultiplicity != nullptr ) {
        double totalDelayedNeutronMultiplicity = m_totalDelayedNeutronMultiplicity->evaluate( projectileEnergy );
 
        if( a_rng( ) < totalDelayedNeutronMultiplicity ) {       // Assumes that totalDelayedNeutronMultiplicity < 1.0, which it is.
            double sum = 0.0;
 
            totalDelayedNeutronMultiplicity *= a_rng( );
            for( std::size_t i1 = 0; i1 < (std::size_t) m_delayedNeutrons.size( ); ++i1 ) {
                DelayedNeutron const *delayedNeutron1 = m_delayedNeutrons[i1];
                Product const &product = delayedNeutron1->product( );
 
                sum += product.multiplicity( )->evaluate( projectileEnergy );
                if( sum >= totalDelayedNeutronMultiplicity ) {
                    product.distribution( )->sample( projectileEnergy, a_input, a_rng );
                    a_input.m_delayedNeutronIndex = delayedNeutron1->delayedNeutronIndex( );
                    a_input.m_delayedNeutronDecayRate = delayedNeutron1->rate( );
                    a_products.add( a_input.energy( ), product.intid( ), product.index( ), product.userParticleIndex( ), product.mass( ), a_input, a_rng, a_push_back, false );
                    break;
                }
            }
        }
    }
 
    if( m_fissionResiduaIntid != -1 ) {             // Special treatment to add 2 ENDL 99120 or 99125 products.
        a_input.setSampledType( MCGIDI::Sampling::SampledType::unspecified );
        a_input.m_frame = GIDI::Frame::lab;
        a_input.m_energyOut1 = 0.0;
        a_input.m_mu = 0.0;
        a_input.m_phi = 0.0;
        a_input.m_delayedNeutronIndex = -1;
        a_input.m_delayedNeutronDecayRate = 0.0;
        a_products.add( 0.0, m_fissionResiduaIntid, m_fissionResiduaIndex, m_fissionResiduaUserIndex, m_fissionResidualMass, a_input, a_rng, a_push_back, false );
        a_products.add( 0.0, m_fissionResiduaIntid, m_fissionResiduaIndex, m_fissionResiduaUserIndex, m_fissionResidualMass, a_input, a_rng, a_push_back, false );
    }
 
#endif
 
    if( a_checkOrphanProducts ) {
        for( auto productIter = m_associatedOrphanProducts.begin( ); productIter != m_associatedOrphanProducts.end( ); ++productIter ) {
            (*productIter)->sampleProducts( m_protareSingle, projectileEnergy, a_input, a_rng, a_push_back, a_products );
        }
    }
}

◆ serialize()

LUPI_HOST_DEVICE void MCGIDI::Reaction::serialize	(	LUPI::DataBuffer &	a_buffer,
		LUPI::DataBuffer::Mode	a_mode )

This method serializes this for broadcasting as needed for MPI and GPUs. The method can count the number of required bytes, pack this or unpack this depending on a_mode.

Parameters

a_buffer	[in] The buffer to read or write data to depending on a_mode.
a_mode	[in] Specifies the action of this method.

Definition at line 530 of file MCGIDI_reaction.cc.

                                                                                               {
    
    DATA_MEMBER_SIZE_T( m_GIDI_reactionIndex, a_buffer, a_mode );
    DATA_MEMBER_STRING( m_label, a_buffer, a_mode );
    DATA_MEMBER_INT( m_ENDF_MT, a_buffer, a_mode );
    DATA_MEMBER_INT( m_ENDL_C, a_buffer, a_mode );
    DATA_MEMBER_INT( m_ENDL_S, a_buffer, a_mode );
    DATA_MEMBER_INT( m_initialStateIndex, a_buffer, a_mode );
    DATA_MEMBER_INT( m_neutronIndex, a_buffer, a_mode );
    DATA_MEMBER_CAST( m_hasFission, a_buffer, a_mode, bool );
    DATA_MEMBER_DOUBLE( m_projectileMass, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_targetMass, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_crossSectionThreshold, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_twoBodyThreshold, a_buffer, a_mode );
    DATA_MEMBER_CAST( m_hasFinalStatePhotons, a_buffer, a_mode, bool );
    DATA_MEMBER_INT( m_fissionResiduaIntid, a_buffer, a_mode );
    DATA_MEMBER_INT( m_fissionResiduaIndex, a_buffer, a_mode );
    DATA_MEMBER_INT( m_fissionResiduaUserIndex, a_buffer, a_mode );
    serializeFissionResiduals( m_fissionResiduals, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_fissionResidualMass, a_buffer, a_mode );
 
    DATA_MEMBER_VECTOR_INT( m_productIntids, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_INT( m_productIndices, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_INT( m_userProductIndices, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_INT( m_productMultiplicities, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_INT( m_productIntidsTransportable, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_INT( m_productIndicesTransportable, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_INT( m_userProductIndicesTransportable, a_buffer, a_mode );
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    bool haveChannel = m_outputChannel != nullptr;
    DATA_MEMBER_CAST( haveChannel, a_buffer, a_mode, bool );
    if( haveChannel ) {
        if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
            if (a_buffer.m_placement != nullptr) {
                m_outputChannel = new(a_buffer.m_placement) OutputChannel();
                a_buffer.incrementPlacement( sizeof(OutputChannel));
            }
            else {
                m_outputChannel = new OutputChannel();
            } }
        else if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
            a_buffer.incrementPlacement( sizeof( OutputChannel ) );
        }
        m_outputChannel->serialize( a_buffer, a_mode );
    }
#else
    serializeQs( a_buffer, a_mode, m_Qs );
    serializeProducts( a_buffer, a_mode, m_products );
    m_totalDelayedNeutronMultiplicity = serializeFunction1d( a_buffer, a_mode, m_totalDelayedNeutronMultiplicity );
    serializeDelayedNeutrons( a_buffer, a_mode, m_delayedNeutrons );
#endif
 
    DATA_MEMBER_VECTOR_SIZE_T( m_associatedOrphanProductIndices, a_buffer, a_mode );
 
    std::size_t vectorSize = m_associatedOrphanProducts.size( );
    int vectorSizeInt = (int) vectorSize;
    DATA_MEMBER_INT( vectorSizeInt, a_buffer, a_mode );
    vectorSize = (std::size_t) vectorSizeInt;
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
        m_associatedOrphanProducts.reserve( vectorSize, &a_buffer.m_placement ); }
    else if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
        a_buffer.m_placement += m_associatedOrphanProducts.internalSize( );
    }
 
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
        m_protareSingle = nullptr;
        m_reactionIndex = MCGIDI_nullReaction;
    }
 
    DATA_MEMBER_CAST( m_GRIN_specialSampleProducts, a_buffer, a_mode, bool );
    DATA_MEMBER_DOUBLE( m_GRIN_inelasticThreshold, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_GRIN_maximumCaptureIncidentEnergy, a_buffer, a_mode );
 
    if( m_GRIN_specialSampleProducts ) {
        if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
            if( a_buffer.m_placement != nullptr ) {
                if( m_ENDF_MT == 91 ) {
                    m_GRIN_inelastic = new(a_buffer.m_placement) GRIN_inelastic;
                    a_buffer.incrementPlacement( sizeof( GRIN_inelastic ) ); }
                else {
                    m_GRIN_capture = new(a_buffer.m_placement) GRIN_capture;
                    a_buffer.incrementPlacement( sizeof( GRIN_capture ) );
                } }
            else {
                if( m_ENDF_MT == 91 ) {
                    m_GRIN_inelastic = new GRIN_inelastic( ); }
                else {
                    m_GRIN_capture = new GRIN_capture( );
                }
            }
        }
 
        if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
            if( m_ENDF_MT == 91 ) {
                a_buffer.incrementPlacement( sizeof( GRIN_inelastic ) ); }
            else {
                a_buffer.incrementPlacement( sizeof( GRIN_capture ) );
            }
        }
 
        if( m_ENDF_MT == 91 ) {
            m_GRIN_inelastic->serialize( a_buffer, a_mode ); }
        else {
            m_GRIN_capture->serialize( a_buffer, a_mode );
        }
    }
}

◆ setModelDBRC_data()

LUPI_HOST void MCGIDI::Reaction::setModelDBRC_data ( Sampling::Upscatter::ModelDBRC_data * a_modelDBRC_data )

This method calls the **setModelDBRC_data* method on the first product of this with a_modelDBRC_data.

Parameters

a_modelDBRC_data [in] The instance storing data needed to treat the DRRC upscatter mode.

Definition at line 445 of file MCGIDI_reaction.cc.

                                                                                              {
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    m_outputChannel->setModelDBRC_data( a_modelDBRC_data );
#else
    m_products[0]->setModelDBRC_data( a_modelDBRC_data );
#endif
}

◆ setOrphanProductData()

LUPI_HOST void MCGIDI::Reaction::setOrphanProductData	(	std::vector< std::size_t > const &	a_associatedOrphanProductIndcies,
		std::vector< Product * > const &	a_associatedOrphanProducts )

Adds the contents of a_associatedOrphanProductIndcies and a_associatedOrphanProducts to this instance.

Parameters

a_associatedOrphanProductIndcies	[in] The list of indices of the orphanProduct reaction that make up the product in a_associatedOrphanProducts.
a_associatedOrphanProducts	[in] The list of pointers to the associated orphan products.

Definition at line 510 of file MCGIDI_reaction.cc.

                                                                         {
 
    m_associatedOrphanProductIndices.reserve( a_associatedOrphanProductIndcies.size( ) );
    for( auto iter = a_associatedOrphanProductIndcies.begin( ); iter != a_associatedOrphanProductIndcies.end( ); ++iter )
        m_associatedOrphanProductIndices.push_back( *iter );
 
    m_associatedOrphanProducts.reserve( a_associatedOrphanProducts.size( ) );
    for( auto iter = a_associatedOrphanProducts.begin( ); iter != a_associatedOrphanProducts.end( ); ++iter )
        m_associatedOrphanProducts.push_back( *iter );
}

◆ setUserParticleIndex()

LUPI_HOST void MCGIDI::Reaction::setUserParticleIndex	(	int	a_particleIndex,
		int	a_userParticleIndex )

Updates the m_userParticleIndex to a_userParticleIndex for all particles with PoPs index a_particleIndex.

Parameters

a_particleIndex	[in] The PoPs index of the particle whose user index is to be set.
a_userParticleIndex	[in] The particle index specified by the user.

Definition at line 378 of file MCGIDI_reaction.cc.

                                                                                            {
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    m_outputChannel->setUserParticleIndex( a_particleIndex, a_userParticleIndex );
#else
    for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
        (*productIter)->setUserParticleIndex( a_particleIndex, a_userParticleIndex );
    }
 
    for( auto iter = m_delayedNeutrons.begin( ); iter != m_delayedNeutrons.end( ); ++iter ) 
        (*iter)->setUserParticleIndex( a_particleIndex, a_userParticleIndex );
#endif
 
    for( std::size_t i1 = 0; i1 < m_productIndices.size( ); ++i1 ) {
        if( m_productIndices[i1] == a_particleIndex ) m_userProductIndices[i1] = a_userParticleIndex;
    }
 
    for( std::size_t i1 = 0; i1 < m_productIndicesTransportable.size( ); ++i1 ) {
        if( m_productIndicesTransportable[i1] == a_particleIndex ) m_userProductIndicesTransportable[i1] = a_userParticleIndex;
    }
 
    if( a_particleIndex == m_fissionResiduaIndex ) m_fissionResiduaUserIndex = a_userParticleIndex;
 
    if( m_GRIN_capture != nullptr ) m_GRIN_capture->setUserParticleIndex( a_particleIndex, a_userParticleIndex );
    if( m_GRIN_inelastic != nullptr ) m_GRIN_inelastic->setUserParticleIndex( a_particleIndex, a_userParticleIndex );
}

◆ setUserParticleIndexViaIntid()

LUPI_HOST void MCGIDI::Reaction::setUserParticleIndexViaIntid	(	int	a_particleIntid,
		int	a_userParticleIndex )

Updates the m_userParticleIndex to a_userParticleIndex for all particles with PoPs index a_particleIntid.

Parameters

a_particleIndex	[in] The PoPs intid of the particle whose user intid is to be set.
a_userParticleIndex	[in] The particle index specified by the user.

Definition at line 412 of file MCGIDI_reaction.cc.

                                                                                                    {
 
#ifdef MCGIDI_USE_OUTPUT_CHANNEL
    m_outputChannel->setUserParticleIndexViaIntid( a_particleIntid, a_userParticleIndex );
#else
    for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
        (*productIter)->setUserParticleIndexViaIntid( a_particleIntid, a_userParticleIndex );
    }
 
    for( auto iter = m_delayedNeutrons.begin( ); iter != m_delayedNeutrons.end( ); ++iter )
        (*iter)->setUserParticleIndexViaIntid( a_particleIntid, a_userParticleIndex );
#endif
 
    for( std::size_t i1 = 0; i1 < m_productIntids.size( ); ++i1 ) {
        if( m_productIntids[i1] == a_particleIntid ) m_userProductIndices[i1] = a_userParticleIndex;
    }
 
    for( std::size_t i1 = 0; i1 < m_productIntidsTransportable.size( ); ++i1 ) {
        if( m_productIntidsTransportable[i1] == a_particleIntid ) m_userProductIndicesTransportable[i1] = a_userParticleIndex;
    }
 
    if( a_particleIntid == m_fissionResiduaIntid ) m_fissionResiduaUserIndex = a_userParticleIndex;
 
    if( m_GRIN_capture != nullptr ) m_GRIN_capture->setUserParticleIndexViaIntid( a_particleIntid, a_userParticleIndex );
    if( m_GRIN_inelastic != nullptr ) m_GRIN_inelastic->setUserParticleIndexViaIntid( a_particleIntid, a_userParticleIndex );
}

◆ targetMass()

LUPI_HOST_DEVICE double MCGIDI::Reaction::targetMass ( ) const

inline

Returns the value of the m_targetMass.

Definition at line 1410 of file MCGIDI.hpp.

◆ twoBodyThreshold()

LUPI_HOST_DEVICE double MCGIDI::Reaction::twoBodyThreshold ( ) const

inline

Returns the value of the m_twoBodyThreshold member.

Definition at line 1412 of file MCGIDI.hpp.

◆ updateProtareSingleInfo()

LUPI_HOST_DEVICE void MCGIDI::Reaction::updateProtareSingleInfo	(	ProtareSingle *	a_protareSingle,
		std::size_t	a_reactionIndex )

inline

Definition at line 1395 of file MCGIDI.hpp.

                                                                                                                          {
                m_protareSingle = a_protareSingle;
                m_reactionIndex = a_reactionIndex;
        }

◆ userProductIndices()

LUPI_HOST_DEVICE Vector< int > const & MCGIDI::Reaction::userProductIndices ( ) const

inline

Returns a const reference to the m_productIndices member.

Definition at line 1420 of file MCGIDI.hpp.

◆ userProductIndicesTransportable()

LUPI_HOST_DEVICE Vector< int > const & MCGIDI::Reaction::userProductIndicesTransportable ( ) const

inline

Definition at line 1434 of file MCGIDI.hpp.

1434{ return( m_userProductIndicesTransportable ); }

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Reaction() [1/2]

◆ Reaction() [2/2]

◆ ~Reaction()

Member Function Documentation

◆ addOrphanProductToProductList() [1/3]

◆ addOrphanProductToProductList() [2/3]

◆ addOrphanProductToProductList() [3/3]

◆ angleBiasing()

◆ angleBiasingViaIntid()

◆ associatedOrphanProductIndices()

◆ crossSection() [1/2]

◆ crossSection() [2/2]

◆ crossSectionAsGIDI_XYs1d()

◆ crossSectionThreshold()

◆ ENDF_MT()

◆ ENDL_C()

◆ ENDL_S()

◆ finalQ()

◆ GIDI_reactionIndex()

◆ hasFission()

◆ initialStateIndex()

◆ label()

◆ numberOfProducts()

◆ product()

◆ productAverageMultiplicity()

◆ productAverageMultiplicityViaIntid()

◆ productIndices()

◆ productIndicesTransportable()

◆ productIntids()

◆ productIntidsTransportable()

◆ productMultiplicities()

◆ productMultiplicity()

◆ productMultiplicityViaIntid()

◆ projectileMass()

◆ protareSingle()

◆ reactionIndex()

◆ sampleNullProducts()

◆ sampleProducts()

◆ serialize()

◆ setModelDBRC_data()

◆ setOrphanProductData()

◆ setUserParticleIndex()

◆ setUserParticleIndexViaIntid()

◆ targetMass()

◆ twoBodyThreshold()

◆ updateProtareSingleInfo()

◆ userProductIndices()

◆ userProductIndicesTransportable()