MCGIDI::ProtareSingle Class Reference

#include <MCGIDI.hpp>

Inheritance diagram for MCGIDI::ProtareSingle:

Public Member Functions
LUPI_HOST_DEVICE	ProtareSingle ()
LUPI_HOST	ProtareSingle (LUPI::StatusMessageReporting &a_smr, GIDI::ProtareSingle const &a_protare, PoPI::Database const &a_pops, Transporting::MC &a_settings, GIDI::Transporting::Particles const &a_particles, DomainHash const &a_domainHash, GIDI::Styles::TemperatureInfos const &a_temperatureInfos, GIDI::ExcludeReactionsSet const &a_reactionsToExclude, std::size_t a_reactionsToExcludeOffset=0, bool a_allowFixedGrid=true)
LUPI_HOST_DEVICE	~ProtareSingle ()
LUPI_HOST_DEVICE bool	isPhotoAtomic () const
LUPI_HOST_DEVICE bool	continuousEnergy () const
LUPI_HOST_DEVICE bool	fixedGrid () const
LUPI_HOST_DEVICE HeatedCrossSectionsContinuousEnergy const &	heatedCrossSections () const
LUPI_HOST_DEVICE HeatedCrossSectionsContinuousEnergy &	heatedCrossSections ()
LUPI_HOST_DEVICE HeatedCrossSectionsMultiGroup const &	heatedMultigroupCrossSections () const
LUPI_HOST_DEVICE HeatedCrossSectionsMultiGroup &	heatedMultigroupCrossSections ()
LUPI_HOST_DEVICE const Vector< NuclideGammaBranchStateInfo * > &	nuclideGammaBranchStateInfos () const
LUPI_HOST_DEVICE const Vector< NuclideGammaBranchInfo * > &	branches () const
LUPI_HOST_DEVICE Vector< Reaction * > const &	reactions () const
LUPI_HOST_DEVICE Vector< Reaction * > const &	orphanProducts () const
template<typename RNG, typename PUSHBACK>
LUPI_HOST_DEVICE void	sampleBranchingGammas (Sampling::Input &a_input, double a_projectileEnergy, int a_initialStateIndex, RNG &&a_rng, PUSHBACK &&push_back, Sampling::ProductHandler &a_products) const
LUPI_HOST void	setUserParticleIndex2 (int a_particleIndex, int a_userParticleIndex)
LUPI_HOST void	setUserParticleIndexViaIntid2 (int a_particleIntid, int a_userParticleIndex)
LUPI_HOST_DEVICE std::size_t	numberOfProtares () const
LUPI_HOST_DEVICE ProtareSingle const *	protare (std::size_t a_index) const
LUPI_HOST_DEVICE ProtareSingle *	protare (std::size_t a_index)
LUPI_HOST_DEVICE ProtareSingle const *	protareWithReaction (std::size_t a_index) const
LUPI_HOST_DEVICE double	minimumEnergy () const
LUPI_HOST_DEVICE double	maximumEnergy () const
LUPI_HOST_DEVICE Vector< double >	temperatures (std::size_t a_index=0) const
LUPI_HOST Vector< double > const &	projectileMultiGroupBoundaries () const
LUPI_HOST Vector< double > const &	projectileMultiGroupBoundariesCollapsed () const
LUPI_HOST_DEVICE std::size_t	numberOfReactions () const
LUPI_HOST_DEVICE Reaction const *	reaction (std::size_t a_index) const
LUPI_HOST_DEVICE std::size_t	numberOfOrphanProducts () const
LUPI_HOST_DEVICE Reaction const *	orphanProduct (std::size_t a_index) const
LUPI_HOST_DEVICE bool	hasFission () const
LUPI_HOST_DEVICE String	interaction () const
LUPI_HOST_DEVICE bool	hasIncoherentDoppler () const
LUPI_HOST_DEVICE int	URR_index () const
LUPI_HOST_DEVICE void	setURR_index (int a_URR_index)
LUPI_HOST_DEVICE bool	inURR (double a_energy) const
LUPI_HOST_DEVICE bool	hasURR_probabilityTables () const
LUPI_HOST_DEVICE double	URR_domainMin () const
LUPI_HOST_DEVICE double	URR_domainMax () const
LUPI_HOST_DEVICE bool	reactionHasURR_probabilityTables (std::size_t a_index) const
LUPI_HOST_DEVICE double	threshold (std::size_t a_index) const
LUPI_HOST_DEVICE double	crossSection (URR_protareInfos const &a_URR_protareInfos, std::size_t a_hashIndex, double a_temperature, double a_energy, 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, URR_protareInfos const &a_URR_protareInfos, std::size_t a_hashIndex, double a_temperature, double a_energy, bool a_sampling=false) const
LUPI_HOST_DEVICE double	reactionCrossSection (std::size_t a_reactionIndex, URR_protareInfos const &a_URR_protareInfos, double a_temperature, double a_energy) const
template<typename RNG>
LUPI_HOST_DEVICE bool	sampleTargetBetaForUpscatterModelA (Sampling::Input &a_input, RNG &&a_rng) const
template<typename RNG>
LUPI_HOST_DEVICE std::size_t	sampleReaction (Sampling::Input &a_input, URR_protareInfos const &a_URR_protareInfos, std::size_t a_hashIndex, double a_crossSection, RNG &&a_rng) const
LUPI_HOST_DEVICE double	depositionEnergy (std::size_t a_hashIndex, double a_temperature, double a_energy) const
LUPI_HOST_DEVICE double	depositionMomentum (std::size_t a_hashIndex, double a_temperature, double a_energy) const
LUPI_HOST_DEVICE double	productionEnergy (std::size_t a_hashIndex, double a_temperature, double a_energy) const
LUPI_HOST_DEVICE double	gain (std::size_t a_hashIndex, double a_temperature, double a_energy, int a_particleIndex) const
LUPI_HOST_DEVICE double	gainViaIntid (std::size_t a_hashIndex, double a_temperature, double a_energy, int a_particleIntid) const
LUPI_HOST_DEVICE bool	upscatterModelASupported () const
LUPI_HOST_DEVICE Vector< double > const &	upscatterModelAGroupEnergies () const
LUPI_HOST_DEVICE Vector< double > const &	upscatterModelAGroupVelocities () const
LUPI_HOST_DEVICE Vector< double > const &	upscatterModelACrossSection () const
LUPI_HOST_DEVICE void	serialize2 (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)
LUPI_HOST_DEVICE long	sizeOf2 () const
Public Member Functions inherited from MCGIDI::Protare
LUPI_HOST_DEVICE	Protare (ProtareType a_protareType)
LUPI_HOST	Protare (ProtareType a_protareType, GIDI::Protare const &a_protare, Transporting::MC const &a_settings, PoPI::Database const &a_pops)
virtual LUPI_HOST_DEVICE	~Protare ()
LUPI_HOST_DEVICE ProtareType	protareType () const
LUPI_HOST_DEVICE String const &	projectileID () const
LUPI_HOST_DEVICE int	projectileIntid () const
LUPI_HOST_DEVICE int	projectileIndex () const
LUPI_HOST_DEVICE int	projectileUserIndex () const
LUPI_HOST_DEVICE double	projectileMass () const
LUPI_HOST_DEVICE double	projectileExcitationEnergy () const
LUPI_HOST_DEVICE String const &	targetID () const
LUPI_HOST_DEVICE int	targetIntid () const
LUPI_HOST_DEVICE int	targetIndex () const
LUPI_HOST_DEVICE int	targetUserIndex () const
LUPI_HOST_DEVICE double	targetMass () const
LUPI_HOST_DEVICE double	targetExcitationEnergy () const
LUPI_HOST_DEVICE int	photonIndex () const
LUPI_HOST_DEVICE int	userPhotonIndex () const
LUPI_HOST_DEVICE String	evaluation () const
LUPI_HOST GIDI::Frame	projectileFrame () const
LUPI_HOST Vector< int > const &	productIntids (bool a_transportablesOnly) const
LUPI_HOST Vector< int > const &	productIndices (bool a_transportablesOnly) const
LUPI_HOST Vector< int > const &	userProductIndices (bool a_transportablesOnly) const
LUPI_HOST void	setUserParticleIndex (int a_particleIndex, int a_userParticleIndex)
LUPI_HOST void	setUserParticleIndexViaIntid (int a_particleIntid, int a_userParticleIndex)
LUPI_HOST_DEVICE bool	isTNSL_ProtareSingle () const
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE std::size_t	numberOfProtares () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE ProtareSingle const *	protare (std::size_t a_index) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE ProtareSingle *	protare (std::size_t a_index) MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE ProtareSingle const *	protareWithReaction (std::size_t a_index) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	minimumEnergy () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	maximumEnergy () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE Vector< double >	temperatures (std::size_t a_index=0) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST Vector< double > const &	projectileMultiGroupBoundaries () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST Vector< double > const &	projectileMultiGroupBoundariesCollapsed () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE std::size_t	numberOfReactions () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE Reaction const *	reaction (std::size_t a_index) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE std::size_t	numberOfOrphanProducts () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE Reaction const *	orphanProduct (std::size_t a_index) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE bool	hasFission () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE bool	hasIncoherentDoppler () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE int	URR_index () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE bool	hasURR_probabilityTables () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	URR_domainMin () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	URR_domainMax () const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE bool	reactionHasURR_probabilityTables (std::size_t a_index) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	threshold (std::size_t a_index) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	crossSection (URR_protareInfos const &a_URR_protareInfos, std::size_t a_hashIndex, double a_temperature, double a_energy, bool a_sampling=false) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE void	crossSectionVector (double a_temperature, double a_userFactor, std::size_t a_numberAllocated, double *a_crossSectionVector) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	reactionCrossSection (std::size_t a_reactionIndex, URR_protareInfos const &a_URR_protareInfos, std::size_t a_hashIndex, double a_temperature, double a_energy, bool a_sampling=false) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	reactionCrossSection (std::size_t a_reactionIndex, URR_protareInfos const &a_URR_protareInfos, double a_temperature, double a_energy) const MCGIDI_TRUE_VIRTUAL
template<typename RNG>
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE std::size_t	sampleReaction (Sampling::Input &a_input, URR_protareInfos const &a_URR_protareInfos, std::size_t a_hashIndex, double a_crossSection, RNG &&a_rng) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	depositionEnergy (std::size_t a_hashIndex, double a_temperature, double a_energy) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	depositionMomentum (std::size_t a_hashIndex, double a_temperature, double a_energy) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	productionEnergy (std::size_t a_hashIndex, double a_temperature, double a_energy) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	gain (std::size_t a_hashIndex, double a_temperature, double a_energy, int a_particleIndex) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE double	gainViaIntid (std::size_t a_hashIndex, double a_temperature, double a_energy, int a_particleIntid) const MCGIDI_TRUE_VIRTUAL
MCGIDI_VIRTUAL_FUNCTION LUPI_HOST_DEVICE Vector< double > const &	upscatterModelAGroupVelocities () const MCGIDI_TRUE_VIRTUAL
LUPI_HOST_DEVICE void	serialize (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)
LUPI_HOST_DEVICE void	serialize2 (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)
LUPI_HOST_DEVICE void	serializeCommon (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)
LUPI_HOST_DEVICE long	sizeOf () const
LUPI_HOST_DEVICE long	memorySize ()
LUPI_HOST_DEVICE void	incrementMemorySize (long &a_totalMemory, long &a_sharedMemory)
template<typename RNG>
LUPI_HOST_DEVICE std::size_t	sampleReaction (Sampling::Input &a_input, URR_protareInfos const &a_URR_protareInfos, std::size_t a_hashIndex, double a_crossSection, RNG &&a_rng) const

