#include <MCGIDI.hpp>

Public Member Functions
LUPI_HOST_DEVICE	HeatedCrossSectionsMultiGroup ()
LUPI_HOST_DEVICE	~HeatedCrossSectionsMultiGroup ()
LUPI_HOST_DEVICE double	minimumEnergy () const
LUPI_HOST_DEVICE double	maximumEnergy () const
LUPI_HOST_DEVICE Vector< double > const &	temperatures () const
LUPI_HOST void	update (LUPI::StatusMessageReporting &a_smr, GIDI::ProtareSingle const &a_protare, SetupInfo &a_setupInfo, Transporting::MC const &a_settings, GIDI::Transporting::Particles const &a_particles, GIDI::Styles::TemperatureInfos const &a_temperatureInfos, std::vector< GIDI::Reaction const * > const &a_reactions, std::vector< GIDI::Reaction const * > const &a_orphanProducts, bool a_zeroReactions, GIDI::ExcludeReactionsSet const &a_reactionsToExclude)
LUPI_HOST_DEVICE int	multiGroupThresholdIndex (std::size_t a_index) const
LUPI_HOST_DEVICE Vector< double > const &	projectileMultiGroupBoundariesCollapsed () const
LUPI_HOST_DEVICE Vector< HeatedCrossSectionMultiGroup * > const &	heatedCrossSections () const
LUPI_HOST_DEVICE double	threshold (std::size_t a_index) const
LUPI_HOST_DEVICE double	crossSection (std::size_t a_hashIndex, double a_temperature, bool a_sampling=false) const
LUPI_HOST_DEVICE void	crossSectionVector (double a_temperature, double a_userFactor, std::size_t a_numberAllocated, double *a_crossSectionVector) const
LUPI_HOST_DEVICE double	reactionCrossSection (std::size_t a_reactionIndex, std::size_t a_hashIndex, double a_temperature, bool a_sampling=false) const
LUPI_HOST_DEVICE double	reactionCrossSection (std::size_t a_reactionIndex, double a_temperature, double a_energy_in) const
template<typename RNG>
LUPI_HOST_DEVICE std::size_t	sampleReaction (std::size_t a_hashIndex, double a_temperature, double a_energy_in, double a_crossSection, RNG &&rng) const
LUPI_HOST_DEVICE double	depositionEnergy (std::size_t a_hashIndex, double a_temperature) const
LUPI_HOST_DEVICE double	depositionMomentum (std::size_t a_hashIndex, double a_temperature) const
LUPI_HOST_DEVICE double	productionEnergy (std::size_t a_hashIndex, double a_temperature) const
LUPI_HOST_DEVICE double	gain (std::size_t a_hashIndex, double a_temperature, int a_particleIndex) const
LUPI_HOST_DEVICE double	gainViaIntid (std::size_t a_hashIndex, double a_temperature, int a_particleIntid) const
LUPI_HOST void	setUserParticleIndex (int a_particleIndex, int a_userParticleIndex)
LUPI_HOST void	setUserParticleIndexViaIntid (int a_particleIntid, int a_userParticleIndex)
LUPI_HOST_DEVICE void	serialize (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)
LUPI_HOST void	write (FILE *a_file, int a_temperatureIndex) const
LUPI_HOST void	print () const

Detailed Description

Definition at line 881 of file MCGIDI.hpp.

Constructor & Destructor Documentation

◆ HeatedCrossSectionsMultiGroup()

LUPI_HOST_DEVICE MCGIDI::HeatedCrossSectionsMultiGroup::HeatedCrossSectionsMultiGroup ( )

Generic constructor.

Definition at line 1889 of file MCGIDI_heatedCrossSections.cc.

                                                                               {
 
}

Referenced by HeatedCrossSectionsMultiGroup().

◆ ~HeatedCrossSectionsMultiGroup()

LUPI_HOST_DEVICE MCGIDI::HeatedCrossSectionsMultiGroup::~HeatedCrossSectionsMultiGroup ( )

Generic constructor.

