#include <MCGIDI.hpp>

Public Member Functions
LUPI_HOST_DEVICE	HeatedCrossSectionContinuousEnergy ()
LUPI_HOST	HeatedCrossSectionContinuousEnergy (SetupInfo &a_setupInfo, Transporting::MC const &a_settings, GIDI::Transporting::Particles const &a_particles, DomainHash const &a_domainHash, GIDI::Styles::TemperatureInfo const &a_temperatureInfo, std::vector< GIDI::Reaction const * > const &a_reactions, std::vector< GIDI::Reaction const * > const &a_orphanProducts, bool a_fixedGrid, bool a_zeroReactions)
LUPI_HOST_DEVICE	~HeatedCrossSectionContinuousEnergy ()
LUPI_HOST_DEVICE std::size_t	evaluationInfo (std::size_t a_hashIndex, double a_energy, double *a_energyFraction) const
LUPI_HOST HeatedReactionCrossSectionContinuousEnergy const *	reactionCrossSection (std::size_t a_index) const
LUPI_HOST_DEVICE double	temperature () const
LUPI_HOST_DEVICE double	minimumEnergy () const
LUPI_HOST_DEVICE double	maximumEnergy () const
LUPI_HOST_DEVICE std::size_t	numberOfReactions () const
LUPI_HOST_DEVICE std::size_t	thresholdOffset (std::size_t a_reactionIndex) const
LUPI_HOST_DEVICE double	threshold (std::size_t a_reactionIndex) 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 Vector< MCGIDI_FLOAT > &	totalCrossSection ()
LUPI_HOST_DEVICE double	crossSection (URR_protareInfos const &a_URR_protareInfos, int a_URR_index, std::size_t a_hashIndex, double a_energy, bool a_sampling=false) const
LUPI_HOST GIDI::Functions::XYs1d	crossSectionAsGIDI_XYs1d () const
LUPI_HOST_DEVICE double	reactionCrossSection (std::size_t a_reactionIndex, URR_protareInfos const &a_URR_protareInfos, int a_URR_index, std::size_t a_hashIndex, double a_energy, bool a_sampling=false) const
LUPI_HOST_DEVICE double	reactionCrossSection2 (std::size_t a_reactionIndex, URR_protareInfos const &a_URR_protareInfos, int a_URR_index, double a_energy, std::size_t a_energyIndex, double a_energyFraction, bool a_sampling=false) const
LUPI_HOST_DEVICE double	reactionCrossSection (std::size_t a_reactionIndex, URR_protareInfos const &a_URR_protareInfos, int a_URR_index, double a_energy) const
LUPI_HOST GIDI::Functions::XYs1d	reactionCrossSectionAsGIDI_XYs1d (std::size_t a_reactionIndex) const
LUPI_HOST_DEVICE double	depositionEnergy (std::size_t a_hashIndex, double a_energy) const
LUPI_HOST_DEVICE double	depositionMomentum (std::size_t a_hashIndex, double a_energy) const
LUPI_HOST_DEVICE double	productionEnergy (std::size_t a_hashIndex, double a_energy) const
LUPI_HOST_DEVICE double	gain (std::size_t a_hashIndex, double a_energy, int a_particleIndex) const
LUPI_HOST_DEVICE double	gainViaIntid (std::size_t a_hashIndex, double a_energy, 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_DEVICE Vector< double > const &	energies () const
LUPI_HOST void	print (ProtareSingle const *a_protareSingle, std::string const &a_indent, std::string const &a_iFormat, std::string const &a_energyFormat, std::string const &a_dFormat) const

Detailed Description

Definition at line 614 of file MCGIDI.hpp.

Constructor & Destructor Documentation

◆ HeatedCrossSectionContinuousEnergy() [1/2]

LUPI_HOST_DEVICE MCGIDI::HeatedCrossSectionContinuousEnergy::HeatedCrossSectionContinuousEnergy ( )

Definition at line 268 of file MCGIDI_heatedCrossSections.cc.

                                                                                         :
        m_temperature( 0.0 ),
        m_hashIndices( ),
        m_energies( ),
        m_totalCrossSection( ),
        m_depositionEnergy( ),
        m_depositionMomentum( ),
        m_productionEnergy( ),
        m_gains( ),
        m_URR_mode( Transporting::URR_mode::none ),
        m_reactionsInURR_region( ),
        m_reactionCrossSections( ),
        m_ACE_URR_probabilityTables( nullptr ) {
 
}

◆ HeatedCrossSectionContinuousEnergy() [2/2]

LUPI_HOST MCGIDI::HeatedCrossSectionContinuousEnergy::HeatedCrossSectionContinuousEnergy	(	SetupInfo &	a_setupInfo,
		Transporting::MC const &	a_settings,
		GIDI::Transporting::Particles const &	a_particles,
		DomainHash const &	a_domainHash,
		GIDI::Styles::TemperatureInfo const &	a_temperatureInfo,
		std::vector< GIDI::Reaction const * > const &	a_reactions,
		std::vector< GIDI::Reaction const * > const &	a_orphanProducts,
		bool	a_fixedGrid,
		bool	a_zeroReactions )

Fills in this with the requested temperature data.

Parameters

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_domainHash	[in] The hash data used when looking up a cross section.
a_temperatureInfo	[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_fixedGrid	[in] If true, the specified fixed grid is used; otherwise, grid in the file is used.
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 298 of file MCGIDI_heatedCrossSections.cc.

                                       :
        m_temperature( a_temperatureInfo.temperature( ).value( ) ),
        m_hashIndices( ),
        m_energies( ),
        m_totalCrossSection( ),
        m_depositionEnergy( ),
        m_depositionMomentum( ),
        m_productionEnergy( ),
        m_gains( ),
        m_URR_mode( Transporting::URR_mode::none ),
        m_reactionsInURR_region( ),
        m_reactionCrossSections( ),
        m_ACE_URR_probabilityTables( nullptr ) {
 
    bool isPhotoAtomic = a_setupInfo.m_protare.isPhotoAtomic( );
    std::string label( a_temperatureInfo.griddedCrossSection( ) );
    std::string URR_label( a_temperatureInfo.URR_probabilityTables( ) );
 
    GIDI::Styles::GriddedCrossSection const &griddedCrossSectionStyle = 
            static_cast<GIDI::Styles::GriddedCrossSection const &>( *a_settings.styles( )->get<GIDI::Styles::Base>( label ) );
    GIDI::Grid const &grid = griddedCrossSectionStyle.grid( );
 
    std::vector<double> const *energiesPointer;
    std::vector<double> const &energies = grid.data( ).vector();
    std::vector<double> const &fixedGridPoints = a_settings.fixedGridPoints( );
    std::vector<int> fixedGridIndices( fixedGridPoints.size( ) );
    if( a_fixedGrid ) {
        for( std::size_t i1 = 0; i1 < fixedGridPoints.size( ); ++i1 ) {
            fixedGridIndices[i1] = binarySearchVector( fixedGridPoints[i1], energies );
        }
        energiesPointer = &fixedGridPoints;
        m_energies = fixedGridPoints; }
    else {
        energiesPointer = &energies;
        m_energies = energies;
    }
 
    m_hashIndices = a_domainHash.map( m_energies );
 
    std::size_t reactionIndex = 0;
    GIDI::Axes axes;
    std::vector<double> dummy;
    GIDI::Functions::Ys1d totalCrossSection( axes, ptwXY_interpolationLinLin, 0, dummy );
    GIDI::Functions::Ys1d fixedGridCrossSection( axes, ptwXY_interpolationLinLin, 0, fixedGridPoints );
    m_reactionCrossSections.resize( a_reactions.size( ) );
    m_URR_mode = Transporting::URR_mode::none;
    for( std::vector<GIDI::Reaction const *>::const_iterator reactionIter = a_reactions.begin( ); reactionIter != a_reactions.end( ); ++reactionIter, ++reactionIndex ) {
        GIDI::Suite const &reactionCrossSectionSuite = (*reactionIter)->crossSection( );
        GIDI::Functions::Ys1d const *reactionCrossSection3 = reactionCrossSectionSuite.get<GIDI::Functions::Ys1d>( label );
        GIDI::Functions::Ys1d *reactionCrossSectionZeroReactions = nullptr;
        if( a_zeroReactions ) {
            reactionCrossSectionZeroReactions = new GIDI::Functions::Ys1d( *reactionCrossSection3 );
            for( std::size_t index = 0; index < reactionCrossSectionZeroReactions->size( ); ++index ) reactionCrossSectionZeroReactions->set( index, 0.0 );
            reactionCrossSection3 = reactionCrossSectionZeroReactions;
        }
 
        Probabilities::ProbabilityBase2d *URR_probabilityTables = nullptr;
        if( ( a_settings._URR_mode( ) == Transporting::URR_mode::pdfs ) && ( URR_label != "" ) ) {
            if( reactionCrossSectionSuite.has( URR_label ) ) {
                GIDI::Functions::URR_probabilityTables1d const &URR_probability_tables1d( *reactionCrossSectionSuite.get<GIDI::Functions::URR_probabilityTables1d>( URR_label ) );
                URR_probabilityTables = Probabilities::parseProbability2d( URR_probability_tables1d.function2d( ), nullptr );
                m_URR_mode = Transporting::URR_mode::pdfs;
            }
        }
 
        ACE_URR_probabilityTables *ACE_URR_probabilityTables1 = nullptr;
        if( a_settings._URR_mode( ) == Transporting::URR_mode::ACE_URR_probabilityTables ) {
            auto URR_iter = a_setupInfo.m_ACE_URR_probabilityTablesFromGIDI.find( URR_label );
            if( URR_iter != a_setupInfo.m_ACE_URR_probabilityTablesFromGIDI.end( ) ) {
                auto ACE_URR_probabilityTablesIter = (*URR_iter).second->m_ACE_URR_probabilityTables.find( (*reactionIter)->label( ) );
                if( ACE_URR_probabilityTablesIter != (*URR_iter).second->m_ACE_URR_probabilityTables.end( ) ) {
                    ACE_URR_probabilityTables1 = (*ACE_URR_probabilityTablesIter).second;
                    (*ACE_URR_probabilityTablesIter).second = nullptr;          // Set to nullptr so destructor of m_ACE_URR_probabilityTables does not delete.
                    m_URR_mode = Transporting::URR_mode::ACE_URR_probabilityTables;
                }
            }
        }
 
        if( a_fixedGrid ) {
            GIDI::Functions::Ys1d *reactionCrossSection4 = &fixedGridCrossSection;
 
            std::size_t start = 0;
 
            if( energies[reactionCrossSection3->start( )] > fixedGridPoints[0] ) {
                int intStart = binarySearchVector( energies[reactionCrossSection3->start( )], fixedGridPoints ) + 1;
                if (intStart < 0) {
                    throw std::out_of_range( "Cross section out of range when initializing fixed grid!" );
                }
                start = static_cast<std::size_t>( intStart );
            }
 
            for( std::size_t i1 = 0; i1 < start; ++i1 ) reactionCrossSection4->set( i1, 0.0 );
            for( std::size_t i1 = start; i1 < fixedGridPoints.size( ); ++i1 ) {
                std::size_t index = static_cast<std::size_t>( fixedGridIndices[i1] );
                double fraction = ( fixedGridPoints[i1] - energies[index] ) / ( energies[index+1] - energies[index] );
 
                index -= reactionCrossSection3->start( );
                reactionCrossSection4->set( i1, ( 1.0 - fraction ) * (*reactionCrossSection3)[index] + fraction * (*reactionCrossSection3)[index+1] );
            }
            reactionCrossSection3 = &fixedGridCrossSection;
        }
 
        m_reactionCrossSections[reactionIndex] = new HeatedReactionCrossSectionContinuousEnergy( (*reactionIter)->crossSectionThreshold( ), 
                *reactionCrossSection3, URR_probabilityTables, ACE_URR_probabilityTables1 );
        totalCrossSection += *reactionCrossSection3;
 
        delete reactionCrossSectionZeroReactions;
    }
    m_totalCrossSection.resize( totalCrossSection.length( ), 0.0 );
    for( std::size_t i1 = 0; i1 < totalCrossSection.size( ); ++i1 ) m_totalCrossSection[i1+totalCrossSection.start()] = totalCrossSection[i1];
 
    if( hasURR_probabilityTables( ) ) {
        std::vector<std::size_t> reactions_in_URR_region;
 
        for( reactionIndex = 0; reactionIndex < numberOfReactions( ); ++reactionIndex ) {
            if( m_reactionCrossSections[reactionIndex]->threshold( ) < URR_domainMax( ) ) {
                reactions_in_URR_region.push_back( reactionIndex );
            }
        }
 
        m_reactionsInURR_region.resize( reactions_in_URR_region.size( ) );
        for( std::size_t i1 = 0; i1 < reactions_in_URR_region.size( ); ++i1 ) m_reactionsInURR_region[i1] = reactions_in_URR_region[i1];
 
        if( a_settings._URR_mode( ) == Transporting::URR_mode::ACE_URR_probabilityTables ) {
            auto URR_iter = a_setupInfo.m_ACE_URR_probabilityTablesFromGIDI.find( URR_label );
            if( URR_iter != a_setupInfo.m_ACE_URR_probabilityTablesFromGIDI.end( ) ) {
                auto ACE_URR_probabilityTablesIter = (*URR_iter).second->m_ACE_URR_probabilityTables.find( "total" );
                if( ACE_URR_probabilityTablesIter != (*URR_iter).second->m_ACE_URR_probabilityTables.end( ) ) {
                    m_ACE_URR_probabilityTables = (*ACE_URR_probabilityTablesIter).second;
                    (*ACE_URR_probabilityTablesIter).second = nullptr;          // Set to nullptr so destructor of m_ACE_URR_probabilityTables does not delete.
                }
            }
        }
    }
 
    if( a_settings.addExpectedValueData( ) ) {
        m_depositionEnergy.resize( totalCrossSection.length( ), 0.0 );
        m_depositionMomentum.resize( totalCrossSection.length( ), 0.0 );
        m_productionEnergy.resize( totalCrossSection.length( ), 0.0 );
 
        m_gains.resize( a_particles.particles( ).size( ) );
        std::size_t i2 = 0;
        int projectileGainIndex = -1;
        int photonGainIndex = -1;
        for( std::map<std::string, GIDI::Transporting::Particle>::const_iterator particle = a_particles.particles( ).begin( ); particle != a_particles.particles( ).end( );
                        ++particle, ++i2 ) {
            int particleIntid = a_setupInfo.m_particleIntids[particle->first];
            int particleIndex = a_setupInfo.m_particleIndices[particle->first];
 
            if( particleIntid == a_setupInfo.m_protare.projectileIntid( ) ) projectileGainIndex = (int) i2;
            m_gains[i2] = new ContinuousEnergyGain( particleIntid, particleIndex, totalCrossSection.length( ) );
            if( particle->first == PoPI::IDs::photon ) photonGainIndex = (int) i2;
        }
 
        std::vector< std::vector<double> > gains( a_particles.particles( ).size( ) );
        for( std::size_t reactionIndex2 = 0; reactionIndex2 < a_reactions.size( ) + a_orphanProducts.size( ); ++reactionIndex2 ) {
 
            std::size_t offset = 0;
            std::vector<double> deposition_energy( m_energies.size( ), 0.0 );
            std::vector<double> deposition_momentum( m_energies.size( ), 0.0 );
            std::vector<double> production_energy( m_energies.size( ), 0.0 );
            for( std::size_t i1 = 0; i1 < gains.size( ); ++i1 ) gains[i1] = std::vector<double>( m_energies.size( ), 0.0 );
 
            HeatedReactionCrossSectionContinuousEnergy *MCGIDI_reaction_cross_section = nullptr;
            GIDI::Reaction const *reaction = nullptr;
            GIDI::Functions::Ys1d const *reactionCrossSection = nullptr;                // If nullptr, reaction is an orphanProduct node.
            GIDI::Functions::Function1dForm const *available_energy = nullptr;
            GIDI::Functions::Function1dForm const *available_momentum = nullptr;
            if( reactionIndex2 < a_reactions.size( ) ) {
                reaction = a_reactions[reactionIndex2];
                available_energy = reaction->availableEnergy( ).get<GIDI::Functions::Function1dForm>( 0 );
                available_momentum = reaction->availableMomentum( ).get<GIDI::Functions::Function1dForm>( 0 );
                MCGIDI_reaction_cross_section = m_reactionCrossSections[reactionIndex2];
                offset = MCGIDI_reaction_cross_section->offset( ); }
            else {
                reaction = a_orphanProducts[reactionIndex2-a_reactions.size( )];
                GIDI::Suite const &reactionCrossSectionSuite = reaction->crossSection( );
                reactionCrossSection = reactionCrossSectionSuite.get<GIDI::Functions::Ys1d>( label );
                offset = reactionCrossSection->start( );
            }
            if( a_settings.useSlowerContinuousEnergyConversion( ) ) {                   // Old way which is slow as it does one energy at a time.
                for( std::size_t energy_index = offset; energy_index < m_energies.size( ); ++energy_index ) {
                    double energy = m_energies[energy_index];
 
                    if( reactionCrossSection == nullptr ) {
                        if( isPhotoAtomic ) {                                           // Treat as Q = 0.0 since 2 photons will be emitted.
                            deposition_energy[energy_index] = energy; }
                        else {
                            deposition_energy[energy_index] = available_energy->evaluate( energy );
 
                            double Q = deposition_energy[energy_index] - energy;        // Should use Q node to get this.
                            if( fabs( Q ) < 1e-12 * deposition_energy[energy_index] )
                                    Q = 0.0;                                            // Probably 0.0 due to rounding errors.
                            production_energy[energy_index] = Q;
                        }
                        deposition_momentum[energy_index] = available_momentum->evaluate( energy );
                    }
 
                    std::size_t i1 = 0;
                    for( std::map<std::string, GIDI::Transporting::Particle>::const_iterator particle = a_particles.particles( ).begin( ); particle != a_particles.particles( ).end( ); 
                            ++particle, ++i1 ) {
                        double product_energy, product_momentum, product_gain;
 
                        if( particle->first == PoPI::IDs::electron ) continue;      // As of this coding, electrons are not complete in GNDS files.
                                                                                    // When they are, this statement can be removed.
                        if( ( reactionCrossSection != nullptr ) && ( particle->first != PoPI::IDs::photon ) ) continue;
 
                        if( reaction->isPairProduction( ) && ( particle->first == PoPI::IDs::photon ) ) {
                            product_energy = 2.0 * PoPI_electronMass_MeV_c2;        // Assumes energy unit is MeV.
                            product_momentum = 0.0;
                            product_gain = 2.0; }
                        else {
                            reaction->continuousEnergyProductData( a_settings, particle->first, energy, product_energy, product_momentum, 
                                    product_gain, true );
                        }
                        if( (int) i1 == projectileGainIndex ) --product_gain;
 
                        deposition_energy[energy_index] -= product_energy;
                        deposition_momentum[energy_index] -= product_momentum;
                        gains[i1][energy_index] = product_gain;
                    }
                } }
            else {                                                                  // New way which is hopefully faster.
                if( reactionCrossSection == nullptr ) {
                    if( isPhotoAtomic ) {                                           // Treat as Q = 0.0 since 2 photons will be emitted.
                        for( std::size_t energyIndex = offset; energyIndex < m_energies.size( ); ++energyIndex ) {
                            deposition_energy[energyIndex] = m_energies[energyIndex];
                        } }
                    else {
                        available_energy->mapToXsAndAdd( offset, *energiesPointer, deposition_energy, 1.0 );
                        for( std::size_t energyIndex = offset; energyIndex < m_energies.size( ); ++energyIndex ) {
                            double Q = deposition_energy[energyIndex] - m_energies[energyIndex];
                            if( fabs( Q ) < 1e-12 * deposition_energy[energyIndex] )
                                    Q = 0.0;                                            // Probably 0.0 due to rounding errors.
                            production_energy[energyIndex] = Q;
                        }
                    }
                    available_momentum->mapToXsAndAdd( offset, *energiesPointer, deposition_momentum, 1.0 );
                }
 
                std::size_t i1 = 0;
                for( std::map<std::string, GIDI::Transporting::Particle>::const_iterator particle = a_particles.particles( ).begin( );
                            particle != a_particles.particles( ).end( ); ++particle, ++i1 ) {
                    if( particle->first == PoPI::IDs::electron ) continue;      // As of this coding, electrons are not complete in GNDS files.
                                                                                // When they are, this statement can be removed.
                    if( ( reactionCrossSection != nullptr ) && ( particle->first != PoPI::IDs::photon ) ) continue;
 
                    if( reaction->isPairProduction( ) && ( particle->first == PoPI::IDs::photon ) ) {
                        for( std::size_t energyIndex = offset; energyIndex < m_energies.size( ); ++energyIndex ) {
                            deposition_energy[energyIndex] -= 2.0 * PoPI_electronMass_MeV_c2;    // Assumes energy unit is MeV.
                            gains[i1][energyIndex] = 2.0;
                        } }
                    else {
                        reaction->mapContinuousEnergyProductData( a_settings, particle->first, *energiesPointer, offset, deposition_energy, 
                                deposition_momentum, gains[i1], true );
                    }
 
                    if( (int) i1 == projectileGainIndex ) {
                        for( std::size_t energyIndex = offset; energyIndex < m_energies.size( ); ++energyIndex ) --gains[i1][energyIndex];
                    }
                }
            }
 
            if( a_particles.hasParticle( PoPI::IDs::photon ) ) {
                if( a_setupInfo.m_initialStateIndices.find( reaction->label( ) ) != a_setupInfo.m_initialStateIndices.end( ) ) {
                    int intInitialStateIndex = a_setupInfo.m_initialStateIndices[reaction->label( )];
                    if( intInitialStateIndex >= 0 ) {
                        std::size_t initialStateIndex = static_cast<std::size_t>( intInitialStateIndex );
                        NuclideGammaBranchStateInfo *nuclideGammaBranchStateInfo = a_setupInfo.m_protare.nuclideGammaBranchStateInfos( )[initialStateIndex];
                        double multiplicity = nuclideGammaBranchStateInfo->multiplicity( );
                        double averageGammaEnergy = nuclideGammaBranchStateInfo->averageGammaEnergy( );
 
                        for( std::size_t energyIndex = offset; energyIndex < m_energies.size( ); ++energyIndex ) {
                            deposition_energy[energyIndex] -= averageGammaEnergy;
                            if( photonGainIndex >= 0 ) gains[static_cast<std::size_t>(photonGainIndex)][energyIndex] += multiplicity;
                        }
                    }
                }
            }
 
            double crossSection = 0.0;
            for( std::size_t energyIndex = offset; energyIndex < m_energies.size( ); ++energyIndex ) {
                if( reactionCrossSection == nullptr ) {
                    crossSection = MCGIDI_reaction_cross_section->crossSection( energyIndex ); }
                else {
                    crossSection = (*reactionCrossSection)[energyIndex-offset];
                }
 
                m_depositionEnergy[energyIndex] += crossSection * deposition_energy[energyIndex];
                m_depositionMomentum[energyIndex] += crossSection * deposition_momentum[energyIndex];
                m_productionEnergy[energyIndex] += crossSection * production_energy[energyIndex];
                for( std::size_t i1 = 0; i1 < m_gains.size( ); ++i1 ) {
                    m_gains[i1]->adjustGain( energyIndex, crossSection * gains[i1][energyIndex] );
                }
            }
        }
    }
}

◆ ~HeatedCrossSectionContinuousEnergy()

LUPI_HOST_DEVICE MCGIDI::HeatedCrossSectionContinuousEnergy::~HeatedCrossSectionContinuousEnergy ( )

Definition at line 603 of file MCGIDI_heatedCrossSections.cc.

                                                                                          {
 
    for( auto iter = m_reactionCrossSections.begin( ); iter < m_reactionCrossSections.end( ); ++iter ) delete *iter;
    for( auto iter = m_gains.begin( ); iter < m_gains.end( ); ++iter ) delete *iter;
    delete m_ACE_URR_probabilityTables;
}

Member Function Documentation

◆ crossSection()

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

Definition at line 682 of file MCGIDI_heatedCrossSections.cc.

                                                                                                 {
 
    double energy_fraction;
    std::size_t energy_index = evaluationInfo( a_hashIndex, a_energy, &energy_fraction );
 
    if( a_URR_index >= 0 ) {
        URR_protareInfo const &URR_protare_info = a_URR_protareInfos[static_cast<std::size_t>(a_URR_index)];
 
        if( URR_protare_info.m_inURR ) {
            double cross_section = 0.0;
            for( std::size_t i1 = 0; i1 < m_reactionsInURR_region.size( ); ++i1 ) {
                cross_section += reactionCrossSection2( m_reactionsInURR_region[i1], a_URR_protareInfos, a_URR_index, a_energy, 
                        energy_index, energy_fraction, false );
            }
            return( cross_section );
        }
    }
 
    return( energy_fraction * m_totalCrossSection[energy_index] + ( 1.0 - energy_fraction ) * m_totalCrossSection[energy_index+1] );
}

Referenced by crossSectionAsGIDI_XYs1d(), and HeatedCrossSectionContinuousEnergy().

◆ crossSectionAsGIDI_XYs1d()

LUPI_HOST GIDI::Functions::XYs1d MCGIDI::HeatedCrossSectionContinuousEnergy::crossSectionAsGIDI_XYs1d ( ) const

Returns the total cross section as a GIDI::Functions::XYs1d instance.

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

Definition at line 770 of file MCGIDI_heatedCrossSections.cc.

                                                                                                 {
 
    std::vector<double> energies = vectorToSTD_vector( m_energies );
    std::vector<double> crossSection = vectorToSTD_vector( m_totalCrossSection );
 
    return( GIDI::Functions::XYs1d( GIDI::Axes( ), ptwXY_interpolationLinLin, energies, crossSection, 0, m_temperature ) );
}

Referenced by reactionCrossSectionAsGIDI_XYs1d().

◆ depositionEnergy()

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

Returns the index of a sampled reaction for 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 projectile energy hash index.
a_energy	[in] The energy of the projectile.

Definition at line 799 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                           {
 
    double energy_fraction;
    std::size_t energy_index = evaluationInfo( a_hashIndex, a_energy, &energy_fraction );
 
    return( energy_fraction * m_depositionEnergy[energy_index] + ( 1.0 - energy_fraction ) * m_depositionEnergy[energy_index+1] );
}

◆ depositionMomentum()

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

Returns the index of a sampled reaction for 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 projectile energy hash index.
a_energy	[in] The energy of the projectile.

Definition at line 815 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                             {
 
    double energy_fraction;
    std::size_t energy_index = evaluationInfo( a_hashIndex, a_energy, &energy_fraction );
 
    return( energy_fraction * m_depositionMomentum[energy_index] + ( 1.0 - energy_fraction ) * m_depositionMomentum[energy_index+1] );
}

◆ energies()

LUPI_HOST_DEVICE Vector< double > const & MCGIDI::HeatedCrossSectionContinuousEnergy::energies ( ) const

inline

Returns a reference to m_styles.

Definition at line 678 of file MCGIDI.hpp.

Referenced by crossSectionAsGIDI_XYs1d(), and HeatedCrossSectionContinuousEnergy().

◆ evaluationInfo()

LUPI_HOST_DEVICE std::size_t MCGIDI::HeatedCrossSectionContinuousEnergy::evaluationInfo	(	std::size_t	a_hashIndex,
		double	a_energy,
		double *	a_energyFraction ) const

This function returns the index in a_energies where a_energy lies between the returned index and the next index. The returned index must lie between a_hashIndices[a_hashIndex] and a_hashIndices[a_hashIndex+1]. If a_energy is below the domain of a_energies, 0 is returned. If a_energy is above the domain of a_energies, the size of a_energies minus 2 is returned. The argument a_energyFraction the weight for the energy at the returned index with the next index getting weighting 1 minus a_energyFraction.

Parameters

a_hashIndex	[in] Specifies projectile energy hash index.
a_energy	[in] The energy whose index is requested.
a_energyFraction	[in] This represents the weighting to apply to the two bounding energies.

Returns: The index bounding a_energy in the member m_energies.

Definition at line 626 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                                      {
 
    return Sampling::evaluationForHashIndex( a_hashIndex, m_hashIndices, a_energy, m_energies, a_energyFraction );
}

Referenced by crossSection(), depositionEnergy(), depositionMomentum(), gain(), gainViaIntid(), productionEnergy(), and MCGIDI::HeatedCrossSectionsContinuousEnergy::sampleReaction().

◆ gain()

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

Returns the gain for the particle with index a_particleIndex for projectile energy a_energy.

Parameters

a_hashIndex	[in] Specifies projectile energy hash index.
a_energy	[in] The energy of the projectile.
a_particleIndex	[in] The index of the particle whose gain is requested.

Definition at line 847 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                    {
 
    double energy_fraction;
    std::size_t energy_index = evaluationInfo( a_hashIndex, a_energy, &energy_fraction );
 
    for( std::size_t i1 = 0; i1 < m_gains.size( ); ++i1 ) {
        if( a_particleIndex == m_gains[i1]->particleIndex( ) ) return( m_gains[i1]->gain( energy_index, energy_fraction ) );
    }
 
    return( 0.0 );
}

Referenced by gain(), and gainViaIntid().

◆ gainViaIntid()

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

Returns the gain for the particle with intid a_particleIntid for projectile energy a_energy.

Parameters

a_hashIndex	[in] Specifies projectile energy hash index.
a_energy	[in] The energy of the projectile.
a_particleIntid	[in] The intid of the particle whose gain is requested.

Definition at line 867 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                            {
 
    double energy_fraction;
    std::size_t energy_index = evaluationInfo( a_hashIndex, a_energy, &energy_fraction );
 
    for( std::size_t i1 = 0; i1 < m_gains.size( ); ++i1 ) {
        if( a_particleIntid == m_gains[i1]->particleIntid( ) ) return( m_gains[i1]->gain( energy_index, energy_fraction ) );
    }
 
    return( 0.0 );
}

◆ hasURR_probabilityTables()

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

Returns true if this has a unresolved resonance region (URR) data and false otherwise.

Returns: true is if this has a URR data.

Definition at line 637 of file MCGIDI_heatedCrossSections.cc.

                                                                                          {
 
    return( m_URR_mode != Transporting::URR_mode::none );
}

Referenced by HeatedCrossSectionContinuousEnergy(), and reactionHasURR_probabilityTables().

◆ maximumEnergy()

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

inline

Returns the maximum cross section domain.

Definition at line 645 of file MCGIDI.hpp.

◆ minimumEnergy()

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

inline

Returns the minimum cross section domain.

Definition at line 644 of file MCGIDI.hpp.

◆ numberOfReactions()

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

inline

Returns the number of reaction cross section.

Definition at line 646 of file MCGIDI.hpp.

Referenced by HeatedCrossSectionContinuousEnergy().

◆ print()

LUPI_HOST void MCGIDI::HeatedCrossSectionContinuousEnergy::print	(	ProtareSingle const *	a_protareSingle,
		std::string const &	a_indent,
		std::string const &	a_iFormat,
		std::string const &	a_energyFormat,
		std::string const &	a_dFormat ) const

Print to std::cout the content of this. This is mainly meant for debugging.

Parameters

a_protareSingle	[in] The ProtareSingle instance this resides in.
a_indent	[in] The buffer to read or write data to depending on a_mode.
a_iFormat	[in] C printf format specifier for any interger that is printed (e.g., "%3d").
a_energyFormat	[in] C printf format specifier for any interger that is printed (e.g., "%20.12e").
a_dFormat	[in] C printf format specifier for any interger that is printed (e.g., "%14.7e").

Definition at line 979 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                {
 
    char const *dFormat = a_dFormat.c_str( );
    std::string indent2 = a_indent + "  ";
    std::string lineFormat = indent2 + a_energyFormat + " " + a_dFormat + " " + a_dFormat + " " + a_dFormat + " " + a_dFormat;
 
    std::cout << std::endl;
    std::cout << a_indent << "# Temperature = " << LUPI::Misc::doubleToString3( dFormat, m_temperature, true ) << std::endl;
 
    std::cout << a_indent << "# Number of hash indices = " << m_hashIndices.size( ) << std::endl;
    for( auto iter = m_hashIndices.begin( ); iter != m_hashIndices.end( ); ++iter )
        std::cout << indent2 << LUPI::Misc::argumentsToString( a_iFormat.c_str( ), *iter ) << std::endl;
    std::cout << std::endl;
    std::size_t energySize = m_energies.size( );
    std::cout << a_indent << "# Number of energies = " << m_energies.size( ) << std::endl;
    std::cout << "#      projectile              total              deposition           deposition          production" << std::endl;
    std::cout << "#        energy             cross section           energy              momentum             energy"<< std::endl;
    std::cout << "#====================================================================================================="<< std::endl;
    for( std::size_t index = 0; index != energySize; ++index ) {
        std::cout << LUPI::Misc::argumentsToString( lineFormat.c_str( ), m_energies[index], m_totalCrossSection[index], m_depositionEnergy[index], 
                m_depositionMomentum[index], m_productionEnergy[index] ) << std::endl;
    }
 
    for( auto iter = m_gains.begin( ); iter != m_gains.end( ); ++iter ) (*iter)->print( a_protareSingle, a_indent, a_iFormat, a_energyFormat, a_dFormat );
 
    std::cout << std::endl;
    std::cout << "# URR mode is ";
    if( m_URR_mode == Transporting::URR_mode::none ) {
        std::cout << "none" << std::endl; }
    else if( m_URR_mode == Transporting::URR_mode::pdfs ) {
        std::cout << "pdfs" << std::endl; }
    else if( m_URR_mode == Transporting::URR_mode::ACE_URR_probabilityTables ) {
        std::cout << "ACE style protability tables" << std::endl; }
    else {
        std::cout << "Oops, need to code into print method." << std::endl;
    }
 
    std::cout << a_indent << "# Index of reactions in URR region:";
    for( auto reactionIter = m_reactionsInURR_region.begin( ); reactionIter != m_reactionsInURR_region.end( ); ++reactionIter ) {
        std::cout << indent2 << LUPI::Misc::argumentsToString( a_iFormat.c_str( ), *reactionIter ) << std::endl;
    }
    std::cout << std::endl;
 
    std::size_t reactionIndex = 0;
    std::cout << std::endl;
    std::cout << a_indent << "# Number of reactions = " << m_reactionCrossSections.size( ) << std::endl;
    for( auto iter = m_reactionCrossSections.begin( ); iter != m_reactionCrossSections.end( ); ++iter, ++reactionIndex ) {
        Reaction const *reaction = a_protareSingle->reaction( reactionIndex );
 
        std::cout << a_indent << "# Reaction number " << reactionIndex << std::endl;
        std::cout << a_indent << "# Reaction label: " << reaction->label( ).c_str( ) << std::endl;
        (*iter)->print( a_protareSingle, a_indent, a_iFormat, a_energyFormat, a_dFormat );
    }
}

◆ productionEnergy()

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

Returns the index of a sampled reaction for 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 projectile energy hash index.
a_energy	[in] The energy of the projectile.

Definition at line 831 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                           {
 
    double energy_fraction;
    std::size_t energy_index = evaluationInfo( a_hashIndex, a_energy, &energy_fraction );
 
    return( energy_fraction * m_productionEnergy[energy_index] + ( 1.0 - energy_fraction ) * m_productionEnergy[energy_index+1] );
}

◆ reactionCrossSection() [1/3]

LUPI_HOST HeatedReactionCrossSectionContinuousEnergy const * MCGIDI::HeatedCrossSectionContinuousEnergy::reactionCrossSection ( std::size_t a_index ) const

inline

Returns the reaction cross section at index a_index.

Definition at line 640 of file MCGIDI.hpp.

Referenced by HeatedCrossSectionContinuousEnergy(), URR_domainMax(), and URR_domainMin().

◆ reactionCrossSection() [2/3]

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionContinuousEnergy::reactionCrossSection	(	std::size_t	a_reactionIndex,
		URR_protareInfos const &	a_URR_protareInfos,
		int	a_URR_index,
		double	a_energy ) const

Definition at line 742 of file MCGIDI_heatedCrossSections.cc.

                                                                                                        {
 
    int intEnergyIndex = binarySearchVector( a_energy_in, m_energies );
    std::size_t energyIndex = static_cast<std::size_t>( intEnergyIndex );
    double energyFraction;
 
    if( intEnergyIndex < 0 ) {
        if( intEnergyIndex == -1 ) {
            energyIndex = m_energies.size( ) - 2;
            energyFraction = 0.0; }
        else {
            energyIndex = 0;
            energyFraction = 1.0;
        } }
    else {
        energyFraction = ( m_energies[energyIndex+1] - a_energy_in ) / ( m_energies[energyIndex+1] - m_energies[energyIndex] );
    }
 
    return( reactionCrossSection2( a_reactionIndex, a_URR_protareInfos, a_URR_index, a_energy_in, energyIndex, energyFraction, false ) );
}

◆ reactionCrossSection() [3/3]

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

◆ reactionCrossSection2()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionContinuousEnergy::reactionCrossSection2	(	std::size_t	a_reactionIndex,
		URR_protareInfos const &	a_URR_protareInfos,
		int	a_URR_index,
		double	a_energy,
		std::size_t	a_energyIndex,
		double	a_energyFraction,
		bool	a_sampling = false ) const

Definition at line 717 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                             {
 
    HeatedReactionCrossSectionContinuousEnergy const &reaction = *m_reactionCrossSections[a_reactionIndex];
    double URR_cross_section_factor = 1.0;
 
    if( a_URR_index >= 0 ) {
        URR_protareInfo const &URR_protare_info = a_URR_protareInfos[static_cast<std::size_t>(a_URR_index)];
        if( URR_protare_info.m_inURR ) {
            if( m_URR_mode == Transporting::URR_mode::pdfs ) {
                if( reaction.URR_probabilityTables( ) != nullptr )
                    URR_cross_section_factor = reaction.URR_probabilityTables( )->sample( a_energy, URR_protare_info.m_rng_Value, []() -> double { return 0.0; } ); }
            else if( m_URR_mode == Transporting::URR_mode::ACE_URR_probabilityTables ) {
                if( reaction._ACE_URR_probabilityTables( ) != nullptr ) 
                    URR_cross_section_factor = reaction._ACE_URR_probabilityTables( )->sample( a_energy, URR_protare_info.m_rng_Value );
            }
        }
    }
 
    return( URR_cross_section_factor * ( a_energyFraction * reaction.crossSection( a_energyIndex ) + ( 1.0 - a_energyFraction ) * reaction.crossSection( a_energyIndex + 1 ) ) );
}

Referenced by crossSection(), reactionCrossSection(), and MCGIDI::HeatedCrossSectionsContinuousEnergy::sampleReaction().

◆ reactionCrossSectionAsGIDI_XYs1d()

LUPI_HOST GIDI::Functions::XYs1d MCGIDI::HeatedCrossSectionContinuousEnergy::reactionCrossSectionAsGIDI_XYs1d ( std::size_t a_reactionIndex ) const

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

Parameters

a_reactionIndex [in] Specifies the indexs of the reaction whose cross section is requested.

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

Definition at line 786 of file MCGIDI_heatedCrossSections.cc.

                                                                                                                                   {
 
    return( m_reactionCrossSections[a_reactionIndex]->crossSectionAsGIDI_XYs1d( m_temperature, m_energies ) );
}

◆ reactionHasURR_probabilityTables()

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

inline

Definition at line 656 of file MCGIDI.hpp.

656{ return( m_reactionCrossSections[a_index]->hasURR_probabilityTables( ) ); }

◆ serialize()

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

                                                                                                                         {
 
    DATA_MEMBER_DOUBLE( m_temperature, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_SIZE_T( m_hashIndices, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_DOUBLE( m_energies, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_FLOAT_OR_DOUBLE( m_totalCrossSection, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_FLOAT_OR_DOUBLE( m_depositionEnergy, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_FLOAT_OR_DOUBLE( m_depositionMomentum, a_buffer, a_mode );
    DATA_MEMBER_VECTOR_FLOAT_OR_DOUBLE( m_productionEnergy, a_buffer, a_mode );
    m_URR_mode = serializeURR_mode( m_URR_mode,  a_buffer, a_mode );
    DATA_MEMBER_VECTOR_SIZE_T( m_reactionsInURR_region, a_buffer, a_mode );
    m_ACE_URR_probabilityTables = serializeACE_URR_probabilityTables( m_ACE_URR_probabilityTables, a_buffer, a_mode );
 
    std::size_t vectorSize = m_reactionCrossSections.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_reactionCrossSections.resize( vectorSize, &a_buffer.m_placement );
    if( a_mode == LUPI::DataBuffer::Mode::Memory ) a_buffer.m_placement += m_reactionCrossSections.internalSize();
    for( std::size_t memberIndex = 0; memberIndex < vectorSize; ++memberIndex ) {
        if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
            if( a_buffer.m_placement != nullptr ) {
                m_reactionCrossSections[memberIndex] = new(a_buffer.m_placement) HeatedReactionCrossSectionContinuousEnergy;
                a_buffer.incrementPlacement( sizeof( HeatedReactionCrossSectionContinuousEnergy ) ); }
            else {
                m_reactionCrossSections[memberIndex] = new HeatedReactionCrossSectionContinuousEnergy;
            }
        }
        if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
            a_buffer.incrementPlacement( sizeof( HeatedReactionCrossSectionContinuousEnergy ) );
        }
        m_reactionCrossSections[memberIndex]->serialize( a_buffer, a_mode );
    }
 
    vectorSize = m_gains.size( );
    vectorSizeInt = (int) vectorSize;
    DATA_MEMBER_INT( vectorSizeInt, a_buffer, a_mode );
    vectorSize = (std::size_t) vectorSizeInt;
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) m_gains.resize( vectorSize, &a_buffer.m_placement );
    if( a_mode == LUPI::DataBuffer::Mode::Memory ) a_buffer.m_placement += m_gains.internalSize();
    for( std::size_t memberIndex = 0; memberIndex < vectorSize; ++memberIndex ) {
        if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
            if( a_buffer.m_placement != nullptr ) {
                m_gains[memberIndex] = new(a_buffer.m_placement) ContinuousEnergyGain;
                a_buffer.incrementPlacement( sizeof( ContinuousEnergyGain ) ); }
            else {
                m_gains[memberIndex] = new ContinuousEnergyGain;
            }
        }
 
        if( a_mode == LUPI::DataBuffer::Mode::Memory ) {
            a_buffer.incrementPlacement( sizeof( ContinuousEnergyGain ) );
        }
        m_gains[memberIndex]->serialize( a_buffer, a_mode );
    }
}

◆ setUserParticleIndex()

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

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

◆ setUserParticleIndexViaIntid()

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

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

◆ temperature()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionContinuousEnergy::temperature ( ) const

inline

Returns the value of the m_temperature member.

Definition at line 643 of file MCGIDI.hpp.

Referenced by HeatedCrossSectionContinuousEnergy().

◆ threshold()

LUPI_HOST_DEVICE double MCGIDI::HeatedCrossSectionContinuousEnergy::threshold ( std::size_t a_reactionIndex ) const

inline

Returns the threshold for the reaction with index a_reactionIndex.

Definition at line 651 of file MCGIDI.hpp.

Referenced by HeatedCrossSectionContinuousEnergy(), and threshold().

◆ thresholdOffset()

LUPI_HOST_DEVICE std::size_t MCGIDI::HeatedCrossSectionContinuousEnergy::thresholdOffset ( std::size_t a_reactionIndex ) const

inline

Returns the offset for the cross section for the reaction with index a_reactionIndex.

Definition at line 649 of file MCGIDI.hpp.

◆ totalCrossSection()

LUPI_HOST_DEVICE Vector< MCGIDI_FLOAT > & MCGIDI::HeatedCrossSectionContinuousEnergy::totalCrossSection ( )

inline

Returns a reference to member m_totalCrossSection.

Definition at line 658 of file MCGIDI.hpp.

Referenced by HeatedCrossSectionContinuousEnergy().

◆ URR_domainMax()

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

Returns the maximum energy for the unresolved resonance region (URR) domain. If no URR data present, returns -1.

Returns: true is if this has a URR data.

Definition at line 667 of file MCGIDI_heatedCrossSections.cc.

                                                                                 {
 
    if( m_ACE_URR_probabilityTables != nullptr ) return( m_ACE_URR_probabilityTables->domainMax( ) );
 
    for( std::size_t i1 = 0; i1 < m_reactionCrossSections.size( ); ++i1 ) {
        HeatedReactionCrossSectionContinuousEnergy *reactionCrossSection = m_reactionCrossSections[i1];
 
        if( reactionCrossSection->hasURR_probabilityTables( ) ) return( reactionCrossSection->URR_domainMax( ) );
    }
 
    return( -1.0 );
}

Referenced by HeatedCrossSectionContinuousEnergy().

◆ URR_domainMin()

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

Returns the minimum energy for the unresolved resonance region (URR) domain. If no URR data present, returns -1.

Returns: true is if this has a URR data.

Definition at line 648 of file MCGIDI_heatedCrossSections.cc.

                                                                                 {
 
    if( m_ACE_URR_probabilityTables != nullptr ) return( m_ACE_URR_probabilityTables->domainMin( ) );
 
    for( std::size_t i1 = 0; i1 < m_reactionCrossSections.size( ); ++i1 ) {
        HeatedReactionCrossSectionContinuousEnergy *reactionCrossSection = m_reactionCrossSections[i1];
 
        if( reactionCrossSection->hasURR_probabilityTables( ) ) return( reactionCrossSection->URR_domainMin( ) );
    }
 
    return( -1.0 );
}

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ HeatedCrossSectionContinuousEnergy() [1/2]

◆ HeatedCrossSectionContinuousEnergy() [2/2]

◆ ~HeatedCrossSectionContinuousEnergy()

Member Function Documentation

◆ crossSection()

◆ crossSectionAsGIDI_XYs1d()

◆ depositionEnergy()

◆ depositionMomentum()

◆ energies()

◆ evaluationInfo()

◆ gain()

◆ gainViaIntid()

◆ hasURR_probabilityTables()

◆ maximumEnergy()

◆ minimumEnergy()

◆ numberOfReactions()

◆ print()

◆ productionEnergy()

◆ reactionCrossSection() [1/3]

◆ reactionCrossSection() [2/3]

◆ reactionCrossSection() [3/3]

◆ reactionCrossSection2()

◆ reactionCrossSectionAsGIDI_XYs1d()

◆ reactionHasURR_probabilityTables()

◆ serialize()

◆ setUserParticleIndex()

◆ setUserParticleIndexViaIntid()

◆ temperature()

◆ threshold()

◆ thresholdOffset()

◆ totalCrossSection()

◆ URR_domainMax()

◆ URR_domainMin()