Additional Inherited Members
Public Attributes inherited from MCGIDI::Protare
friend	ProtareSingle
friend	ProtareComposite
friend	ProtareTNSL

Detailed Description

Class representing a GNDS <reactionSuite> node with only data needed for Monte Carlo transport. The data are also stored in a way that is better suited for Monte Carlo transport. For example, cross section data for each reaction are not stored with its reaction, but within the HeatedCrossSections member of the Protare.

Definition at line 1609 of file MCGIDI.hpp.

Constructor & Destructor Documentation

ProtareSingle() [1/2]

LUPI_HOST_DEVICE MCGIDI::ProtareSingle::ProtareSingle

(

)

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

Definition at line 1272 of file MCGIDI_protare.cc.

                                               :
        Protare( ProtareType::single ),
        m_URR_index( -1 ),
        m_hasURR_probabilityTables( false ),
        m_URR_domainMin( -1.0 ),
        m_URR_domainMax( -1.0 ),
        m_upscatterModelASupported( false ),
        m_projectileMultiGroupBoundaries( 0 ),
        m_projectileMultiGroupBoundariesCollapsed( 0 ),
        m_reactions( 0 ),
        m_orphanProducts( 0 ) {
 
}

Referenced by protare(), protare(), and protareWithReaction().

ProtareSingle() [2/2]

LUPI_HOST MCGIDI::ProtareSingle::ProtareSingle	(	LUPI::StatusMessageReporting &	a_smr,
		GIDI::ProtareSingle const &	a_protare,
		PoPI::Database const &	a_pops,
		Transporting::MC &	a_settings,
		GIDI::Transporting::Particles const &	a_particles,
		DomainHash const &	a_domainHash,
		GIDI::Styles::TemperatureInfos const &	a_temperatureInfos,
		GIDI::ExcludeReactionsSet const &	a_reactionsToExclude,
		std::size_t	a_reactionsToExcludeOffset = 0,
		bool	a_allowFixedGrid = true )

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 whose data is to be used to construct this.
a_pops	[in] A PoPs Database instance used to get particle intids and possibly other particle information.
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_domainHash	[in] The hash data used when looking up a cross section.
a_temperatureInfos	[in] The list of temperature data to extract from a_protare.
a_reactionsToExclude	[in] A list of reaction to not include in the MCGIDI::Protare.
a_reactionsToExcludeOffset	[in] The starting index for the reactions in this ProtareSingle.
a_allowFixedGrid	[in] For internal (i.e., MCGIDI) use only. Users must use the default value.