Definition at line 1897 of file MCGIDI_heatedCrossSections.cc.

                                                                                {
 
    for( Vector<HeatedCrossSectionMultiGroup *>::const_iterator iter = m_heatedCrossSections.begin( ); iter != m_heatedCrossSections.end( ); ++iter ) delete *iter;
}

Referenced by ~HeatedCrossSectionsMultiGroup().

Member Function Documentation

◆ crossSection()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::crossSection	(	std::size_t	a_hashIndex,
		double	a_temperature,
		bool	a_sampling = false ) const

Returns the total multi-group cross section for target temperature a_temperature and projectile multi-group a_hashIndex.

Parameters

a_hashIndex	[in] The multi-group index.
a_temperature	[in] The temperature of the target.
a_sampling	[in] Used for multi-group look up. If true, use augmented cross sections.

Definition at line 1951 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                        {
 
    double cross_section;
 
    if( a_temperature <= m_temperatures[0] ) {
        cross_section = m_heatedCrossSections[0]->crossSection( a_hashIndex, a_sampling ); }
    else if( a_temperature >= m_temperatures.back( ) ) {
        cross_section = m_heatedCrossSections.back( )->crossSection( a_hashIndex, a_sampling ); }
    else {
        std::size_t i1;
        for( i1 = 0; i1 < m_temperatures.size( ); ++i1 ) if( a_temperature < m_temperatures[i1] ) break;
        double fraction = ( a_temperature - m_temperatures[i1-1] ) / ( m_temperatures[i1] - m_temperatures[i1-1] );
 
        cross_section = ( 1. - fraction ) * m_heatedCrossSections[i1-1]->crossSection( a_hashIndex, a_sampling )
                        + fraction * m_heatedCrossSections[i1]->crossSection( a_hashIndex, a_sampling );
    }
 
    return( cross_section );
}

Referenced by crossSection().

◆ crossSectionVector()

LUPI_HOST_DEVICE void MCGIDI::HeatedCrossSectionsMultiGroup::crossSectionVector	(	double	a_temperature,
		double	a_userFactor,
		std::size_t	a_numberAllocated,
		double *	a_crossSectionVector ) const

Adds the energy dependent, total cross section corresponding to the temperature a_temperature multiplied by a_userFactor to a_crossSectionVector.

Parameters

a_temperature	[in] Specifies the temperature of the material.
a_userFactor	[in] User factor which all cross sections are multiplied by.
a_numberAllocated	[in] The length of memory allocated for a_crossSectionVector.
a_crossSectionVector	[in/out] The energy dependent, total cross section to add cross section data to.

Definition at line 1980 of file MCGIDI_heatedCrossSections.cc.

                                                                                  {
 
    std::size_t index1 = 0, index2 = 0;
    double fraction = 0.0;
 
    if( a_temperature <= m_temperatures[0] ) { 
        }
    else if( a_temperature >= m_temperatures.back( ) ) {
        index1 = index2 = m_temperatures.size( ) - 1;
        fraction = 1.0; }
    else {
        for( ; index2 < m_temperatures.size( ); ++index2 ) if( a_temperature < m_temperatures[index2] ) break;
        index1 = index2 - 1;
        fraction = ( a_temperature - m_temperatures[index1] ) / ( m_temperatures[index2] - m_temperatures[index1] );
    }
 
    Vector<double> &totalCrossSection1 = m_heatedCrossSections[index1]->totalCrossSection( );
    Vector<double> &totalCrossSection2 = m_heatedCrossSections[index2]->totalCrossSection( );
    std::size_t size = totalCrossSection1.size( );
    double factor1 = a_userFactor * ( 1.0 - fraction ), factor2 = a_userFactor * fraction;
 
    if( a_numberAllocated < totalCrossSection1.size( ) ) LUPI_THROW( "HeatedCrossSectionsMultiGroup::crossSectionVector: a_numberAllocated too small." );
    for( std::size_t i1 = 0; i1 < size; ++i1 ) {
        a_crossSectionVector[i1] += factor1 * totalCrossSection1[i1] + factor2 * totalCrossSection2[i1];
    }
}

