MCGIDI::GRIN_capture Class Reference

#include <MCGIDI.hpp>

Public Member Functions
LUPI_HOST_DEVICE	GRIN_capture ()
LUPI_HOST	GRIN_capture (SetupInfo &a_setupInfo, GIDI::GRIN::GRIN_continuumGammas const &GRIN_continuumGammas)
LUPI_HOST_DEVICE	~GRIN_capture ()
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

Thiis class represents GRIN capture continuum reaction data which has simulated (i.e., modelled) levels.

Definition at line 1144 of file MCGIDI.hpp.

Constructor & Destructor Documentation

GRIN_capture() [1/2]

LUPI_HOST_DEVICE MCGIDI::GRIN_capture::GRIN_capture

(

)

Definition at line 445 of file MCGIDI_GRIN.cc.

                                             :
        m_captureNeutronSeparationEnergy( 0.0 ),
        m_residualIntid( -1 ),
        m_residualIndex( -1 ),
        m_residualUserIndex( -1 ),
        m_residualMass( 0.0 ) {
 
}

GRIN_capture() [2/2]

LUPI_HOST MCGIDI::GRIN_capture::GRIN_capture	(	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 459 of file MCGIDI_GRIN.cc.

                                                                                                                       :
        m_captureNeutronSeparationEnergy( GRIN_continuumGammas.captureNeutronSeparationEnergy( ).value( ) ),
        m_residualIntid( GRIN_continuumGammas.captureResidualIntid( ) ),
        m_residualIndex( GRIN_continuumGammas.captureResidualIndex( ) ),
        m_residualUserIndex( -1 ),
        m_residualMass( GRIN_continuumGammas.captureResidualMass( ) ) {
 
    PoPI::Database const &pops = GRIN_continuumGammas.pops( );
    GIDI::Suite const &captureLevelProbabilities = GRIN_continuumGammas.captureLevelProbabilities( );
 
    m_summedProbabilities.reserve( captureLevelProbabilities.size( ) );
    m_captureLevelProbabilities.reserve( captureLevelProbabilities.size( ) );
    double sum = 0.0;
    for( std::size_t index = 0; index < captureLevelProbabilities.size( ); ++index ) {
        GIDI::GRIN::CaptureLevelProbability const *captureLevelProbability = captureLevelProbabilities.get<GIDI::GRIN::CaptureLevelProbability const>( 0 );
 
        sum += captureLevelProbability->probabilty( );
        m_summedProbabilities.push_back( sum );
        m_captureLevelProbabilities.push_back( new GRIN_captureLevelProbability( a_setupInfo, pops, captureLevelProbability ) );
    }
}

~GRIN_capture()

LUPI_HOST_DEVICE MCGIDI::GRIN_capture::~GRIN_capture

(

)

Definition at line 484 of file MCGIDI_GRIN.cc.

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

Member Function Documentation

sampleProducts()

template<typename RNG, typename PUSHBACK>

LUPI_HOST_DEVICE bool MCGIDI::GRIN_capture::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 3069 of file MCGIDI_headerSource.hpp.

                                                                                                  {
 
    std::size_t index = 0;
    double random = a_rng( );
    for( ; index < m_summedProbabilities.size( ) - 1; ++index ) {
        if( random < m_summedProbabilities[index] ) break;
    }
    GRIN_captureLevelProbability *GRIN_captureLevelProbability1 = m_captureLevelProbabilities[index];
 
    double availableEnergy = m_captureNeutronSeparationEnergy + a_projectileEnergy;
    int primaryCaptureLevelIndex = GRIN_captureLevelProbability1->sampleCaptureLevel( a_protare, availableEnergy, a_rng );
    NuclideGammaBranchStateInfo const *nuclideGammaBranchStateInfo = a_protare->nuclideGammaBranchStateInfos( )[static_cast<std::size_t>(primaryCaptureLevelIndex)];
 
    a_input.m_GRIN_intermediateResidual = nuclideGammaBranchStateInfo->intid( );
 
    a_input.setSampledType( Sampling::SampledType::photon );
    a_input.m_dataInTargetFrame = false;
    a_input.m_frame = GIDI::Frame::lab;
 
    a_input.m_energyOut1 = availableEnergy - nuclideGammaBranchStateInfo->nuclearLevelEnergy( );
    a_input.m_mu = 2 * a_rng( ) - 1.0;
    a_input.m_phi = 2.0 * M_PI * a_rng( );
 
    a_products.add( a_projectileEnergy, PoPI::Intids::photon, a_protare->photonIndex( ), a_protare->userPhotonIndex( ), 
            0.0, a_input, a_rng, a_push_back, true );
 
    a_protare->sampleBranchingGammas( a_input, a_projectileEnergy, primaryCaptureLevelIndex, a_rng, a_push_back, a_products );
 
    if( m_residualIntid != -1 ) {
        a_input.m_energyOut1 = 0.0;
        a_input.m_mu = 0.0;
        a_input.m_phi = 0.0;
        a_products.add( a_projectileEnergy, m_residualIntid, m_residualIndex, m_residualUserIndex, m_residualMass, a_input, a_rng, a_push_back, false );
    }
 
    return( true );
}

serialize()

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

                                                                                                   {
 
    DATA_MEMBER_DOUBLE( m_captureNeutronSeparationEnergy, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_DOUBLE( m_summedProbabilities, a_buffer, a_mode );
    DATA_MEMBER_INT( m_residualIntid, a_buffer, a_mode );
    DATA_MEMBER_INT( m_residualIndex, a_buffer, a_mode );
    DATA_MEMBER_INT( m_residualUserIndex, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_residualMass, a_buffer, a_mode );
 
    std::size_t vectorSize = m_captureLevelProbabilities.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_captureLevelProbabilities.resize( vectorSize, &a_buffer.m_placement );
        for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
            if( a_buffer.m_placement != nullptr ) {
                m_captureLevelProbabilities[vectorIndex] = new(a_buffer.m_placement) GRIN_captureLevelProbability;
                a_buffer.incrementPlacement( sizeof( GRIN_captureLevelProbability ) ); }
            else {
               m_captureLevelProbabilities[vectorIndex] = new GRIN_captureLevelProbability;
            }
        } }
    else if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
        a_buffer.m_placement += m_captureLevelProbabilities.internalSize( );
        a_buffer.incrementPlacement( sizeof( GRIN_captureLevelProbability ) * vectorSize );
    }
 
    for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
        m_captureLevelProbabilities[vectorIndex]->serialize( a_buffer, a_mode );
    }
}

setUserParticleIndex()

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

                                                                                                {
 
    if( m_residualIndex == a_particleIndex ) m_residualUserIndex = a_userParticleIndex;
}

setUserParticleIndexViaIntid()

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

                                                                                                        {
 
    if( m_residualIntid == a_particleIntid ) m_residualUserIndex = a_userParticleIndex;
}

---

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

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