Definition at line 1299 of file MCGIDI_protare.cc.

                                                                              :
        Protare( ProtareType::single, a_protare, a_settings, a_pops ),
        m_interaction( a_protare.interaction( ).c_str( ) ),
        m_URR_index( -1 ),
        m_hasURR_probabilityTables( false ),
        m_URR_domainMin( -1.0 ),
        m_URR_domainMax( -1.0 ),
        m_domainHash( a_domainHash ),
        m_upscatterModelASupported( ( projectileIntid( ) != PoPI::Intids::photon ) &&
                                    ( projectileIntid( ) != PoPI::Intids::electron ) &&
                                    !isTNSL_ProtareSingle( ) ),
        m_projectileMultiGroupBoundaries( 0 ),
        m_projectileMultiGroupBoundariesCollapsed( 0 ),
        m_reactions( 0 ),
        m_orphanProducts( 0 ),
        m_isPhotoAtomic( a_protare.isPhotoAtomic( ) ),
        m_heatedCrossSections( ),
        m_heatedMultigroupCrossSections( ) {
 
    a_protare.updateReactionIndices( 0 );           // This is not correct as the offset should be passed as an arguent.
    PoPI::Database const &pops = a_protare.protare( 0 )->internalPoPs( );
 
    if( !a_protare.isPhotoAtomic( ) ) {
        std::set<std::string> incompleteParticles;
        a_protare.incompleteParticles( a_settings, incompleteParticles );
        for( auto particle = a_particles.particles( ).begin( ); particle != a_particles.particles( ).end( ); ++particle ) {
            if( incompleteParticles.count( particle->first ) != 0 ) {
                std::string message = "Requested particle '" + particle->first + "' is incomplete in '" + a_protare.realFileName( ) + "'.";
                if( a_settings.throwOnError( ) ) {
                    throw std::runtime_error( message.c_str( ) ); }
                else {
                    smr_setReportError2p( a_smr.smr( ), 0, 0, message.c_str( ) );
                }
            }
        }
    }
 
    SetupInfo setupInfo( *this, a_protare, a_pops, pops );
    setupInfo.m_formatVersion = a_protare.formatVersion( );
    setupInfo.m_GRIN_continuumGammas = a_protare.GRIN_continuumGammas2( );
 
    GIDI::Transporting::Particles particles;
    for( std::map<std::string, GIDI::Transporting::Particle>::const_iterator particle = a_particles.particles( ).begin( ); particle != a_particles.particles( ).end( ); ++particle ) {
        setupInfo.m_particleIntids[particle->first] = MCGIDI_popsIntid( pops, particle->first );
        setupInfo.m_particleIndices[particle->first] = MCGIDI_popsIndex( a_pops, particle->first );
 
        if( ( m_interaction == GIDI_MapInteractionAtomicChars ) && 
                !( ( particle->first == PoPI::IDs::photon ) || ( particle->first == PoPI::IDs::electron ) ) ) continue;
        particles.add( particle->second );
    }
 
    GIDI::Transporting::MG multiGroupSettings( a_settings.projectileID( ), GIDI::Transporting::Mode::MonteCarloContinuousEnergy, a_settings.delayedNeutrons( ) );
    multiGroupSettings.setThrowOnError( a_settings.throwOnError( ) );
 
    setupInfo.m_distributionLabel = a_temperatureInfos[0].griddedCrossSection( );
 
    a_settings.styles( &a_protare.styles( ) );
 
    switch( a_settings.crossSectionLookupMode( ) ) {
    case Transporting::LookupMode::Data1d::continuousEnergy :
        m_continuousEnergy = true;
        break;
    case Transporting::LookupMode::Data1d::multiGroup :
        m_continuousEnergy = false;
        if( a_settings.upscatterModel( ) == Sampling::Upscatter::Model::B ) {
            multiGroupSettings.setMode( GIDI::Transporting::Mode::multiGroupWithSnElasticUpScatter ); }
        else {
            multiGroupSettings.setMode( GIDI::Transporting::Mode::multiGroup );
        }
        break;
    default :
        throw std::runtime_error( "ProtareSingle::ProtareSingle: invalid lookupMode" );
    }
    m_fixedGrid = a_allowFixedGrid && ( a_protare.projectile( ).ID( ) == PoPI::IDs::photon ) && ( a_settings.fixedGridPoints( ).size( ) > 0 );
 
    setupNuclideGammaBranchStateInfos( setupInfo, a_protare, a_settings.makePhotonEmissionProbabilitiesOne( ),
            a_settings.zeroNuclearLevelEnergyWidth( ) );
    convertACE_URR_probabilityTablesFromGIDI( a_protare, a_settings,  setupInfo );
 
    if( ( a_settings.crossSectionLookupMode( ) == Transporting::LookupMode::Data1d::multiGroup ) || 
        ( a_settings.other1dDataLookupMode( ) == Transporting::LookupMode::Data1d::multiGroup ) ) {
 
        GIDI::Suite const *transportables = nullptr;
        if( setupInfo.m_formatVersion.major( ) > 1 ) {
            GIDI::Styles::HeatedMultiGroup const &heatedMultiGroup = *a_protare.styles( ).get<GIDI::Styles::HeatedMultiGroup>( a_settings.label( ) );
           transportables = &heatedMultiGroup.transportables( ); }
        else {
            std::vector<GIDI::Suite::const_iterator> tags = a_protare.styles( ).findAllOfMoniker( GIDI_multiGroupStyleChars );
 
            if( tags.size( ) != 1 ) throw std::runtime_error( "MCGIDI::ProtareSingle::ProtareSingle: What is going on here?" );
            GIDI::Styles::MultiGroup const &multiGroup = static_cast<GIDI::Styles::MultiGroup const &>( **tags[0] );
            transportables = &multiGroup.transportables( );
        }
 
        GIDI::Transportable const transportable = *transportables->get<GIDI::Transportable>( a_protare.projectile( ).ID( ) );
        m_projectileMultiGroupBoundaries = transportable.groupBoundaries( );
        GIDI::Transporting::Particle const *particle = a_particles.particle( a_protare.projectile( ).ID( ) );
        m_projectileMultiGroupBoundariesCollapsed = particle->multiGroup( ).boundaries( );
    }
 
    std::vector<GIDI::Reaction const *> GIDI_reactions;
    std::set<std::string> product_ids;
    std::set<std::string> product_ids_transportable;
    GIDI::Reaction const *nuclearPlusCoulombInterferenceReaction = nullptr;
    if( a_settings.nuclearPlusCoulombInterferenceOnly( ) ) nuclearPlusCoulombInterferenceReaction = a_protare.nuclearPlusCoulombInterferenceOnlyReaction( );
 
    for( std::size_t reactionIndex = 0; reactionIndex < a_protare.reactions( ).size( ); ++reactionIndex ) {
        if( a_reactionsToExclude.find( reactionIndex + a_reactionsToExcludeOffset ) != a_reactionsToExclude.end( ) ) continue;
 
        GIDI::Reaction const *GIDI_reaction = a_protare.reaction( reactionIndex );
 
        if( !GIDI_reaction->active( ) ) continue;
 
        if( m_continuousEnergy ) {
            if( GIDI_reaction->crossSectionThreshold( ) >= a_settings.energyDomainMax( ) ) continue; }
        else {
            GIDI::Vector multi_group_cross_section = GIDI_reaction->multiGroupCrossSection( a_smr, multiGroupSettings, a_temperatureInfos[0] );
            GIDI::Vector vector = GIDI::collapse( multi_group_cross_section, a_settings, a_particles, 0.0 );
 
            std::size_t i1 = 0;
            for( ; i1 < vector.size( ); ++i1 ) if( vector[i1] != 0.0 ) break;
            if( i1 == vector.size( ) ) continue;
        }
        if( a_settings.ignoreENDF_MT5( ) && ( GIDI_reaction->ENDF_MT( ) == 5 ) && ( a_reactionsToExclude.size( ) == 0 ) ) continue;
 
        GIDI_reaction->productIDs( product_ids, particles, false );
        GIDI_reaction->productIDs( product_ids_transportable, particles, true );
 
        if( a_settings.nuclearPlusCoulombInterferenceOnly( ) && GIDI_reaction->RutherfordScatteringPresent( ) ) {
            if( nuclearPlusCoulombInterferenceReaction != nullptr ) GIDI_reactions.push_back( nuclearPlusCoulombInterferenceReaction ); }
        else {
            GIDI_reactions.push_back( GIDI_reaction );
        }
    }
 
    bool zeroReactions = GIDI_reactions.size( ) == 0;   // Happens when all reactions are skipped in the prior loop.
    if( zeroReactions ) GIDI_reactions.push_back( a_protare.reaction( 0 ) );    // Special case where no reaction in the protare is wanted so the first one is used but its cross section is set to 0.0 at all energies.
 
    setupInfo.m_reactionType = Transporting::Reaction::Type::Reactions;
    m_reactions.reserve( GIDI_reactions.size( ) );
    for( auto GIDI_reaction = GIDI_reactions.begin( ); GIDI_reaction != GIDI_reactions.end( ); ++GIDI_reaction ) {
        setupInfo.m_reaction = *GIDI_reaction;
        setupInfo.m_isPairProduction = (*GIDI_reaction)->isPairProduction( );
        setupInfo.m_isPhotoAtomicIncoherentScattering = (*GIDI_reaction)->isPhotoAtomicIncoherentScattering( );
        setupInfo.m_initialStateIndex = -1;
        Reaction *reaction = new Reaction( **GIDI_reaction, setupInfo, a_settings, particles, a_temperatureInfos );
        setupInfo.m_initialStateIndices[(*GIDI_reaction)->label( )] = setupInfo.m_initialStateIndex;
        reaction->updateProtareSingleInfo( this, m_reactions.size( ) );
        m_reactions.push_back( reaction );
    }
 
    std::set<int> product_intids;
    std::set<int> product_indices;
    for( std::set<std::string>::iterator iter = product_ids.begin( ); iter != product_ids.end( ); ++iter ) {
        product_intids.insert( MCGIDI_popsIntid( pops, *iter ) );
        product_indices.insert( MCGIDI_popsIndex( a_pops, *iter ) );
    }
    std::set<int> product_intids_transportable;
    std::set<int> product_indices_transportable;
    for( std::set<std::string>::iterator iter = product_ids_transportable.begin( ); iter != product_ids_transportable.end( ); ++iter ) {
        product_intids_transportable.insert( MCGIDI_popsIntid( pops, *iter ) );
        product_indices_transportable.insert( MCGIDI_popsIndex( a_pops, *iter ) );
    }
    productIntidsAndIndices( product_intids, product_intids_transportable, product_indices, product_indices_transportable );
 
    if( a_settings.sampleNonTransportingParticles( ) || particles.hasParticle( PoPI::IDs::photon ) ) {
        setupInfo.m_reactionType = Transporting::Reaction::Type::OrphanProducts;
        m_orphanProducts.reserve( a_protare.orphanProducts( ).size( ) );
        std::vector< std::vector<std::size_t> > associatedOrphanProductIndices( m_reactions.size( ) );
 
        for( std::size_t orphanProductIndex = 0; orphanProductIndex < a_protare.orphanProducts( ).size( ); ++orphanProductIndex ) {
            GIDI::Reaction const *GIDI_reaction = a_protare.orphanProduct( orphanProductIndex );
 
            if( GIDI_reaction->crossSectionThreshold( ) >= a_settings.energyDomainMax( ) ) continue;
 
            setupInfo.m_reaction = GIDI_reaction;
            Reaction *orphanProductReaction = new Reaction( *GIDI_reaction, setupInfo, a_settings, particles, a_temperatureInfos );
            orphanProductReaction->updateProtareSingleInfo( this, m_orphanProducts.size( ) );
            m_orphanProducts.push_back( orphanProductReaction );
 
            GIDI::Functions::Reference1d const *reference( GIDI_reaction->crossSection( ).get<GIDI::Functions::Reference1d>( 0 ) );
            std::string xlink = reference->xlink( );
            GUPI::Ancestry const *ancestry = a_protare.findInAncestry( xlink );
            if( ancestry == nullptr ) throw std::runtime_error( "Could not find xlink for orphan product - 1." );
            ancestry = ancestry->ancestor( );
            if( ancestry == nullptr ) throw std::runtime_error( "Could not find xlink for orphan product - 2." );
            if( ancestry->moniker( ) != GIDI_crossSectionSumChars ) {
                ancestry = ancestry->ancestor( );
                if( ancestry == nullptr ) throw std::runtime_error( "Could not find xlink for orphan product - 3." );
            }
            GIDI::Sums::CrossSectionSum const *crossSectionSum = static_cast<GIDI::Sums::CrossSectionSum const *>( ancestry );
            GIDI::Sums::Summands const &summands = crossSectionSum->summands( );
            for( std::size_t i1 = 0; i1 < summands.size( ); ++i1 ) {
                GIDI::Sums::Summand::Base const *summand = summands[i1];
 
                ancestry = a_protare.findInAncestry( summand->href( ) );
                if( ancestry == nullptr ) throw std::runtime_error( "Could not find href for summand - 1." );
                ancestry = ancestry->ancestor( );
                if( ancestry == nullptr ) throw std::runtime_error( "Could not find href for summand - 2." );
 
                GIDI::Reaction const *GIDI_reaction2 = static_cast<GIDI::Reaction const *>( ancestry );
                for( std::size_t reactionIndex = 0; reactionIndex < m_reactions.size( ); ++reactionIndex ) {
                    std::string label( m_reactions[reactionIndex]->label( ).c_str( ) );
 
                    if( label == GIDI_reaction2->label( ) ) {
                        associatedOrphanProductIndices[reactionIndex].push_back( m_orphanProducts.size( ) - 1 );
                        break;
                    }
                }
            }
        }
 
        for( std::size_t reactionIndex = 0; reactionIndex < m_reactions.size( ); ++reactionIndex ) {
            Reaction *reaction = m_reactions[reactionIndex];
            std::size_t size = associatedOrphanProductIndices[reactionIndex].size( );
            if( size > 0 ) {
                std::vector<Product *> associatedOrphanProducts;
                for( std::size_t index1 = 0; index1 < size; ++index1 ) {
                    std::size_t associatedOrphanProductIndex = associatedOrphanProductIndices[reactionIndex][index1];
                    m_orphanProducts[associatedOrphanProductIndex]->addOrphanProductToProductList( associatedOrphanProducts );
                }
                reaction->setOrphanProductData( associatedOrphanProductIndices[reactionIndex], associatedOrphanProducts );
            }
        }
    }
 
    std::vector<GIDI::Reaction const *> GIDI_orphanProducts;
    for( std::size_t reactionIndex = 0; reactionIndex < a_protare.orphanProducts( ).size( ); ++reactionIndex ) {
        GIDI::Reaction const *GIDI_reaction = a_protare.orphanProduct( reactionIndex );
 
        if( GIDI_reaction->crossSectionThreshold( ) >= a_settings.energyDomainMax( ) ) continue;
        GIDI_orphanProducts.push_back( GIDI_reaction );
    }
 
    bool removeContinuousEnergyData = false;
    if( m_continuousEnergy ) {
        m_heatedCrossSections.update( a_smr, setupInfo, a_settings, particles, a_domainHash, a_temperatureInfos, GIDI_reactions, GIDI_orphanProducts,
                m_fixedGrid, zeroReactions );
        m_hasURR_probabilityTables = m_heatedCrossSections.hasURR_probabilityTables( );
        m_URR_domainMin = m_heatedCrossSections.URR_domainMin( );
        m_URR_domainMax = m_heatedCrossSections.URR_domainMax( ); }
    else {
        m_heatedMultigroupCrossSections.update( a_smr, a_protare, setupInfo, a_settings, particles, a_temperatureInfos, GIDI_reactions, 
                GIDI_orphanProducts, zeroReactions, a_reactionsToExclude );
 
        if( ( a_settings.upscatterModelAGroupBoundaries().size( ) > 0 ) ||
                ( a_settings.upscatterModel( ) == Sampling::Upscatter::Model::DBRC ) ) { // Load pointwise data to recompute Model A cross sections on user-defined grid or for DBRC.
            removeContinuousEnergyData = true;
            m_heatedCrossSections.update( a_smr, setupInfo, a_settings, particles, a_domainHash, a_temperatureInfos, GIDI_reactions, GIDI_orphanProducts,
                    m_fixedGrid, zeroReactions );
        }
    }
 
    if( m_upscatterModelASupported && ( a_settings.upscatterModel( ) == Sampling::Upscatter::Model::A ) ) {
        std::vector<double> const &upscatterModelAGroupBoundaries = a_settings.upscatterModelAGroupBoundaries( );
        if( upscatterModelAGroupBoundaries.size( ) == 0 ) {
            GIDI::Styles::Base const *style = a_protare.styles( ).get<GIDI::Styles::Base>( a_temperatureInfos[0].heatedMultiGroup( ) );
 
            if( style->moniker( ) == GIDI_SnElasticUpScatterStyleChars ) style = a_protare.styles( ).get<GIDI::Styles::Base>( style->derivedStyle( ) );
            if( style->moniker( ) != GIDI_heatedMultiGroupStyleChars ) throw GIDI::Exception( "Label does not yield a heatedMultiGroup style." );
 
            GIDI::Styles::HeatedMultiGroup const &heatedMultiGroup = *static_cast<GIDI::Styles::HeatedMultiGroup const *>( style );
            std::vector<double> const &boundaries = heatedMultiGroup.groupBoundaries( a_protare.projectile( ).ID( ) );
 
            m_upscatterModelAGroupEnergies.resize( boundaries.size( ) );
            m_upscatterModelAGroupVelocities.resize( boundaries.size( ) );
            for( std::size_t i1 = 0; i1 < boundaries.size( ); ++i1 ) {
                m_upscatterModelAGroupEnergies[i1] = boundaries[i1];
                m_upscatterModelAGroupVelocities[i1] = MCGIDI_particleBeta( projectileMass( ), boundaries[i1] );
            }
 
            GIDI::ExcludeReactionsSet reactionsToExclude;
            auto upscatterModelACrossSectionForm = a_protare.multiGroupCrossSection( a_smr, multiGroupSettings, a_temperatureInfos[0], 
                    reactionsToExclude, a_temperatureInfos[0].heatedMultiGroup( ) );
            m_upscatterModelACrossSection.resize( upscatterModelACrossSectionForm.size( ) );
            for( std::size_t i1 = 0; i1 < upscatterModelACrossSectionForm.size( ); ++i1 ) 
                m_upscatterModelACrossSection[i1] = upscatterModelACrossSectionForm[i1]; }
        else {
            
            m_upscatterModelAGroupEnergies.reserve( upscatterModelAGroupBoundaries.size( ) );
            m_upscatterModelAGroupVelocities.reserve( upscatterModelAGroupBoundaries.size( ) );
            for( auto iter = upscatterModelAGroupBoundaries.begin( ); iter != upscatterModelAGroupBoundaries.end( ); ++iter ) {
                m_upscatterModelAGroupEnergies.push_back( *iter );
                m_upscatterModelAGroupVelocities.push_back( MCGIDI_particleBeta( projectileMass( ), *iter ) );
            }
 
            GIDI::Transporting::MultiGroup boundaries( "Model A", upscatterModelAGroupBoundaries );
 
            GIDI::Functions::XYs1d crossSectionXYs1d = m_heatedCrossSections.crossSectionAsGIDI_XYs1d( 0.0 );
 
            GIDI::Transporting::Flux flux( "Model A", 0.0 );
            std::vector<double> energies, fluxes;
            energies.push_back( upscatterModelAGroupBoundaries[0] );
            energies.push_back( upscatterModelAGroupBoundaries.back( ) );
            fluxes.push_back( 1.0 );
            fluxes.push_back( 1.0 );
            flux.addFluxOrder( GIDI::Transporting::Flux_order( 0, energies, fluxes ) );
 
            GIDI::Vector crossSectionVector = multiGroupXYs1d( boundaries, crossSectionXYs1d, flux );
            m_upscatterModelACrossSection.resize( crossSectionVector.size( ) );
            for( std::size_t index = 0; index < crossSectionVector.size( ); ++index )
                    m_upscatterModelACrossSection[index] = crossSectionVector[index];
        }
        if( !m_continuousEnergy ) m_multiGroupHash = MultiGroupHash( m_projectileMultiGroupBoundariesCollapsed );
    }
 
    if( ( PoPI::Intids::neutron  == projectileIntid( ) ) && ( a_settings.upscatterModel( ) == Sampling::Upscatter::Model::DBRC ) ) {
        std::size_t reactionIndex = 0;
        for( auto reactionIter = m_reactions.begin( ); reactionIter != m_reactions.end( ); ++reactionIter, ++reactionIndex ) {
            if( (*reactionIter)->ENDF_MT( ) == 2 ) {
                Reaction *reaction = *reactionIter;
 
                HeatedCrossSectionContinuousEnergy const *heatedCrossSectionContinuousEnergy = m_heatedCrossSections.heatedCrossSections( )[0];
                HeatedReactionCrossSectionContinuousEnergy const *heatedReactionCrossSectionContinuousEnergy 
                        = heatedCrossSectionContinuousEnergy->reactionCrossSection( reactionIndex );
 
                Vector<double> const &energies = heatedCrossSectionContinuousEnergy->energies( );
                Vector<MCGIDI_FLOAT> const &crossSectionsFloat = heatedReactionCrossSectionContinuousEnergy->crossSections( );
                Vector<double> crossSections( crossSectionsFloat.size( ) );
                std::size_t index = 0;
                for( auto iter = crossSectionsFloat.begin( ); iter != crossSectionsFloat.end( ); ++iter, ++index )
                    crossSections[index] = *iter;
 
                Sampling::Upscatter::ModelDBRC_data *modelDBRC_data = 
                        new Sampling::Upscatter::ModelDBRC_data( projectileMass( ), targetMass( ), energies, crossSections, a_domainHash );
                reaction->setModelDBRC_data( modelDBRC_data );
                break;
            }
        }
    }
    if( removeContinuousEnergyData ) {
        m_heatedCrossSections.clear( );
    }
}