Referenced by crossSectionVector().

◆ depositionEnergy()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::depositionEnergy	(	std::size_t	a_hashIndex,
		double	a_temperature ) const

Returns the multi-group deposition energy for target temperature a_temperature and projectile multi-group a_hashIndex.

Parameters

a_hashIndex	[in] The multi-group index.
a_temperature	[in] The temperature of the target.

Returns: The deposition energy.

Definition at line 2068 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                           {
 
    double deposition_energy;
 
    if( a_temperature <= m_temperatures[0] ) {
        deposition_energy = m_heatedCrossSections[0]->depositionEnergy( a_hashIndex ); }
    else if( a_temperature >= m_temperatures.back( ) ) {
        deposition_energy = m_heatedCrossSections.back( )->depositionEnergy( a_hashIndex ); }
    else {
        std::size_t i1;
        for( i1 = 0; i1 < m_temperatures.size( ); ++i1 ) if( a_temperature < m_temperatures[i1] ) break;
        double fraction = ( a_temperature - m_temperatures[i1-1] ) / ( m_temperatures[i1] - m_temperatures[i1-1] );
        deposition_energy = ( 1. - fraction ) * m_heatedCrossSections[i1-1]->depositionEnergy( a_hashIndex )
                            + fraction * m_heatedCrossSections[i1]->depositionEnergy( a_hashIndex );
    }
 
    return( deposition_energy );
}

Referenced by depositionEnergy().

◆ depositionMomentum()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::depositionMomentum	(	std::size_t	a_hashIndex,
		double	a_temperature ) const

Returns the multi-group deposition momentum for target temperature a_temperature and projectile multi-group a_hashIndex.

Parameters

a_hashIndex	[in] The multi-group index.
a_temperature	[in] The temperature of the target.

Returns: The deposition energy.

Definition at line 2096 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                             {
 
    double deposition_momentum;
 
    if( a_temperature <= m_temperatures[0] ) {
        deposition_momentum = m_heatedCrossSections[0]->depositionMomentum( a_hashIndex ); }
    else if( a_temperature >= m_temperatures.back( ) ) {
        deposition_momentum = m_heatedCrossSections.back( )->depositionMomentum( a_hashIndex ); }
    else {
        std::size_t i1;
        for( i1 = 0; i1 < m_temperatures.size( ); ++i1 ) if( a_temperature < m_temperatures[i1] ) break;
        double fraction = ( a_temperature - m_temperatures[i1-1] ) / ( m_temperatures[i1] - m_temperatures[i1-1] );
        deposition_momentum = ( 1. - fraction ) * m_heatedCrossSections[i1-1]->depositionMomentum( a_hashIndex )
                            + fraction * m_heatedCrossSections[i1]->depositionMomentum( a_hashIndex );
    }
 
    return( deposition_momentum );
}

Referenced by depositionMomentum().

◆ gain()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::gain	(	std::size_t	a_hashIndex,
		double	a_temperature,
		int	a_particleIndex ) const

Returns the multi-group gain for particle with index a_particleIndex. If no particle is found, a Vector of all 0's is returned.

Parameters

a_hashIndex	[in] The multi-group index.
a_temperature	[in] The temperature of the target.
a_particleIndex	[in] The index of the particle whose gain is to be returned.

Returns: The multi-group gain.

Definition at line 2154 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                    {
 
    if( a_temperature <= m_temperatures[0] ) {
        return( m_heatedCrossSections[0]->gain( a_hashIndex, a_particleIndex ) ); }
    else if( a_temperature >= m_temperatures.back( ) ) {
        return( m_heatedCrossSections.back( )->gain( a_hashIndex, a_particleIndex ) );
    }
 
    std::size_t i1;
    for( i1 = 0; i1 < m_temperatures.size( ); ++i1 ) if( a_temperature < m_temperatures[i1] ) break;
    double fraction = ( a_temperature - m_temperatures[i1-1] ) / ( m_temperatures[i1] - m_temperatures[i1-1] );
 
    double gain1 = m_heatedCrossSections[i1-1]->gain( a_hashIndex, a_particleIndex );
    double gain2 = m_heatedCrossSections[i1]->gain( a_hashIndex, a_particleIndex );
 
    return( ( 1. - fraction ) * gain1 + fraction * gain2 );
}

