MCGIDI::GRIN_inelastic Class Reference

#include <MCGIDI.hpp>

Public Member Functions
LUPI_HOST_DEVICE	GRIN_inelastic ()
LUPI_HOST	GRIN_inelastic (SetupInfo &a_setupInfo, GIDI::GRIN::GRIN_continuumGammas const &GRIN_continuumGammas)
LUPI_HOST_DEVICE	~GRIN_inelastic ()
LUPI_HOST void	setUserParticleIndex (int a_particleIndex, int a_userParticleIndex)
LUPI_HOST void	setUserParticleIndexViaIntid (int a_particleIntid, int a_userParticleIndex)
template<typename RNG, typename PUSHBACK>
LUPI_HOST_DEVICE bool	sampleProducts (ProtareSingle const *a_protare, double a_projectileEnergy, Sampling::Input &a_input, RNG &&a_rng, PUSHBACK &&a_push_back, Sampling::ProductHandler &a_products) const
LUPI_HOST_DEVICE void	serialize (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)

Detailed Description

This class represents GRIN inelastic continuum reaction data which has simulated levels.

Definition at line 1055 of file MCGIDI.hpp.

Constructor & Destructor Documentation

GRIN_inelastic() [1/2]

LUPI_HOST_DEVICE MCGIDI::GRIN_inelastic::GRIN_inelastic

(

)

Definition at line 195 of file MCGIDI_GRIN.cc.

                                                 {
 
}

Referenced by GRIN_inelastic(), and GRIN_inelastic().

GRIN_inelastic() [2/2]

LUPI_HOST MCGIDI::GRIN_inelastic::GRIN_inelastic	(	SetupInfo &	a_setupInfo,
		GIDI::GRIN::GRIN_continuumGammas const &	GRIN_continuumGammas )

Parameters

a_setupInfo	[in] Used internally when constructing a Protare to pass information to other constructors.
GRIN_continuumGammas	[in] GIDI instance containing the GRIN capture data.

Definition at line 204 of file MCGIDI_GRIN.cc.

                                                                                                                           :
        m_neutronIndex( a_setupInfo.m_neutronIndex ),
        m_neutronUserParticleIndex( -1 ),
        m_neutronMass( a_setupInfo.m_protare.projectileMass( ) ),
 
        m_targetIntid( a_setupInfo.m_protare.targetIntid( ) ),
        m_targetIndex( a_setupInfo.m_protare.targetIndex( ) ),
        m_targetUserParticleIndex( -1 ),
        m_targetMass( a_setupInfo.m_protare.targetMass( ) ) {
 
    PoPI::Database const &pops = GRIN_continuumGammas.pops( );
    GIDI::Suite const &inelasticIncidentEnergies = GRIN_continuumGammas.inelasticIncidentEnergies( );
    m_energies.reserve( inelasticIncidentEnergies.size( ) );
    m_inelasticForEnergy.reserve( inelasticIncidentEnergies.size( ) );
    for( std::size_t index = 0; index < inelasticIncidentEnergies.size( ); ++index ) {
 
        GIDI::GRIN::InelasticIncidentEnergy const *inelasticIncidentEnergy = inelasticIncidentEnergies.get<GIDI::GRIN::InelasticIncidentEnergy>( index );
 
        m_energies.push_back( inelasticIncidentEnergy->energy( ) );
        m_inelasticForEnergy.push_back( new GRIN_inelasticForEnergy( a_setupInfo, m_neutronMass, m_targetMass, pops, inelasticIncidentEnergy ) );
    }
}

~GRIN_inelastic()

LUPI_HOST_DEVICE MCGIDI::GRIN_inelastic::~GRIN_inelastic

(

)

Definition at line 230 of file MCGIDI_GRIN.cc.

                                                  {
 
    for( auto iter = m_inelasticForEnergy.begin( ); iter != m_inelasticForEnergy.end( ); ++iter ) delete *iter;
}

Member Function Documentation

sampleProducts()

template<typename RNG, typename PUSHBACK>

LUPI_HOST_DEVICE bool MCGIDI::GRIN_inelastic::sampleProducts ( ProtareSingle const * a_protare, double a_projectileEnergy, Sampling::Input & a_input, RNG && a_rng, PUSHBACK && a_push_back, Sampling::ProductHandler & a_products ) const

inline

This method adds sampled products to a_products.

Parameters