~ProtareSingle()

LUPI_HOST_DEVICE MCGIDI::ProtareSingle::~ProtareSingle

(

)

Definition at line 1640 of file MCGIDI_protare.cc.

                                                {
 
    for( Vector<NuclideGammaBranchInfo *>::const_iterator iter = m_branches.begin( ); iter < m_branches.end( ); ++iter ) delete *iter;
    for( Vector<NuclideGammaBranchStateInfo *>::const_iterator iter = m_nuclideGammaBranchStateInfos.begin( ); iter < m_nuclideGammaBranchStateInfos.end( ); ++iter ) delete *iter;
    for( Vector<Reaction *>::const_iterator iter = m_reactions.begin( ); iter < m_reactions.end( ); ++iter ) delete *iter;
    for( Vector<Reaction *>::const_iterator iter = m_orphanProducts.begin( ); iter < m_orphanProducts.end( ); ++iter ) delete *iter;
}

Referenced by ~ProtareSingle().

Member Function Documentation

branches()

LUPI_HOST_DEVICE const Vector< NuclideGammaBranchInfo * > & MCGIDI::ProtareSingle::branches ( ) const

inline

Returns a reference to the m_branches member.

Definition at line 1660 of file MCGIDI.hpp.

continuousEnergy()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::continuousEnergy ( ) const