Referenced by gain().

◆ gainViaIntid()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::gainViaIntid	(	std::size_t	a_hashIndex,
		double	a_temperature,
		int	a_particleIntid ) const

Returns the multi-group gain for particle with intid a_particleIntid. If no particle is found, a Vector of all 0's is returned.

Parameters

a_hashIndex	[in] The multi-group index.
a_temperature	[in] The temperature of the target.
a_particleIntid	[in] The intid of the particle whose gain is to be returned.

Returns: The multi-group gain.

Definition at line 2182 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                            {
 
    if( a_temperature <= m_temperatures[0] ) {
        return( m_heatedCrossSections[0]->gainViaIntid( a_hashIndex, a_particleIntid ) ); }
    else if( a_temperature >= m_temperatures.back( ) ) {
        return( m_heatedCrossSections.back( )->gainViaIntid( a_hashIndex, a_particleIntid ) );
    }
 
    std::size_t i1;
    for( i1 = 0; i1 < m_temperatures.size( ); ++i1 ) if( a_temperature < m_temperatures[i1] ) break;
    double fraction = ( a_temperature - m_temperatures[i1-1] ) / ( m_temperatures[i1] - m_temperatures[i1-1] );
 
    double gain1 = m_heatedCrossSections[i1-1]->gainViaIntid( a_hashIndex, a_particleIntid );
    double gain2 = m_heatedCrossSections[i1]->gainViaIntid( a_hashIndex, a_particleIntid );
 
    return( ( 1. - fraction ) * gain1 + fraction * gain2 );
}

Referenced by gainViaIntid().

◆ heatedCrossSections()

LUPI_HOST_DEVICE Vector< HeatedCrossSectionMultiGroup * > const & MCGIDI::HeatedCrossSectionsMultiGroup::heatedCrossSections ( ) const

inline

Definition at line 906 of file MCGIDI.hpp.

906{ return( m_heatedCrossSections ); }

◆ maximumEnergy()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::maximumEnergy ( ) const

inline

Definition at line 895 of file MCGIDI.hpp.

895{ return( m_projectileMultiGroupBoundariesCollapsed.back( ) ); }

◆ minimumEnergy()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::minimumEnergy ( ) const

inline

Definition at line 894 of file MCGIDI.hpp.

894{ return( m_projectileMultiGroupBoundariesCollapsed[0] ); }

◆ multiGroupThresholdIndex()

LUPI_HOST_DEVICE int MCGIDI::HeatedCrossSectionsMultiGroup::multiGroupThresholdIndex ( std::size_t a_index ) const

inline

Returns the threshold for the reaction at index a_index.

Definition at line 902 of file MCGIDI.hpp.

◆ print()

LUPI_HOST void MCGIDI::HeatedCrossSectionsMultiGroup::print ( ) const

This method calls write for every temperature dataset in this with the file type stdout.

Definition at line 2293 of file MCGIDI_heatedCrossSections.cc.

                                                           {
 
    for( std::size_t index = 0; index < m_heatedCrossSections.size( ); ++index ) write( stdout, static_cast<int>( index ) );
}

Referenced by print().

◆ productionEnergy()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::productionEnergy	(	std::size_t	a_hashIndex,
		double	a_temperature ) const

Returns the multi-group production energy for target temperature a_temperature and projectile multi-group a_hashIndex.

Parameters

a_hashIndex	[in] The multi-group index.
a_temperature	[in] The temperature of the target.

Returns: The deposition energy.