a_protare	[in] The ProtareSingle 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 3119 of file MCGIDI_headerSource.hpp.

                                                                                                  {
 
    std::size_t index = 1;
    for( ; index < m_energies.size( ); ++index ) {
        if( m_energies[index] > a_projectileEnergy ) break;
    }
    --index;
 
    GRIN_inelasticForEnergy *inelasticForEnergy = m_inelasticForEnergy[index];
    int levelIndex = inelasticForEnergy->sampleLevelIndex( a_projectileEnergy, a_rng( ) );
    if( levelIndex < 0 ) return( false );
 
    NuclideGammaBranchStateInfo const *nuclideGammaBranchStateInfo = a_protare->nuclideGammaBranchStateInfos( )[static_cast<std::size_t>(levelIndex)];
 
    a_input.m_GRIN_intermediateResidual = nuclideGammaBranchStateInfo->intid( );
 
    double residualMass = m_targetMass + nuclideGammaBranchStateInfo->nuclearLevelEnergy( );
    double initialMass = m_neutronMass + m_targetMass;
    double finalMass = m_neutronMass + residualMass;
    double twoBodyThreshold = 0.5 * ( finalMass * finalMass - initialMass * initialMass ) / m_targetMass;
    double betaBoast = sqrt( a_projectileEnergy * ( a_projectileEnergy + 2. * m_neutronMass ) ) 
            / ( a_projectileEnergy + m_neutronMass + m_targetMass );      // betaBoast = v/c.
    double _x = m_targetMass * ( a_projectileEnergy - twoBodyThreshold ) / ( finalMass * finalMass );
    if( _x < 0 ) _x = 0.;           // FIXME There needs to be a better test here.
    double Kp;
    if( _x < 2e-5 ) {
        Kp = finalMass * _x * ( 1 - 0.5 * _x * ( 1 - _x ) ); }
    else {          // This is the relativistic formula derived from E^2 - (pc)^2 is frame independent.
        Kp = sqrt( finalMass * finalMass + 2 * m_targetMass * ( a_projectileEnergy - twoBodyThreshold ) ) - finalMass;
    }
    if( Kp < 0 ) Kp = 0.;           // FIXME There needs to be a better test here.
 
    a_input.setSampledType( Sampling::SampledType::firstTwoBody );
    a_input.m_mu = 1.0 - 2.0 * a_rng( );
    a_input.m_phi = 2. * M_PI * a_rng( );
    kinetics_COMKineticEnergy2LabEnergyAndMomentum( betaBoast, Kp, m_neutronMass, residualMass, a_input );
 
    a_input.m_delayedNeutronIndex = -1;
    a_input.m_delayedNeutronDecayRate = 0.0;
    a_products.add( a_projectileEnergy, PoPI::Intids::neutron, m_neutronIndex, m_neutronUserParticleIndex, m_neutronMass, a_input, a_rng, 
            a_push_back, false );
    a_products.add( a_projectileEnergy, m_targetIntid, m_targetIndex, m_targetUserParticleIndex, 
            m_targetMass, a_input, a_rng, a_push_back, false );
 
    a_protare->sampleBranchingGammas( a_input, a_projectileEnergy, levelIndex, a_rng, a_push_back, a_products );
 
    return( true );
}

serialize()

LUPI_HOST_DEVICE void MCGIDI::GRIN_inelastic::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 269 of file MCGIDI_GRIN.cc.

                                                                                                     {
 
    DATA_MEMBER_INT( m_neutronIndex, a_buffer, a_mode );
    DATA_MEMBER_INT( m_neutronUserParticleIndex, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_neutronMass, a_buffer, a_mode );
 
    DATA_MEMBER_INT( m_targetIntid, a_buffer, a_mode );
    DATA_MEMBER_INT( m_targetIndex, a_buffer, a_mode );
    DATA_MEMBER_INT( m_targetUserParticleIndex, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_targetMass, a_buffer, a_mode );
 
    DATA_MEMBER_VECTOR_DOUBLE( m_energies, a_buffer, a_mode );
 
    std::size_t vectorSize = m_inelasticForEnergy.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_inelasticForEnergy.resize( vectorSize, &a_buffer.m_placement );
        for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
            if( a_buffer.m_placement != nullptr ) {
                m_inelasticForEnergy[vectorIndex] = new(a_buffer.m_placement) GRIN_inelasticForEnergy;
                a_buffer.incrementPlacement( sizeof( GRIN_inelasticForEnergy ) ); }
            else {
               m_inelasticForEnergy[vectorIndex] = new GRIN_inelasticForEnergy;
            }
        } }
    else if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
        a_buffer.m_placement += m_inelasticForEnergy.internalSize( );
        a_buffer.incrementPlacement( sizeof( GRIN_inelasticForEnergy ) * vectorSize );
    }
 
    for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
        m_inelasticForEnergy[vectorIndex]->serialize( a_buffer, a_mode );
    }
}

setUserParticleIndex()

LUPI_HOST void MCGIDI::GRIN_inelastic::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 242 of file MCGIDI_GRIN.cc.

                                                                                                  {
 
    if( m_neutronIndex == a_particleIndex ) m_neutronUserParticleIndex = a_userParticleIndex;
    if( m_targetIndex == a_particleIndex ) m_targetUserParticleIndex = a_userParticleIndex;
}

setUserParticleIndexViaIntid()

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

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

Parameters

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

Definition at line 255 of file MCGIDI_GRIN.cc.

                                                                                                          {
 
    if( PoPI::Intids::neutron == a_particleIntid ) m_neutronUserParticleIndex = a_userParticleIndex;
    if( m_targetIntid == a_particleIntid ) m_targetUserParticleIndex = a_userParticleIndex;
}

---

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

• MCGIDI.hpp
• MCGIDI_headerSource.hpp
• MCGIDI_GRIN.cc