inline

Definition at line 1651 of file MCGIDI.hpp.

{ return( m_continuousEnergy ); }

crossSection()

LUPI_HOST_DEVICE double MCGIDI::ProtareSingle::crossSection	(	URR_protareInfos const &	a_URR_protareInfos,
		std::size_t	a_hashIndex,
		double	a_temperature,
		double	a_energy,
		bool	a_sampling = false ) const

Returns the total cross section for target temperature a_temperature and projectile energy a_energy. a_sampling is only used for multi-group cross section look up.

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] The energy of the projectile.
a_sampling	[in] Used for multi-group look up. If true, use augmented cross sections.

Definition at line 1818 of file MCGIDI_protare.cc.

                                                                                                                                                                                     {
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.crossSection( a_URR_protareInfos, m_URR_index, a_hashIndex, a_temperature, a_energy ) );
 
    return( m_heatedMultigroupCrossSections.crossSection( a_hashIndex, a_temperature, a_sampling ) );
}

Referenced by crossSection(), and sampleReaction().

crossSectionVector()

LUPI_HOST_DEVICE void MCGIDI::ProtareSingle::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 1834 of file MCGIDI_protare.cc.

                                                     {
 
    if( m_continuousEnergy ) {
        if( !m_fixedGrid ) LUPI_THROW( "ProtareSingle::crossSectionVector: continuous energy cannot be supported." );
        m_heatedCrossSections.crossSectionVector( a_temperature, a_userFactor, a_numberAllocated, a_crossSectionVector ); }
    else {
        m_heatedMultigroupCrossSections.crossSectionVector( a_temperature, a_userFactor, a_numberAllocated, a_crossSectionVector );
    }
}

Referenced by crossSectionVector().

depositionEnergy()

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

Returns the index of a sampled reaction for a target with termpature a_temperature, a projectile with energy a_energy and total cross section a_crossSection. Random numbers are obtained via a_userrng and a_rngState.

Parameters

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

Definition at line 1891 of file MCGIDI_protare.cc.

                                                                                                                            {
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.depositionEnergy( a_hashIndex, a_temperature, a_energy ) );
 
    return( m_heatedMultigroupCrossSections.depositionEnergy( a_hashIndex, a_temperature ) );
}

Referenced by depositionEnergy().

depositionMomentum()

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

Returns the index of a sampled reaction for a target with termpature a_temperature, a projectile with energy a_energy and total cross section a_crossSection. Random numbers are obtained via a_userrng and a_rngState.

Parameters

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

Definition at line 1907 of file MCGIDI_protare.cc.

                                                                                                                              {
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.depositionMomentum( a_hashIndex, a_temperature, a_energy ) );
 
    return( m_heatedMultigroupCrossSections.depositionMomentum( a_hashIndex, a_temperature ) );
}

Referenced by depositionMomentum().

fixedGrid()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::fixedGrid ( ) const

inline

Definition at line 1652 of file MCGIDI.hpp.

{ return( m_fixedGrid ); }

gain()

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

Returns the index of a sampled reaction for a target with termpature a_temperature, a projectile with energy a_energy and total cross section a_crossSection. Random numbers are obtained via a_userrng and a_rngState.

Parameters

a_hashIndex	[in] Specifies the continuous energy or multi-group index.
a_temperature	[in] The temperature of the target.
a_energy	[in] The energy of the projectile.
a_particleIndex	[in] The index of the particle whose gain is to be returned.

Definition at line 1940 of file MCGIDI_protare.cc.

                                                                                                                                     {
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.gain( a_hashIndex, a_temperature, a_energy, a_particleIndex ) );
 
    return( m_heatedMultigroupCrossSections.gain( a_hashIndex, a_temperature, a_particleIndex ) );
}

Referenced by gain().

gainViaIntid()

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

Returns the intid of a sampled reaction for a target with termpature a_temperature, a projectile with energy a_energy and total cross section a_crossSection. Random numbers are obtained via a_userrng and a_rngState.

Parameters

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

Definition at line 1957 of file MCGIDI_protare.cc.

                                                                                                                                             {
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.gainViaIntid( a_hashIndex, a_temperature, a_energy, a_particleIntid ) );
 
    return( m_heatedMultigroupCrossSections.gainViaIntid( a_hashIndex, a_temperature, a_particleIntid ) );
}

Referenced by gainViaIntid().

hasFission()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::hasFission

(

)

const

Returns true if this has a fission reaction and false otherwise.

Returns

true is if this has a fission reaction and false otherwise.

Definition at line 1771 of file MCGIDI_protare.cc.

                                                       {
 
    for( Vector<Reaction *>::const_iterator iter = m_reactions.begin( ); iter < m_reactions.end( ); ++iter ) {
        if( (*iter)->hasFission( ) ) return( true );
    }
    return( false );
}

Referenced by hasFission().

hasIncoherentDoppler()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::hasIncoherentDoppler

(

)

const

Returns true if this has an incoherent photoatomic doppler broadened reaction and false otherwise.

Returns

true is if this has a specified reaction and false otherwise.

Definition at line 1785 of file MCGIDI_protare.cc.

                                                                 {
 
    for( Vector<Reaction *>::const_iterator iter = m_reactions.begin( ); iter < m_reactions.end( ); ++iter ) {
        if( (*iter)->ENDF_MT( ) == 1534 ) return( true );
    }
    return( false );
}

Referenced by hasIncoherentDoppler().

hasURR_probabilityTables()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::hasURR_probabilityTables ( ) const

inline

Definition at line 1706 of file MCGIDI.hpp.

{ return( m_hasURR_probabilityTables ); }

Referenced by MCGIDI::URR_protareInfos::setup().

heatedCrossSections() [1/2]

LUPI_HOST_DEVICE HeatedCrossSectionsContinuousEnergy & MCGIDI::ProtareSingle::heatedCrossSections ( )

inline

Returns a reference to the m_heatedCrossSections member.

Definition at line 1654 of file MCGIDI.hpp.

heatedCrossSections() [2/2]

LUPI_HOST_DEVICE HeatedCrossSectionsContinuousEnergy const & MCGIDI::ProtareSingle::heatedCrossSections ( ) const

inline

Returns a reference to the m_heatedCrossSections member.

Definition at line 1653 of file MCGIDI.hpp.

heatedMultigroupCrossSections() [1/2]

LUPI_HOST_DEVICE HeatedCrossSectionsMultiGroup & MCGIDI::ProtareSingle::heatedMultigroupCrossSections ( )

inline

Returns a reference to the m_heatedMultigroupCrossSections member.

Definition at line 1656 of file MCGIDI.hpp.

heatedMultigroupCrossSections() [2/2]

LUPI_HOST_DEVICE HeatedCrossSectionsMultiGroup const & MCGIDI::ProtareSingle::heatedMultigroupCrossSections ( ) const

inline

Returns a reference to the m_heatedMultigroupCrossSections member.

Definition at line 1655 of file MCGIDI.hpp.

interaction()

LUPI_HOST_DEVICE String MCGIDI::ProtareSingle::interaction ( ) const

inline

Definition at line 1700 of file MCGIDI.hpp.

{ return( m_interaction ); }

Referenced by ProtareSingle().

inURR()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::inURR

(

double

a_energy

)

const

Returns true if a_energy with unresolved resonance region (URR) of this and false otherwise.

Returns

true is if this has a URR data.

Definition at line 1799 of file MCGIDI_protare.cc.

                                                                  {
 
    if( a_energy < m_URR_domainMin ) return( false );
    if( a_energy > m_URR_domainMax ) return( false );
 
    return( true );
}

Referenced by inURR(), and MCGIDI::URR_protareInfos::updateProtare().

isPhotoAtomic()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::isPhotoAtomic ( ) const

inline

Definition at line 1650 of file MCGIDI.hpp.

{ return( m_isPhotoAtomic ); }

Referenced by MCGIDI::HeatedCrossSectionContinuousEnergy::HeatedCrossSectionContinuousEnergy(), and ProtareSingle().

maximumEnergy()

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

inline

Returns the maximum cross section domain.

Definition at line 1684 of file MCGIDI.hpp.

minimumEnergy()

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

inline

Returns the minimum cross section domain.

Definition at line 1681 of file MCGIDI.hpp.

nuclideGammaBranchStateInfos()

LUPI_HOST_DEVICE const Vector< NuclideGammaBranchStateInfo * > & MCGIDI::ProtareSingle::nuclideGammaBranchStateInfos ( ) const

inline

Returns a reference to the m_nuclideGammaBranchStateInfos member.