Definition at line 2124 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                           {
 
    double production_energy;
 
    if( a_temperature <= m_temperatures[0] ) {
        production_energy = m_heatedCrossSections[0]->productionEnergy( a_hashIndex ); }
    else if( a_temperature >= m_temperatures.back( ) ) {
        production_energy = m_heatedCrossSections.back( )->productionEnergy( a_hashIndex ); }
    else {
        std::size_t i1;
        for( i1 = 0; i1 < m_temperatures.size( ); ++i1 ) if( a_temperature < m_temperatures[i1] ) break;
        double fraction = ( a_temperature - m_temperatures[i1-1] ) / ( m_temperatures[i1] - m_temperatures[i1-1] );
 
        production_energy = ( 1. - fraction ) * m_heatedCrossSections[i1-1]->productionEnergy( a_hashIndex )
                            + fraction * m_heatedCrossSections[i1]->productionEnergy( a_hashIndex );
    }
 
    return( production_energy );
}

Referenced by productionEnergy().

◆ projectileMultiGroupBoundariesCollapsed()

LUPI_HOST_DEVICE Vector< double > const & MCGIDI::HeatedCrossSectionsMultiGroup::projectileMultiGroupBoundariesCollapsed ( ) const

inline

Returns the value of the m_projectileMultiGroupBoundariesCollapsed.

Definition at line 904 of file MCGIDI.hpp.

◆ reactionCrossSection() [1/2]

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::reactionCrossSection	(	std::size_t	a_reactionIndex,
		double	a_temperature,
		double	a_energy_in ) const

Returns the requested reaction's multi-group cross section for target temperature a_temperature and projectile multi-group a_hashIndex.

Parameters

a_reactionIndex	[in] The index of the reaction.
a_temperature	[in] The temperature of the target.
a_energy_in	[in] The energy of the projectile.

Definition at line 2044 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                                       {
 
    int intEnergyIndex = binarySearchVector( a_energy_in, m_projectileMultiGroupBoundariesCollapsed );
    std::size_t energyIndex = static_cast<std::size_t>( intEnergyIndex );
 
    if( intEnergyIndex == -2 ) {
        energyIndex = 0; }
    else {
        energyIndex = m_projectileMultiGroupBoundariesCollapsed.size( ) - 2;
    }
 
 
    return( reactionCrossSection( a_reactionIndex, energyIndex, a_temperature, false ) );
}

◆ reactionCrossSection() [2/2]

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::reactionCrossSection	(	std::size_t	a_reactionIndex,
		std::size_t	a_hashIndex,
		double	a_temperature,
		bool	a_sampling = false ) const

Returns the requested reaction's multi-group cross section for target temperature a_temperature and projectile multi-group a_hashIndex.

Parameters

a_reactionIndex	[in] The index of the reaction.
a_hashIndex	[in] The multi-group index.
a_temperature	[in] The temperature of the target.
a_sampling	[in] If true, use augmented cross sections.

Definition at line 2017 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                                                           {
 
    double cross_section;
 
    if( a_temperature <= m_temperatures[0] ) {
        cross_section = m_heatedCrossSections[0]->reactionCrossSection( a_reactionIndex, a_hashIndex, a_sampling ); }
    else if( a_temperature >= m_temperatures.back( ) ) {
        cross_section = m_heatedCrossSections.back( )->reactionCrossSection( a_reactionIndex, a_hashIndex, a_sampling ); }
    else {
        std::size_t i1;
        for( i1 = 0; i1 < m_temperatures.size( ); ++i1 ) if( a_temperature < m_temperatures[i1] ) break;
        double fraction = ( a_temperature - m_temperatures[i1-1] ) / ( m_temperatures[i1] - m_temperatures[i1-1] );
        cross_section = ( 1. - fraction ) * m_heatedCrossSections[i1-1]->reactionCrossSection( a_reactionIndex, a_hashIndex, a_sampling )
                            + fraction * m_heatedCrossSections[i1]->reactionCrossSection( a_reactionIndex, a_hashIndex, a_sampling );
    }
 
    return( cross_section );
}

Referenced by reactionCrossSection(), and reactionCrossSection().

◆ sampleReaction()

template<typename RNG>

LUPI_HOST_DEVICE std::size_t MCGIDI::HeatedCrossSectionsMultiGroup::sampleReaction	(	std::size_t	a_hashIndex,
		double	a_temperature,
		double	a_energy,
		double	a_crossSection,
		RNG &&	a_rng ) const

inline

Returns the requested reaction's multi-group cross section for target temperature a_temperature and projectile multi-group a_hashIndex.

Parameters

a_hashIndex	[in] The multi-group index.
a_temperature	[in] The temperature of the target.
a_energy	[in] The energy of the projectile.
a_crossSection	[in] The total cross section for the protare at a_temperature and a_energy.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).

Definition at line 2267 of file MCGIDI_headerSource.hpp.

                                     {
 
    std::size_t i1, sampled_reaction_index, temperatureIndex1, temperatureIndex2, numberOfTemperatures = m_temperatures.size( );
    double sampleCrossSection = a_crossSection * a_rng( );
 
    if( a_temperature <= m_temperatures[0] ) {
        temperatureIndex1 = 0;
        temperatureIndex2 = temperatureIndex1; }
    else if( a_temperature >= m_temperatures.back( ) ) {
        temperatureIndex1 = m_temperatures.size( ) - 1;
        temperatureIndex2 = temperatureIndex1; }
    else {
        for( i1 = 0; i1 < numberOfTemperatures; ++i1 ) if( a_temperature < m_temperatures[i1] ) break;
        temperatureIndex1 = i1 - 1;
        temperatureIndex2 = i1;
    }
 
    std::size_t numberOfReactions = m_heatedCrossSections[0]->numberOfReactions( );
    double crossSectionSum = 0;
    HeatedCrossSectionMultiGroup &heatedCrossSection1 = *m_heatedCrossSections[temperatureIndex1];
 
    if( temperatureIndex1 == temperatureIndex2 ) {
        for( sampled_reaction_index = 0; sampled_reaction_index < numberOfReactions; ++sampled_reaction_index ) {
            crossSectionSum += heatedCrossSection1.reactionCrossSection( sampled_reaction_index, a_hashIndex, true );
            if( crossSectionSum >= sampleCrossSection ) break;
        } }
    else {
        double temperatureFraction2 = ( a_temperature - m_temperatures[temperatureIndex1] ) / ( m_temperatures[temperatureIndex2] - m_temperatures[temperatureIndex1] );
        double temperatureFraction1 = 1.0 - temperatureFraction2;
        HeatedCrossSectionMultiGroup &heatedCrossSection2 = *m_heatedCrossSections[temperatureIndex2];
 
        for( sampled_reaction_index = 0; sampled_reaction_index < numberOfReactions; ++sampled_reaction_index ) {
            if( m_thresholds[sampled_reaction_index] >= a_energy ) continue;
            crossSectionSum += temperatureFraction1 * heatedCrossSection1.reactionCrossSection( sampled_reaction_index, a_hashIndex, true );
            crossSectionSum += temperatureFraction2 * heatedCrossSection2.reactionCrossSection( sampled_reaction_index, a_hashIndex, true );
            if( crossSectionSum >= sampleCrossSection ) break;
        }
    }
 
    if( sampled_reaction_index == numberOfReactions ) return( MCGIDI_nullReaction );
 
    if( m_multiGroupThresholdIndex[sampled_reaction_index] == static_cast<int>( a_hashIndex ) ) {
        double energyAboveThreshold = a_energy - m_thresholds[sampled_reaction_index];
 
        if( energyAboveThreshold <= ( a_rng( ) * ( m_projectileMultiGroupBoundariesCollapsed[a_hashIndex+1] - m_thresholds[sampled_reaction_index] ) ) )
            return( MCGIDI_nullReaction );
    }
 
    return( sampled_reaction_index );
}

◆ serialize()