Definition at line 1658 of file MCGIDI.hpp.

Referenced by MCGIDI::HeatedCrossSectionContinuousEnergy::HeatedCrossSectionContinuousEnergy(), MCGIDI::GRIN_captureToCompound::sampleCaptureLevel(), MCGIDI::GRIN_capture::sampleProducts(), and MCGIDI::GRIN_inelastic::sampleProducts().

numberOfOrphanProducts()

LUPI_HOST_DEVICE std::size_t MCGIDI::ProtareSingle::numberOfOrphanProducts ( ) const

inline

Returns the number of orphan products of this.

Definition at line 1696 of file MCGIDI.hpp.

numberOfProtares()

LUPI_HOST_DEVICE std::size_t MCGIDI::ProtareSingle::numberOfProtares ( ) const

inline

Returns the number of protares contained in this.

Definition at line 1676 of file MCGIDI.hpp.

numberOfReactions()

LUPI_HOST_DEVICE std::size_t MCGIDI::ProtareSingle::numberOfReactions ( ) const

inline

Returns the number of reactions of this.

Definition at line 1694 of file MCGIDI.hpp.

Referenced by protareWithReaction().

orphanProduct()

LUPI_HOST_DEVICE Reaction const * MCGIDI::ProtareSingle::orphanProduct ( std::size_t a_index ) const

inline

Returns the (a_index-1)^th orphan product of this.

Definition at line 1697 of file MCGIDI.hpp.

orphanProducts()

LUPI_HOST_DEVICE Vector< Reaction * > const & MCGIDI::ProtareSingle::orphanProducts ( ) const

inline

Returns the value of the m_orphanProducts member.

Definition at line 1666 of file MCGIDI.hpp.

productionEnergy()

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

Returns the index of a sampled reaction for a target with termpature a_temperature, a projectile with energy a_energy and total cross section a_crossSection. Random numbers are obtained via a_userrng and a_rngState.

Parameters

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

Definition at line 1923 of file MCGIDI_protare.cc.

                                                                                                                            {
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.productionEnergy( a_hashIndex, a_temperature, a_energy ) );
 
    return( m_heatedMultigroupCrossSections.productionEnergy( a_hashIndex, a_temperature ) );
}

Referenced by productionEnergy().

projectileMultiGroupBoundaries()

LUPI_HOST Vector< double > const & MCGIDI::ProtareSingle::projectileMultiGroupBoundaries ( ) const

inline

Returns the value of the m_projectileMultiGroupBoundaries member.

Definition at line 1689 of file MCGIDI.hpp.

Referenced by MCGIDI::Protare::projectileMultiGroupBoundaries().

projectileMultiGroupBoundariesCollapsed()

LUPI_HOST Vector< double > const & MCGIDI::ProtareSingle::projectileMultiGroupBoundariesCollapsed ( ) const

inline

Returns the value of the m_projectileMultiGroupBoundariesCollapsed member.

Definition at line 1691 of file MCGIDI.hpp.

Referenced by MCGIDI::Protare::projectileMultiGroupBoundariesCollapsed(), and MCGIDI::HeatedCrossSectionsMultiGroup::update().

protare() [1/2]

LUPI_HOST_DEVICE ProtareSingle * MCGIDI::ProtareSingle::protare

(

std::size_t

a_index

)

Returns the pointer representing the protare (i.e., this) if a_index is 0 and nullptr otherwise.

Parameters

a_index

[in] Must always be 0.

Returns

Returns the pointer representing this.

Definition at line 1700 of file MCGIDI_protare.cc.

                                                                          {
 
    if( a_index != 0 ) return( nullptr );
    return( this );
}

protare() [2/2]

LUPI_HOST_DEVICE ProtareSingle const * MCGIDI::ProtareSingle::protare

(

std::size_t

a_index

)

const

Returns the pointer representing the protare (i.e., this) if a_index is 0 and nullptr otherwise.

Parameters

a_index

[in] Must always be 0.

Returns

Returns the pointer representing this.

Definition at line 1686 of file MCGIDI_protare.cc.

                                                                                      {
 
    if( a_index != 0 ) return( nullptr );
    return( this );
}

Referenced by protare(), and protare().

protareWithReaction()

LUPI_HOST_DEVICE ProtareSingle const * MCGIDI::ProtareSingle::protareWithReaction

(

std::size_t

a_index

)

const

Returns the pointer to the this if (a_index - 1)th is a value reaction index and nullptr otherwise.

Parameters

a_index

[in] Index of the reaction.

Returns

Pointer to the requested protare or nullptr if invalid a_index..

Definition at line 1714 of file MCGIDI_protare.cc.

                                                                                                  {
 
    if( static_cast<std::size_t>( a_index ) < numberOfReactions( ) ) return( this );
    return( nullptr );
}

Referenced by protareWithReaction().

reaction()

LUPI_HOST_DEVICE Reaction const * MCGIDI::ProtareSingle::reaction ( std::size_t a_index ) const

inline

Returns the (a_index-1)^th reaction of this.

Definition at line 1695 of file MCGIDI.hpp.

Referenced by MCGIDI::HeatedCrossSectionContinuousEnergy::print().

reactionCrossSection() [1/2]

LUPI_HOST_DEVICE double MCGIDI::ProtareSingle::reactionCrossSection	(	std::size_t	a_reactionIndex,
		URR_protareInfos const &	a_URR_protareInfos,
		double	a_temperature,
		double	a_energy ) const

Returns the reaction's cross section for the reaction at index a_reactionIndex, for target temperature a_temperature and projectile energy a_energy.

Parameters

a_reactionIndex	[in] The index of the reaction.
a_URR_protareInfos	[in] URR information.
a_temperature	[in] The temperature of the target.
a_energy	[in] The energy of the projectile.

Definition at line 1875 of file MCGIDI_protare.cc.

                                                                                                                                                                                {
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.reactionCrossSection( a_reactionIndex, a_URR_protareInfos, m_URR_index, a_temperature, a_energy ) );
 
    return( m_heatedMultigroupCrossSections.reactionCrossSection( a_reactionIndex, a_temperature, a_energy ) );
}

reactionCrossSection() [2/2]

LUPI_HOST_DEVICE double MCGIDI::ProtareSingle::reactionCrossSection	(	std::size_t	a_reactionIndex,
		URR_protareInfos const &	a_URR_protareInfos,
		std::size_t	a_hashIndex,
		double	a_temperature,
		double	a_energy,
		bool	a_sampling = false ) const

Returns the reaction's cross section for the reaction at index a_reactionIndex, for target temperature a_temperature and projectile energy a_energy. a_sampling is only used for multi-group cross section look up.

Parameters

a_reactionIndex	[in] The index of the reaction.
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] The energy of the projectile.
a_sampling	[in] Used for multi-group look up. If true, use augmented cross sections.

Definition at line 1857 of file MCGIDI_protare.cc.

                                                                               {
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.reactionCrossSection( a_reactionIndex, a_URR_protareInfos, m_URR_index, a_hashIndex, 
            a_temperature, a_energy ) );
 
    return( m_heatedMultigroupCrossSections.reactionCrossSection( a_reactionIndex, a_hashIndex, a_temperature, a_sampling ) );
}

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

reactionHasURR_probabilityTables()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::reactionHasURR_probabilityTables ( std::size_t a_index ) const

inline

Definition at line 1709 of file MCGIDI.hpp.

{ return( m_heatedCrossSections.reactionHasURR_probabilityTables( a_index ) ); }

reactions()

LUPI_HOST_DEVICE Vector< Reaction * > const & MCGIDI::ProtareSingle::reactions ( ) const

inline

Returns the value of the m_reactions member.

Definition at line 1664 of file MCGIDI.hpp.

sampleBranchingGammas()

template<typename RNG, typename PUSHBACK>

LUPI_HOST_DEVICE void MCGIDI::ProtareSingle::sampleBranchingGammas ( Sampling::Input & a_input, double a_projectileEnergy, int a_initialStateIndex, RNG && a_rng, PUSHBACK && a_push_back, Sampling::ProductHandler & a_products ) const

inline

Samples gammas from a nuclide electro-magnetic decay.

Parameters

a_input	[in] Sample options requested by user.
a_projectileEnergy	[in] The energy of the projectile.
a_initialStateIndex	[in] The index in m_nuclideGammaBranchStateInfos whose nuclide data are used for sampling.
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 gammas to.

Definition at line 2718 of file MCGIDI_headerSource.hpp.

                                                                                                  {
 
    int initialStateIndex = a_initialStateIndex;
    double energyLevelSampleWidthUpper = 0.0;           // Used for GRIN continuum levels to add variaction to outgoing photons.
 
    NuclideGammaBranchStateInfo *nuclideGammaBranchStateInfo = nullptr;
    if( initialStateIndex >= 0 ) nuclideGammaBranchStateInfo = m_nuclideGammaBranchStateInfos[static_cast<std::size_t>(initialStateIndex)];
    while( initialStateIndex >= 0 ) {
        auto const &branchIndices = nuclideGammaBranchStateInfo->branchIndices( );
 
        double random = a_rng( );
        double sum = 0.0;
        initialStateIndex = -1;             // Just in case the for loop never has "sum >= random".
        for( std::size_t i1 = 0; i1 < branchIndices.size( ); ++i1 ) {
            NuclideGammaBranchInfo *nuclideGammaBranchInfo = m_branches[branchIndices[i1]];
 
            sum += nuclideGammaBranchInfo->probability( );
            if( sum >= random ) {
                double energyLevelSampleWidthLower = 0.0;
                initialStateIndex = nuclideGammaBranchInfo->residualStateIndex( );
                if( initialStateIndex >= 0 ) {
                    nuclideGammaBranchStateInfo = m_nuclideGammaBranchStateInfos[static_cast<std::size_t>(initialStateIndex)];
                    energyLevelSampleWidthLower = a_rng( ) * nuclideGammaBranchStateInfo->nuclearLevelEnergyWidth( );
                }
                if( nuclideGammaBranchInfo->photonEmissionProbability( ) > a_rng( ) ) {
                    a_input.setSampledType( Sampling::SampledType::photon );
                    a_input.m_dataInTargetFrame = false;
                    a_input.m_frame = GIDI::Frame::lab;
 
                    a_input.m_energyOut1 = nuclideGammaBranchInfo->gammaEnergy( ) + energyLevelSampleWidthUpper - energyLevelSampleWidthLower;
                    a_input.m_mu = 1.0 - 2.0 * a_rng( );
                    a_input.m_phi = 2.0 * M_PI * a_rng( );
 
                    a_products.add( a_projectileEnergy, PoPI::Intids::photon, m_photonIndex, userPhotonIndex( ), 0.0, a_input, a_rng, a_push_back, true );
                }
                energyLevelSampleWidthUpper = energyLevelSampleWidthLower;
                break;
            }
        }
    }
}

Referenced by MCGIDI::Product::sampleFinalState(), MCGIDI::GRIN_capture::sampleProducts(), MCGIDI::GRIN_inelastic::sampleProducts(), and MCGIDI::Product::sampleProducts().

sampleReaction()

template<typename RNG>

LUPI_HOST_DEVICE std::size_t MCGIDI::ProtareSingle::sampleReaction ( Sampling::Input & a_input, URR_protareInfos const & a_URR_protareInfos, std::size_t a_hashIndex, double a_crossSection, RNG && a_rng ) const

inline

Returns the index of a sampled reaction for target temperature, projectile energy and total cross section as specified via argument a_input. Random numbers are obtained via a_rng.

Parameters

a_input	[in/out] Sample options requested by user. The values m_modelTemperature and m_modelEnergy are set by this method.
a_URR_protareInfos	[in] URR information.
a_hashIndex	[in] Specifies the continuous energy hash index or multi-group index.
a_crossSection	[in] The total cross section for the protare at a_input.temperature() and a_input.energy().
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).

Definition at line 2843 of file MCGIDI_headerSource.hpp.

                                                                                   {
 
    std::size_t hashIndex = a_hashIndex;
    double crossSection1 = a_crossSection;
 
    a_input.m_dataInTargetFrame = false;
    a_input.m_modelTemperature = a_input.m_temperature;
    a_input.m_modelEnergy = a_input.m_energy;
 
    if( upscatterModelASupported( ) && ( a_input.m_upscatterModel == Sampling::Upscatter::Model::A ) ) {
        a_input.m_dataInTargetFrame = sampleTargetBetaForUpscatterModelA( a_input, a_rng );
        if( a_input.m_dataInTargetFrame ) {
            if( m_continuousEnergy ) {
                hashIndex = m_domainHash.index( a_input.m_modelEnergy ); }
            else {
                hashIndex = m_multiGroupHash.index( a_input.m_modelEnergy );
            }
            crossSection1 = crossSection( a_URR_protareInfos, hashIndex, a_input.m_modelTemperature, a_input.m_modelEnergy, true );
        }
    }
 
    if( m_continuousEnergy ) return( m_heatedCrossSections.sampleReaction( a_URR_protareInfos, m_URR_index, hashIndex, 
            a_input.m_modelTemperature, a_input.m_modelEnergy, crossSection1, a_rng ) );
 
    return( m_heatedMultigroupCrossSections.sampleReaction( hashIndex, a_input.m_modelTemperature, a_input.m_modelEnergy, 
            crossSection1, a_rng ) );
}

sampleTargetBetaForUpscatterModelA()

template<typename RNG>

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::sampleTargetBetaForUpscatterModelA ( Sampling::Input & a_input, RNG && a_rng ) const

inline

This function is used internally to sample a target's velocity (speed and cosine of angle relative to projectile) for a heated target using zero temperature, multi-grouped cross sections.

Parameters

a_input	[in/out] Contains needed input like the targets temperature. Also will have the target sampled velocity on return if return value is true.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).

Returns

Returns true if target velocity is sampled and false otherwise.

Definition at line 2772 of file MCGIDI_headerSource.hpp.

                                                                                                                                 {
 
    double projectileBeta = MCGIDI_particleBeta( m_projectileMass, a_input.energy( ) );
    double targetThermalBeta = MCGIDI_particleBeta( m_targetMass, a_input.temperature( ) );
 
    a_input.m_projectileBeta = projectileBeta;
    a_input.m_relativeBeta = projectileBeta;
    a_input.m_muLab = 0.0;
    a_input.m_targetBeta = 0.0;
 
    if( targetThermalBeta < 1e-4 * projectileBeta ) return( false );
 
    a_input.m_modelTemperature = 0.0;
 
    double relativeBetaMin = projectileBeta - 2.0 * targetThermalBeta;
    double relativeBetaMax = projectileBeta + 2.0 * targetThermalBeta;
 
    std::size_t maxIndex = m_upscatterModelAGroupVelocities.size( ) - 2;
    int intRelativeBetaMinIndex = binarySearchVector( relativeBetaMin, m_upscatterModelAGroupVelocities, true );
    std::size_t relativeBetaMinIndex = static_cast<std::size_t>( intRelativeBetaMinIndex );
    int intRelativeBetaMaxIndex = binarySearchVector( relativeBetaMax, m_upscatterModelAGroupVelocities, true );
    std::size_t relativeBetaMaxIndex = static_cast<std::size_t>( intRelativeBetaMaxIndex );
    double targetBeta, relativeBeta, mu;
 
    if( relativeBetaMinIndex >= maxIndex ) relativeBetaMinIndex = maxIndex;
    if( relativeBetaMaxIndex >= maxIndex ) relativeBetaMaxIndex = maxIndex;
 
    if( relativeBetaMinIndex == relativeBetaMaxIndex ) {
        targetBeta = targetThermalBeta * sampleBetaFromMaxwellian( a_rng );
        mu = 1.0 - 2.0 * a_rng( );
        relativeBeta = sqrt( targetBeta * targetBeta + projectileBeta * projectileBeta - 2.0 * mu * targetBeta * projectileBeta ); }
    else {
 
        double reactionRate;
        double reactionRateMax = 0;
        for( std::size_t i1 = relativeBetaMinIndex; i1 <= relativeBetaMaxIndex; ++i1 ) {
            reactionRate = m_upscatterModelACrossSection[i1] * m_upscatterModelAGroupVelocities[i1+1];
            if( reactionRate > reactionRateMax ) reactionRateMax = reactionRate;
        }
 
        do {
            targetBeta = targetThermalBeta * sampleBetaFromMaxwellian( a_rng );
            mu = 1.0 - 2.0 * a_rng( );
            relativeBeta = sqrt( targetBeta * targetBeta + projectileBeta * projectileBeta - 2.0 * mu * targetBeta * projectileBeta );
 
            std::size_t index = static_cast<std::size_t>( binarySearchVector( relativeBeta, m_upscatterModelAGroupVelocities, true ) );
            if( index > maxIndex ) index = maxIndex;
            reactionRate = m_upscatterModelACrossSection[index] * relativeBeta;
        } while( reactionRate <  a_rng( ) * reactionRateMax );
    }
 
    a_input.m_modelEnergy = particleKineticEnergy( m_projectileMass, relativeBeta );
    a_input.m_relativeBeta = relativeBeta;
    a_input.m_muLab = mu;
    a_input.m_targetBeta = targetBeta;
 
    return( true );
}

Referenced by sampleReaction().

serialize2()