LUPI_HOST_DEVICE void MCGIDI::HeatedCrossSectionsMultiGroup::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 2232 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                    {
 
    DATA_MEMBER_VECTOR_DOUBLE( m_temperatures, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_DOUBLE( m_thresholds, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_INT( m_multiGroupThresholdIndex, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_DOUBLE( m_projectileMultiGroupBoundariesCollapsed, a_buffer, a_mode );
 
    std::size_t vectorSize = m_heatedCrossSections.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_heatedCrossSections.resize( vectorSize, &a_buffer.m_placement );
    if( a_mode == LUPI::DataBuffer::Mode::Memory ) a_buffer.m_placement += m_heatedCrossSections.internalSize();
    for( std::size_t memberIndex = 0; memberIndex < vectorSize; ++memberIndex ) {
        if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
            if( a_buffer.m_placement != nullptr ) {
                m_heatedCrossSections[memberIndex] = new(a_buffer.m_placement) HeatedCrossSectionMultiGroup;
                a_buffer.incrementPlacement( sizeof( HeatedCrossSectionMultiGroup ) ); }
            else {
                m_heatedCrossSections[memberIndex] = new HeatedCrossSectionMultiGroup;
            }
        }
        if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
            a_buffer.incrementPlacement( sizeof( HeatedCrossSectionMultiGroup ) );
        }
        m_heatedCrossSections[memberIndex]->serialize( a_buffer, a_mode );
    }
}

Referenced by serialize().

◆ setUserParticleIndex()

LUPI_HOST void MCGIDI::HeatedCrossSectionsMultiGroup::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 2207 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                 {
 
    for( auto iter = m_heatedCrossSections.begin( ); iter != m_heatedCrossSections.end( ); ++iter ) (*iter)->setUserParticleIndex( a_particleIndex, a_userParticleIndex );
}

Referenced by setUserParticleIndex().

◆ setUserParticleIndexViaIntid()

LUPI_HOST void MCGIDI::HeatedCrossSectionsMultiGroup::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 intid of the particle whose user index is to be set.
a_userParticleIndex	[in] The particle index specified by the user.

Definition at line 2219 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                         {
 
    for( auto iter = m_heatedCrossSections.begin( ); iter != m_heatedCrossSections.end( ); ++iter ) (*iter)->setUserParticleIndexViaIntid( a_particleIntid, a_userParticleIndex );
}

Referenced by setUserParticleIndexViaIntid().

◆ temperatures()

LUPI_HOST_DEVICE Vector< double > const & MCGIDI::HeatedCrossSectionsMultiGroup::temperatures ( ) const

inline

Returns the value of the m_temperatures.

Definition at line 896 of file MCGIDI.hpp.

◆ threshold()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionsMultiGroup::threshold ( std::size_t a_index ) const

inline

Returns the threshold for the reaction at index a_index.

Definition at line 908 of file MCGIDI.hpp.

Referenced by update().

◆ update()

LUPI_HOST void MCGIDI::HeatedCrossSectionsMultiGroup::update	(	LUPI::StatusMessageReporting &	a_smr,
		GIDI::ProtareSingle const &	a_protare,
		SetupInfo &	a_setupInfo,
		Transporting::MC const &	a_settings,
		GIDI::Transporting::Particles const &	a_particles,
		GIDI::Styles::TemperatureInfos const &	a_temperatureInfos,
		std::vector< GIDI::Reaction const * > const &	a_reactions,
		std::vector< GIDI::Reaction const * > const &	a_orphanProducts,
		bool	a_zeroReactions,
		GIDI::ExcludeReactionsSet const &	a_reactionsToExclude )

Fills in this with the requested temperature data.

Parameters

a_smr	[Out] If errors are not to be thrown, then the error is reported via this instance.
a_protare	[in] The GIDI::Protare used to constuct the Protare that this is a part of.
a_setupInfo	[in] Used internally when constructing a Protare to pass information to other components.
a_settings	[in] Used to pass user options to the this to instruct it which data are desired.
a_particles	[in] List of transporting particles and their information (e.g., multi-group boundaries and fluxes).
a_temperatureInfos	[in] The list of temperatures to use.
a_reactions	[in] The list of reactions to use.
a_orphanProducts	[in] The list of orphan products to use.
a_zeroReactions	[in] Special case where no reaction in a protare is wanted so the first one is used but its cross section is set to 0.0 at all energies.

Definition at line 1916 of file MCGIDI_heatedCrossSections.cc.

                                                                      {
 
    m_temperatures.reserve( a_temperatureInfos.size( ) );
    m_heatedCrossSections.reserve( a_temperatureInfos.size( ) );
 
    for( GIDI::Styles::TemperatureInfos::const_iterator iter = a_temperatureInfos.begin( ); iter != a_temperatureInfos.end( ); ++iter ) {
        m_temperatures.push_back( iter->temperature( ).value( ) );
        m_heatedCrossSections.push_back( new HeatedCrossSectionMultiGroup( a_smr, a_protare, a_setupInfo, a_settings, *iter, a_particles, 
                a_reactions, iter->heatedMultiGroup( ), a_zeroReactions, a_reactionsToExclude ) );
    }
 
    m_thresholds.resize( m_heatedCrossSections[0]->numberOfReactions( ) );
    for( std::size_t i1 = 0; i1 < m_heatedCrossSections[0]->numberOfReactions( ); ++i1 ) m_thresholds[i1] = m_heatedCrossSections[0]->threshold( i1 );
 
    m_multiGroupThresholdIndex.resize( m_heatedCrossSections[0]->numberOfReactions( ) );
    for( std::size_t i1 = 0; i1 < m_heatedCrossSections[0]->numberOfReactions( ); ++i1 ) {
        m_multiGroupThresholdIndex[i1] = -1;
        if( m_thresholds[i1] > 0 ) m_multiGroupThresholdIndex[i1] = static_cast<int>( m_heatedCrossSections[0]->thresholdOffset( i1 ) );
    }
 
    m_projectileMultiGroupBoundariesCollapsed = a_setupInfo.m_protare.projectileMultiGroupBoundariesCollapsed( );
}

Referenced by update().

◆ write()

LUPI_HOST void MCGIDI::HeatedCrossSectionsMultiGroup::write	(	FILE *	a_file,
		int	a_temperatureIndex ) const

This method writes the multi-group data at temperature index a_temperatureIndex to a_file.

Parameters

a_file	[in] The buffer to read or write data to depending on a_mode.
a_temperatureIndex	[in] The index of the temperature whose data are written.

Definition at line 2269 of file MCGIDI_heatedCrossSections.cc.

                                                                                                {
 
    if( a_temperatureIndex < 0 ) return;
 
    std::size_t temperatureIndex = (std::size_t) a_temperatureIndex;
    if( temperatureIndex >= m_temperatures.size( ) ) return;
 
    printf( "HeatedCrossSectionsMultiGroup::write for temperature %.4e\n", m_temperatures[temperatureIndex] );
 
    fprintf( a_file, "    boundaries index                           " );
    std::string space( 14, ' ' );
    for( std::size_t index = 0; index < m_projectileMultiGroupBoundariesCollapsed.size( ); ++index ) {
        fprintf( a_file, "%s%6zu", space.c_str( ), index );
    }
    fprintf( a_file, "\n" );
    writeVector( a_file, "boundaries", 0, m_projectileMultiGroupBoundariesCollapsed );
 
    m_heatedCrossSections[temperatureIndex]->write( a_file );
}

Referenced by print(), and write().

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ HeatedCrossSectionsMultiGroup()

◆ ~HeatedCrossSectionsMultiGroup()

Member Function Documentation

◆ crossSection()

◆ crossSectionVector()

◆ depositionEnergy()

◆ depositionMomentum()

◆ gain()

◆ gainViaIntid()

◆ heatedCrossSections()

◆ maximumEnergy()

◆ minimumEnergy()

◆ multiGroupThresholdIndex()

◆ print()

◆ productionEnergy()

◆ projectileMultiGroupBoundariesCollapsed()

◆ reactionCrossSection() [1/2]

◆ reactionCrossSection() [2/2]

◆ sampleReaction()

◆ serialize()

◆ setUserParticleIndex()

◆ setUserParticleIndexViaIntid()

◆ temperatures()

◆ threshold()

◆ update()

◆ write()