LUPI_HOST_DEVICE void MCGIDI::ProtareSingle::serialize2	(	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 1972 of file MCGIDI_protare.cc.

                                                                                                     {
 
    std::size_t vectorSize;
    LUPI::DataBuffer *workingBuffer = &a_buffer;
 
    DATA_MEMBER_STRING( m_interaction, a_buffer, a_mode );
    DATA_MEMBER_INT( m_URR_index, a_buffer, a_mode );
    DATA_MEMBER_CAST( m_hasURR_probabilityTables, a_buffer, a_mode, bool );
    DATA_MEMBER_DOUBLE( m_URR_domainMin, a_buffer, a_mode );
    DATA_MEMBER_DOUBLE( m_URR_domainMax, a_buffer, a_mode );
    m_domainHash.serialize( a_buffer, a_mode );
    DATA_MEMBER_VECTOR_DOUBLE( m_projectileMultiGroupBoundaries, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_DOUBLE( m_projectileMultiGroupBoundariesCollapsed, a_buffer, a_mode );
    DATA_MEMBER_CAST( m_upscatterModelASupported, a_buffer, a_mode, bool );
    DATA_MEMBER_VECTOR_DOUBLE( m_upscatterModelAGroupEnergies, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_DOUBLE( m_upscatterModelAGroupVelocities, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_DOUBLE( m_upscatterModelACrossSection, a_buffer, a_mode );
    m_multiGroupHash.serialize( a_buffer, a_mode );
 
    vectorSize = m_nuclideGammaBranchStateInfos.size( );
    int vectorSizeInt = (int) vectorSize;
    DATA_MEMBER_INT( vectorSizeInt, *workingBuffer, a_mode );
    vectorSize = (std::size_t) vectorSizeInt;
 
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
        m_nuclideGammaBranchStateInfos.resize( vectorSize, &(workingBuffer->m_placement) );
        for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
            if (workingBuffer->m_placement != nullptr) {
                m_nuclideGammaBranchStateInfos[vectorIndex] = new(workingBuffer->m_placement) NuclideGammaBranchStateInfo;
                workingBuffer->incrementPlacement( sizeof( NuclideGammaBranchStateInfo ) );
            }
            else {
                m_nuclideGammaBranchStateInfos[vectorIndex] = new NuclideGammaBranchStateInfo;
            }
        }
    }
    if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
        a_buffer.m_placement += m_nuclideGammaBranchStateInfos.internalSize();
        a_buffer.incrementPlacement( sizeof( NuclideGammaBranchStateInfo ) * vectorSize );
    }
    for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
        m_nuclideGammaBranchStateInfos[vectorIndex]->serialize( *workingBuffer, a_mode );
    }
 
    vectorSize = m_branches.size( );
    vectorSizeInt = (int) vectorSize;
    DATA_MEMBER_INT( vectorSizeInt, *workingBuffer, a_mode );
    vectorSize = (std::size_t) vectorSizeInt;
 
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
        m_branches.resize( vectorSize, &(workingBuffer->m_placement) );
        for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
            if (workingBuffer->m_placement != nullptr) {
                m_branches[vectorIndex] = new(workingBuffer->m_placement) NuclideGammaBranchInfo;
                workingBuffer->incrementPlacement( sizeof( NuclideGammaBranchInfo ) );
            }
            else {
                m_branches[vectorIndex] = new NuclideGammaBranchInfo;
            }
        }
    }
    if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
        a_buffer.m_placement += m_branches.internalSize();
        workingBuffer->incrementPlacement( sizeof( NuclideGammaBranchInfo ) * vectorSize );
    }
    for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
        m_branches[vectorIndex]->serialize( *workingBuffer, a_mode );
    }
 
    vectorSize = m_reactions.size( );
    vectorSizeInt = (int) vectorSize;
    DATA_MEMBER_INT( vectorSizeInt, *workingBuffer, a_mode );
    vectorSize = (std::size_t) vectorSizeInt;
 
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
        m_reactions.resize( vectorSize, &(workingBuffer->m_placement) );
        for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
            if (workingBuffer->m_placement != nullptr) {
                m_reactions[vectorIndex] = new(workingBuffer->m_placement) Reaction;
                workingBuffer->incrementPlacement( sizeof(Reaction));
            }
            else {
                m_reactions[vectorIndex] = new Reaction;
            }
        }
    }
    if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
        a_buffer.m_placement += m_reactions.internalSize();
        a_buffer.incrementPlacement( sizeof(Reaction) * vectorSize);
    }
    for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
        m_reactions[vectorIndex]->serialize( *workingBuffer, a_mode );
        m_reactions[vectorIndex]->updateProtareSingleInfo( this, vectorIndex );
    }
 
    vectorSize = m_orphanProducts.size( );
    vectorSizeInt = (int) vectorSize;
    DATA_MEMBER_INT( vectorSizeInt, *workingBuffer, a_mode );
    vectorSize = (std::size_t) vectorSizeInt;
 
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
        m_orphanProducts.resize( vectorSize, &(workingBuffer->m_placement) );
        for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
            if (workingBuffer->m_placement != nullptr) {
                m_orphanProducts[vectorIndex] = new(workingBuffer->m_placement) Reaction;
                workingBuffer->incrementPlacement( sizeof(Reaction));
            }
            else {
                m_orphanProducts[vectorIndex] = new Reaction;
            }
        }
    }
 
    if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
        a_buffer.m_placement += m_orphanProducts.internalSize( );
        a_buffer.incrementPlacement( sizeof( Reaction ) * vectorSize );
    }
 
    for( std::size_t vectorIndex = 0; vectorIndex < vectorSize; ++vectorIndex ) {
        m_orphanProducts[vectorIndex]->serialize( *workingBuffer, a_mode );
        m_orphanProducts[vectorIndex]->updateProtareSingleInfo( this, vectorIndex );
    }
 
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
        for( auto reactionIter = m_reactions.begin( ); reactionIter != m_reactions.end( ); ++reactionIter ) {
            (*reactionIter)->addOrphanProductToProductList( m_orphanProducts );
        }
    }
 
    DATA_MEMBER_CAST( m_isPhotoAtomic, *workingBuffer, a_mode, bool );
    DATA_MEMBER_CAST( m_continuousEnergy, *workingBuffer, a_mode, bool );
    DATA_MEMBER_CAST( m_fixedGrid, *workingBuffer, a_mode, bool );
    m_heatedCrossSections.serialize( *workingBuffer, a_mode );
    m_heatedMultigroupCrossSections.serialize( *workingBuffer, a_mode );
}

Referenced by serialize2().

setURR_index()

LUPI_HOST_DEVICE void MCGIDI::ProtareSingle::setURR_index ( int a_URR_index )

inline

Definition at line 1704 of file MCGIDI.hpp.

{ m_URR_index = a_URR_index; }

Referenced by MCGIDI::URR_protareInfos::setup().

setUserParticleIndex2()

LUPI_HOST void MCGIDI::ProtareSingle::setUserParticleIndex2	(	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 1655 of file MCGIDI_protare.cc.

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

Referenced by setUserParticleIndex2().

setUserParticleIndexViaIntid2()

LUPI_HOST void MCGIDI::ProtareSingle::setUserParticleIndexViaIntid2	(	int	a_particleIntid,
		int	a_userParticleIndex )

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

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 1670 of file MCGIDI_protare.cc.

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

Referenced by setUserParticleIndexViaIntid2().

sizeOf2()

LUPI_HOST_DEVICE long MCGIDI::ProtareSingle::sizeOf2 ( ) const

inline

Definition at line 1742 of file MCGIDI.hpp.

{ return sizeof(*this); }

temperatures()

LUPI_HOST_DEVICE Vector< double > MCGIDI::ProtareSingle::temperatures

(

std::size_t

a_index = 0

)

const

Returns the list of temperatures for this.

Parameters

a_index

[in] Index of the reqested ProtareSingle. Must be 0.

Returns

Vector of doubles.

Definition at line 1728 of file MCGIDI_protare.cc.

                                                                                     {
 
    if( a_index != 0 ) LUPI_THROW( "ProtareSingle::temperatures: a_index not 0." );
    if( m_continuousEnergy ) return( m_heatedCrossSections.temperatures( ) );
    return( m_heatedMultigroupCrossSections.temperatures( ) );
}

Referenced by MCGIDI::Protare::temperatures(), and temperatures().

threshold()

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

inline

Returns the threshold for the reaction at index a_index.

Definition at line 1711 of file MCGIDI.hpp.

upscatterModelACrossSection()

LUPI_HOST_DEVICE Vector< double > const & MCGIDI::ProtareSingle::upscatterModelACrossSection ( ) const

inline

Returns the value of the m_upscatterModelACrossSection.

Definition at line 1738 of file MCGIDI.hpp.

upscatterModelAGroupEnergies()

LUPI_HOST_DEVICE Vector< double > const & MCGIDI::ProtareSingle::upscatterModelAGroupEnergies ( ) const

inline

Returns a reference to the m_upscatterModelAGroupEnergies member.

Definition at line 1736 of file MCGIDI.hpp.

upscatterModelAGroupVelocities()

LUPI_HOST_DEVICE Vector< double > const & MCGIDI::ProtareSingle::upscatterModelAGroupVelocities ( ) const

inline

Returns a reference to the m_upscatterModelAGroupVelocities member.

Definition at line 1737 of file MCGIDI.hpp.

upscatterModelASupported()

LUPI_HOST_DEVICE bool MCGIDI::ProtareSingle::upscatterModelASupported ( ) const

inline

Returns the value of the m_upscatterModelASupported member.

Definition at line 1735 of file MCGIDI.hpp.

Referenced by sampleReaction().

URR_domainMax()

LUPI_HOST_DEVICE double MCGIDI::ProtareSingle::URR_domainMax ( ) const

inline

Definition at line 1708 of file MCGIDI.hpp.

{ return( m_URR_domainMax ); }

URR_domainMin()

LUPI_HOST_DEVICE double MCGIDI::ProtareSingle::URR_domainMin ( ) const

inline

Definition at line 1707 of file MCGIDI.hpp.

{ return( m_URR_domainMin ); }

URR_index()

LUPI_HOST_DEVICE int MCGIDI::ProtareSingle::URR_index ( ) const

inline

Definition at line 1703 of file MCGIDI.hpp.

{ return( m_URR_index ); }

Referenced by MCGIDI::URR_protareInfos::updateProtare().

---

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

• MCGIDI.hpp
• MCGIDI_headerSource.hpp
• MCGIDI_protare.cc