#include <MCGIDI.hpp>

Public Member Functions
LUPI_HOST_DEVICE	OutputChannel ()
LUPI_HOST	OutputChannel (GIDI::OutputChannel const *a_outputChannel, SetupInfo &a_setupInfo, Transporting::MC const &a_settings, GIDI::Transporting::Particles const &a_particles)
LUPI_HOST_DEVICE	~OutputChannel ()
LUPI_HOST_DEVICE Product *	operator[] (std::size_t a_index)
LUPI_HOST_DEVICE bool	isTwoBody () const
LUPI_HOST_DEVICE double	finalQ (double a_x1) const
LUPI_HOST_DEVICE bool	isFission () const
LUPI_HOST_DEVICE bool	hasFission () const
LUPI_HOST_DEVICE Functions::Function1d_d1 *	Q ()
LUPI_HOST void	setUserParticleIndex (int a_particleIndex, int a_userParticleIndex)
LUPI_HOST void	setUserParticleIndexViaIntid (int a_particleIntid, int a_userParticleIndex)
LUPI_HOST void	setModelDBRC_data (Sampling::Upscatter::ModelDBRC_data *a_modelDBRC_data)
LUPI_HOST_DEVICE Vector< Product * > const &	products () const
Vector< DelayedNeutron * >	delayedNeutrons () const
LUPI_HOST_DEVICE DelayedNeutron const *	delayedNeutron (std::size_t a_index) const
LUPI_HOST void	moveProductsEtAlToReaction (std::vector< Product * > &a_products, Functions::Function1d *a_totalDelayedNeutronMultiplicity, std::vector< DelayedNeutron > &a_delayedNeutrons, std::vector< Functions::Function1d_d1 * > &a_Qs)
LUPI_HOST_DEVICE double	productAverageMultiplicity (int a_index, double a_projectileEnergy) const
LUPI_HOST_DEVICE double	productAverageMultiplicityViaIntid (int a_intid, double a_projectileEnergy) const
template<typename RNG, typename PUSHBACK>
LUPI_HOST_DEVICE void	sampleProducts (ProtareSingle const *a_protare, double a_projectileEnergy, Sampling::Input &a_input, RNG &&a_rng, PUSHBACK &&a_push_back, Sampling::ProductHandler &a_products) const
template<typename RNG>
LUPI_HOST_DEVICE void	angleBiasing (Reaction const *a_reaction, int a_pid, double a_temperature, double a_energy_in, double a_mu_lab, double &a_probability, double &a_energy_out, RNG &&a_rng, double &a_cumulative_weight) const
template<typename RNG>
LUPI_HOST_DEVICE void	angleBiasingViaIntid (Reaction const *a_reaction, int a_intid, double a_temperature, double a_energy_in, double a_mu_lab, double &a_probability, double &a_energy_out, RNG &&a_rng, double &a_cumulative_weight) const
LUPI_HOST_DEVICE void	serialize (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)

Detailed Description

Definition at line 1272 of file MCGIDI.hpp.

Constructor & Destructor Documentation

◆ OutputChannel() [1/2]

LUPI_HOST_DEVICE MCGIDI::OutputChannel::OutputChannel ( )

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

Definition at line 23 of file MCGIDI_outputChannel.cc.

                                               :
        m_channelType( ChannelType::none ),
        m_neutronIndex( -1 ),
        m_isFission( false ),
        m_hasFinalStatePhotons( false ),
        m_Q( nullptr ),
        m_products( ),
        m_totalDelayedNeutronMultiplicity( nullptr ) {
 
}

◆ OutputChannel() [2/2]

LUPI_HOST MCGIDI::OutputChannel::OutputChannel	(	GIDI::OutputChannel const *	a_outputChannel,
		SetupInfo &	a_setupInfo,
		Transporting::MC const &	a_settings,
		GIDI::Transporting::Particles const &	a_particles )

Parameters

a_outputChannel	[in] The GIDI::OutputChannel whose data is to be used to construct this.
a_setupInfo	[in] Used internally when constructing a Protare to pass information to other constructors.
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).

Definition at line 41 of file MCGIDI_outputChannel.cc.

                                                               :
        m_channelType( ChannelType::none ),
        m_neutronIndex( a_setupInfo.m_neutronIndex ),
        m_isFission( false ),
        m_hasFinalStatePhotons( false ),
        m_Q( nullptr ),
        m_products( ),
        m_totalDelayedNeutronMultiplicity( nullptr ) {
 
    if( a_outputChannel != nullptr ) {
        m_channelType = a_outputChannel->twoBody( ) ? ChannelType::twoBody : ChannelType::uncorrelatedBodies;
        m_isFission = a_outputChannel->isFission( );
 
        m_Q = Functions::parseFunction1d_d1( a_outputChannel->Q( ).get<GIDI::Functions::Function1dForm>( 0 ) );
        if( a_setupInfo.m_isPairProduction ) {
            double domainMin = m_Q->domainMin( ), domainMax = m_Q->domainMax( );
 
            delete m_Q;
            m_Q = new Functions::Constant1d( domainMin, domainMax, 0.0 );
        }
        a_setupInfo.m_Q = m_Q->evaluate( 0 );                                  // Needed for NBodyPhaseSpace.
 
        GIDI::Suite const &products = a_outputChannel->products( );
        if( m_channelType == ChannelType::twoBody ) {
            if( !a_setupInfo.m_protare.isTNSL_ProtareSingle( ) ) {
                GIDI::Product const *product = products.get<GIDI::Product>( 1 );
                a_setupInfo.m_product2Mass = product->particle( ).mass( "MeV/c**2" );         // Includes nuclear excitation energy.
            }
        }
 
        bool electronPresent = false;
        std::size_t size = 0;
        std::set<std::size_t> productsToDo;
        for( std::size_t i1 = 0; i1 < a_outputChannel->products( ).size( ); ++i1 ) {
            GIDI::Product const *product = products.get<GIDI::Product>( i1 );
 
            if( product->particle( ).ID( ) == PoPI::IDs::electron ) electronPresent = true;
            if( electronPresent && !a_setupInfo.m_isPhotoAtomicIncoherentScattering ) continue;
            if( !electronPresent && !product->isCompleteParticle( ) && ( product->outputChannel( ) == nullptr ) ) continue;
 
            if( ( product->outputChannel( ) != nullptr ) || a_settings.sampleNonTransportingParticles( ) || a_particles.hasParticle( product->particle( ).ID( ) ) )
                productsToDo.insert( i1 );
        }
        size = productsToDo.size( );
        if( a_setupInfo.m_isPairProduction ) {
            size += 2;
            size = 2;                               // This is a kludge until the ENDL to GNDS translator is fixed.
        }
 
        bool addIncoherentPhotoAtomicScatteringElectron = false;
        if( a_setupInfo.m_isPhotoAtomicIncoherentScattering && a_particles.hasParticle( PoPI::IDs::electron ) ) {   // May need to add electron for legacy GNDS files.
            if( !electronPresent ) {
// FIXME: BRB 7/Nov/2024, Why is an electron added, this is incoherent atomic scattering which does not emit an electron?
                addIncoherentPhotoAtomicScatteringElectron = true;
                ++size;
            }
        }
        m_products.reserve( size );
 
        if( a_setupInfo.m_isPairProduction ) {
            std::string ID( PoPI::IDs::photon );
            std::string label = ID;
 
            Product *product = new Product( a_setupInfo.m_popsUser, ID, label );
            product->setMultiplicity( new Functions::Constant1d( a_setupInfo.m_domainMin, a_setupInfo.m_domainMax, 1.0, 0.0 ) );
            product->distribution( new Distributions::PairProductionGamma( a_setupInfo, true ) );
            m_products.push_back( product );
 
            label += "__a";
            product = new Product( a_setupInfo.m_popsUser, ID, label );
            product->setMultiplicity( new Functions::Constant1d( a_setupInfo.m_domainMin, a_setupInfo.m_domainMax, 1.0, 0.0 ) );
            product->distribution( new Distributions::PairProductionGamma( a_setupInfo, false ) );
            m_products.push_back( product );
        }
 
        for( std::size_t i1 = 0; i1 < a_outputChannel->products( ).size( ); ++i1 ) {
            if( productsToDo.find( i1 ) == productsToDo.end( ) ) continue;
 
            GIDI::Product const *product = products.get<GIDI::Product>( i1 );
 
            if( a_setupInfo.m_isPairProduction ) {
                if( !a_settings.sampleNonTransportingParticles( ) ) continue;
                if( a_setupInfo.m_protare.targetIntid( ) != MCGIDI_popsIntid( a_setupInfo.m_pops, product->particle( ).ID( ) ) ) continue;
            }
            a_setupInfo.m_twoBodyOrder = TwoBodyOrder::notApplicable;
            if( m_channelType == ChannelType::twoBody ) a_setupInfo.m_twoBodyOrder = ( ( i1 == 0 ? TwoBodyOrder::firstParticle : TwoBodyOrder::secondParticle ) );
            m_products.push_back( new Product( product, a_setupInfo, a_settings, a_particles, m_isFission ) );
 
            if( addIncoherentPhotoAtomicScatteringElectron && ( product->particle( ).ID( ) == PoPI::IDs::photon ) ) {
                addIncoherentPhotoAtomicScatteringElectron = false;
 
                Product *product2 = new Product( a_setupInfo.m_pops, PoPI::IDs::electron, PoPI::IDs::electron );
                product2->setMultiplicity( new Functions::Constant1d( a_setupInfo.m_domainMin, a_setupInfo.m_domainMax, 1.0, 0.0 ) );
                product2->distribution( new Distributions::IncoherentPhotoAtomicScatteringElectron( a_setupInfo ) );
                m_products.push_back( product2 );
            }
        }
 
        if( ( a_settings.delayedNeutrons( ) == GIDI::Transporting::DelayedNeutrons::on ) && a_particles.hasParticle( PoPI::IDs::neutron ) ) {
            GIDI::FissionFragmentData const &fissionFragmentData = a_outputChannel->fissionFragmentData( );
            GIDI::Suite const &delayedNeutrons = fissionFragmentData.delayedNeutrons( );
 
            if( delayedNeutrons.size( ) > 0 ) {
                bool missingData = false;
                GIDI::Axes axes;
                GIDI::Functions::XYs1d totalDelayedNeutronMultiplicity( axes, ptwXY_interpolationLinLin );
 
                m_delayedNeutrons.reserve( delayedNeutrons.size( ) );
                for( std::size_t i1 = 0; i1 < delayedNeutrons.size( ); ++i1 ) {
                    GIDI::DelayedNeutron const *delayedNeutron = delayedNeutrons.get<GIDI::DelayedNeutron>( i1 );
                    GIDI::Product const &product = delayedNeutron->product( );
                    GIDI::Suite const &multiplicity = product.multiplicity( );
 
                    GIDI::Functions::Function1dForm const *form1d = multiplicity.get<GIDI::Functions::Function1dForm>( 0 );
 
                    if( form1d->type( ) == GIDI::FormType::unspecified1d ) {
                        missingData = true;
                        break;
                    }
 
                    if( form1d->type( ) != GIDI::FormType::XYs1d ) {
                        std::cerr << "OutputChannel::OutputChannel: GIDI::DelayedNeutron multiplicity type != GIDI::FormType::XYs1d" << std::endl;
                        missingData = true;
                        break;
                    }
 
                    GIDI::Functions::XYs1d const *multiplicityXYs1d = static_cast<GIDI::Functions::XYs1d const *>( form1d );
                    totalDelayedNeutronMultiplicity += *multiplicityXYs1d;
 
                    m_delayedNeutrons.push_back( new DelayedNeutron( static_cast<int>( i1 ), delayedNeutron, a_setupInfo, a_settings, a_particles ) );
                }
                if( !missingData ) m_totalDelayedNeutronMultiplicity = new Functions::XYs1d( totalDelayedNeutronMultiplicity );
            }
        }
 
        m_hasFinalStatePhotons = a_setupInfo.m_hasFinalStatePhotons;
    }
}

◆ ~OutputChannel()

LUPI_HOST_DEVICE MCGIDI::OutputChannel::~OutputChannel ( )

Definition at line 184 of file MCGIDI_outputChannel.cc.

                                                {
 
    delete m_Q;
    for( std::size_t i1 = 0; i1 < m_products.size( ); ++i1 ) delete m_products[i1];
 
    delete m_totalDelayedNeutronMultiplicity;
    for( std::size_t i1 = 0; i1 < m_delayedNeutrons.size( ); ++i1 ) delete m_delayedNeutrons[i1];
}

Member Function Documentation

◆ angleBiasing()

template<typename RNG>

LUPI_HOST_DEVICE void MCGIDI::OutputChannel::angleBiasing	(	Reaction const *	a_reaction,
		int	a_index,
		double	a_temperature,
		double	a_energy_in,
		double	a_mu_lab,
		double &	a_weight,
		double &	a_energy_out,
		RNG &&	a_rng,
		double &	a_cumulative_weight ) const

inline

Returns the probability for a project with energy a_energy_in to cause this channel to emitted a particle of index a_index at angle a_mu_lab as seen in the lab frame. If a particle is emitted, a_energy_out is its sampled outgoing energy.

Parameters

a_reaction	[in] The reaction containing the particle which this distribution describes.
a_index	[in] The index of the particle to emit.
a_temperature	[in] Specifies the temperature of the material.
a_energy_in	[in] The energy of the incident particle.
a_mu_lab	[in] The desired mu in the lab frame for the emitted particle.
a_weight	[in] The probability of emitting outgoing particle into lab angle a_mu_lab.
a_energy_out	[in] The energy of the emitted outgoing particle.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).
a_cumulative_weight	[in] The sum of the multiplicity for other outgoing particles with index a_index.

Definition at line 2469 of file MCGIDI_headerSource.hpp.

                                                                                                          {
 
    for( Vector<Product *>::const_iterator iter = m_products.begin( ); iter != m_products.end( ); ++iter )
        (*iter)->angleBiasing( a_reaction, a_index, a_temperature, a_energy_in, a_mu_lab, a_weight, a_energy_out, a_rng, a_cumulative_weight );
 
    if( ( m_totalDelayedNeutronMultiplicity != nullptr ) && ( a_index == m_neutronIndex ) ) {
        for( std::size_t i1 = 0; i1 < (std::size_t) m_delayedNeutrons.size( ); ++i1 ) {
            DelayedNeutron const *delayedNeutron1( delayedNeutron( i1 ) );
            Product const &product = delayedNeutron1->product( );
 
            product.angleBiasing( a_reaction, a_index, a_temperature, a_energy_in, a_mu_lab, a_weight, a_energy_out, a_rng, a_cumulative_weight );
        }
    }
}

◆ angleBiasingViaIntid()

template<typename RNG>

LUPI_HOST_DEVICE void MCGIDI::OutputChannel::angleBiasingViaIntid	(	Reaction const *	a_reaction,
		int	a_intid,
		double	a_temperature,
		double	a_energy_in,
		double	a_mu_lab,
		double &	a_weight,
		double &	a_energy_out,
		RNG &&	a_rng,
		double &	a_cumulative_weight ) const

inline

Returns the probability for a project with energy a_energy_in to cause this channel to emitted a particle of intid a_intid at angle a_mu_lab as seen in the lab frame. If a particle is emitted, a_energy_out is its sampled outgoing energy.

Parameters

a_reaction	[in] The reaction containing the particle which this distribution describes.
a_intid	[in] The intid of the particle to emit.
a_temperature	[in] Specifies the temperature of the material.
a_energy_in	[in] The energy of the incident particle.
a_mu_lab	[in] The desired mu in the lab frame for the emitted particle.
a_weight	[in] The probability of emitting outgoing particle into lab angle a_mu_lab.
a_energy_out	[in] The energy of the emitted outgoing particle.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).
a_cumulative_weight	[in] The sum of the multiplicity for other outgoing particles with intid a_intid.

Definition at line 2501 of file MCGIDI_headerSource.hpp.

                                                                                                          {
 
    for( Vector<Product *>::const_iterator iter = m_products.begin( ); iter != m_products.end( ); ++iter )
        (*iter)->angleBiasingViaIntid( a_reaction, a_intid, a_temperature, a_energy_in, a_mu_lab, a_weight, a_energy_out, a_rng, a_cumulative_weight );
 
    if( ( m_totalDelayedNeutronMultiplicity != nullptr ) && ( a_intid == PoPI::Intids::neutron ) ) {
        for( std::size_t i1 = 0; i1 < (std::size_t) m_delayedNeutrons.size( ); ++i1 ) {
            DelayedNeutron const *delayedNeutron1( delayedNeutron( i1 ) );
            Product const &product = delayedNeutron1->product( );
 
            product.angleBiasingViaIntid( a_reaction, a_intid, a_temperature, a_energy_in, a_mu_lab, a_weight, a_energy_out, a_rng, a_cumulative_weight );
        }
    }
}

◆ delayedNeutron()

LUPI_HOST_DEVICE DelayedNeutron const * MCGIDI::OutputChannel::delayedNeutron ( std::size_t a_index ) const

inline

Definition at line 1306 of file MCGIDI.hpp.

1306{ return( m_delayedNeutrons[a_index] ); }

Referenced by angleBiasing(), angleBiasingViaIntid(), OutputChannel(), and sampleProducts().

◆ delayedNeutrons()

Vector< DelayedNeutron * > MCGIDI::OutputChannel::delayedNeutrons ( ) const

inline

Definition at line 1305 of file MCGIDI.hpp.

1305{ return( m_delayedNeutrons ); }

Referenced by OutputChannel().

◆ finalQ()

LUPI_HOST_DEVICE double MCGIDI::OutputChannel::finalQ ( double a_x1 ) const

This method returns the final Q for this by getting its final Q plus any sub-output channel's finalQ.

Parameters

a_x1	[in] The energy of the projectile.

Returns: The Q-value at product energy a_x1.

Definition at line 201 of file MCGIDI_outputChannel.cc.

                                                                 {
 
    double final_Q = m_Q->evaluate( a_x1 );
 
    for( std::size_t i1 = 0; i1 < m_products.size( ); ++i1 ) final_Q += m_products[i1]->finalQ( a_x1 );
    return( final_Q );
}

Referenced by finalQ(), and MCGIDI::Reaction::finalQ().

◆ hasFission()

LUPI_HOST_DEVICE bool MCGIDI::OutputChannel::hasFission ( ) const

This method returns true if the output channel or any of its sub-output channels is a fission channel and false otherwise.

Returns: true if this or any sub-output channel is a fission channel and false otherwise.

Definition at line 215 of file MCGIDI_outputChannel.cc.

                                                       {
 
    if( m_isFission ) return( true );
    for( std::size_t i1 = 0; i1 < m_products.size( ); ++i1 ) {
        if( m_products[i1]->hasFission( ) ) return( true );
    }
    return( false );
}

Referenced by hasFission().

◆ isFission()

LUPI_HOST_DEVICE bool MCGIDI::OutputChannel::isFission ( ) const

inline

Returns the value of the m_isFission.

Definition at line 1294 of file MCGIDI.hpp.

◆ isTwoBody()

LUPI_HOST_DEVICE bool MCGIDI::OutputChannel::isTwoBody ( ) const

inline

Returns true if output channel is two-body and false otherwise.

Definition at line 1292 of file MCGIDI.hpp.

◆ moveProductsEtAlToReaction()

LUPI_HOST void MCGIDI::OutputChannel::moveProductsEtAlToReaction	(	std::vector< Product * > &	a_products,
		Functions::Function1d **	a_totalDelayedNeutronMultiplicity,
		std::vector< DelayedNeutron * > &	a_delayedNeutrons,
		std::vector< Functions::Function1d_d1 * > &	a_Qs )

Returns the energy dependent multiplicity for outgoing particle with pops id a_id. The returned value may not be an integer. Energy dependent multiplicity mainly occurs for photons and fission neutrons.

Parameters

a_products	[in] The std::vector instance to add products to.
a_totalDelayedNeutronMultiplicity	[in] The std::vector instance to add delayed neutron multiplicities to.
a_delayedNeutrons	[in] The std::vector instance to add delayed neutrons to.
a_Qs	[in] The std::vector instance to add Q functions to.

Definition at line 271 of file MCGIDI_outputChannel.cc.

                                                                                                             {
 
    if( a_totalDelayedNeutronMultiplicity != nullptr ) {    /* This will not work if fission is a nested channel. Ergo "n + (R -> fission)". */
        *a_totalDelayedNeutronMultiplicity = m_totalDelayedNeutronMultiplicity;
        m_totalDelayedNeutronMultiplicity = nullptr;
        for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
            a_delayedNeutrons.push_back( m_delayedNeutrons[index] );
            m_delayedNeutrons[index] = nullptr;
        }
    }
 
    a_Qs.push_back( m_Q );
    m_Q = nullptr;
    for( std::size_t productIndex = 0; productIndex < m_products.size( ); ++productIndex ) {
        Product *product = m_products[productIndex];
 
        if( product->outputChannel( ) != nullptr ) {
            product->outputChannel( )->moveProductsEtAlToReaction( a_products, nullptr, a_delayedNeutrons, a_Qs );
            delete product; }
        else {
            a_products.push_back( product );
        }
        m_products[productIndex] = nullptr;
    }
}

◆ operator[]()

LUPI_HOST_DEVICE Product * MCGIDI::OutputChannel::operator[] ( std::size_t a_index )

inline

Returns a pointer to the product at index a_index.

Definition at line 1290 of file MCGIDI.hpp.

◆ productAverageMultiplicity()

LUPI_HOST_DEVICE double MCGIDI::OutputChannel::productAverageMultiplicity	(	int	a_index,
		double	a_projectileEnergy ) const

Returns the energy dependent multiplicity for outgoing particle with pops index a_index. The returned value may not be an integer. Energy dependent multiplicity mainly occurs for photons and fission neutrons.

Parameters

a_index	[in] The index of the requested particle.
a_projectileEnergy	[in] The energy of the projectile.

Returns: The multiplicity value for the requested particle.

Definition at line 376 of file MCGIDI_outputChannel.cc.

                                                                                                                {
 
    double multiplicity = 0.0;
 
    for( Vector<Product *>::const_iterator iter = m_products.begin( ); iter != m_products.end( ); ++iter ) {
        multiplicity += (*iter)->productAverageMultiplicity( a_index, a_projectileEnergy );
    }
 
    if( m_totalDelayedNeutronMultiplicity != nullptr ) {
        if( a_index == m_neutronIndex ) multiplicity += m_totalDelayedNeutronMultiplicity->evaluate( a_projectileEnergy );
    }
 
    return( multiplicity );
}

Referenced by MCGIDI::Reaction::productAverageMultiplicity().

◆ productAverageMultiplicityViaIntid()

LUPI_HOST_DEVICE double MCGIDI::OutputChannel::productAverageMultiplicityViaIntid	(	int	a_intid,
		double	a_projectileEnergy ) const

Returns the energy dependent multiplicity for outgoing particle with pops intid a_intid. The returned value may not be an integer. Energy dependent multiplicity mainly occurs for photons and fission neutrons.

Parameters

a_intid	[in] The intid of the requested particle.
a_projectileEnergy	[in] The energy of the projectile.

Returns: The multiplicity value for the requested particle.

Definition at line 401 of file MCGIDI_outputChannel.cc.

                                                                                                                        {
 
    double multiplicity = 0.0;
 
    for( Vector<Product *>::const_iterator iter = m_products.begin( ); iter != m_products.end( ); ++iter ) {
        multiplicity += (*iter)->productAverageMultiplicityViaIntid( a_intid, a_projectileEnergy );
    }
 
    if( m_totalDelayedNeutronMultiplicity != nullptr ) {
        if( a_intid == PoPI::Intids::neutron ) multiplicity += m_totalDelayedNeutronMultiplicity->evaluate( a_projectileEnergy );
    }
 
    return( multiplicity );
}

Referenced by MCGIDI::Reaction::productAverageMultiplicityViaIntid().

◆ products()

LUPI_HOST_DEVICE Vector< Product * > const & MCGIDI::OutputChannel::products ( ) const

inline

Returns the value of the m_products.

Definition at line 1303 of file MCGIDI.hpp.

Referenced by OutputChannel().

◆ Q()

LUPI_HOST_DEVICE Functions::Function1d_d1 * MCGIDI::OutputChannel::Q ( )

inline

Returns the pointer of the m_Q member.

Definition at line 1297 of file MCGIDI.hpp.

◆ sampleProducts()

template<typename RNG, typename PUSHBACK>

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

inline

This method adds sampled products to a_products.

Parameters

a_protare	[in] The Protare this Reaction belongs to.
a_projectileEnergy	[in] The energy of the projectile.
a_input	[in] Sample options requested by user.
a_rng	[in] The random number generator function that returns a double in the range [0, 1.0).
a_products	[in] The object to add all sampled products to.

Definition at line 2406 of file MCGIDI_headerSource.hpp.

                                                                                                  {
 
    if( m_hasFinalStatePhotons ) {
        double random = a_rng( );
        double cumulative = 0.0;
        bool sampled = false;
        for( auto productIter = m_products.begin( ); productIter != m_products.end( ); ++productIter ) {
            cumulative += (*productIter)->multiplicity( )->evaluate( a_projectileEnergy );
            if( cumulative >= random ) {
                (*productIter)->sampleFinalState( a_protare, a_projectileEnergy, a_input, a_rng, a_push_back, a_products );
                sampled = true;
                break;
            }
        }
        if( !sampled ) {     // BRB: FIXME: still need to code for continuum photon.
        } }
    else {
        for( Vector<Product *>::const_iterator iter = m_products.begin( ); iter != m_products.end( ); ++iter )
            (*iter)->sampleProducts( a_protare, a_projectileEnergy, a_input, a_rng, a_push_back, a_products );
    }
 
    if( m_totalDelayedNeutronMultiplicity != nullptr ) {
        double totalDelayedNeutronMultiplicity = m_totalDelayedNeutronMultiplicity->evaluate( a_projectileEnergy );
 
        if( a_rng( ) < totalDelayedNeutronMultiplicity ) {       // Assumes that totalDelayedNeutronMultiplicity < 1.0, which it is.
            double sum = 0.0;
 
            totalDelayedNeutronMultiplicity *= a_rng( );
            for( std::size_t i1 = 0; i1 < (std::size_t) m_delayedNeutrons.size( ); ++i1 ) {
                DelayedNeutron const *delayedNeutron1( delayedNeutron( i1 ) );
                Product const &product = delayedNeutron1->product( );
 
                sum += product.multiplicity( )->evaluate( a_projectileEnergy );
                if( sum >= totalDelayedNeutronMultiplicity ) {
                    product.distribution( )->sample( a_projectileEnergy, a_input, a_rng );
                    a_input.m_delayedNeutronIndex = delayedNeutron1->delayedNeutronIndex( );
                    a_input.m_delayedNeutronDecayRate = delayedNeutron1->rate( );
                    a_products.add( a_projectileEnergy, product.intid( ), product.index( ), product.userParticleIndex( ), product.mass( ), 
                            a_input, a_rng, a_push_back, false );
                    break;
                }
            }
        }
    }
}

◆ serialize()

LUPI_HOST_DEVICE void MCGIDI::OutputChannel::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 424 of file MCGIDI_outputChannel.cc.

                                                                                                    {
 
    int channelType = 0;
    switch( m_channelType ) {
    case ChannelType::none :
        break;
    case ChannelType::twoBody :
        channelType = 1;
        break;
    case ChannelType::uncorrelatedBodies :
        channelType = 2;
        break;
    }
    DATA_MEMBER_INT( channelType, a_buffer, a_mode );
    if( a_mode == LUPI::DataBuffer::Mode::Unpack ) {
        switch( channelType ) {
        case 0 :
            m_channelType = ChannelType::none;
            break;
        case 1 :
            m_channelType = ChannelType::twoBody;
            break;
        case 2 :
            m_channelType = ChannelType::uncorrelatedBodies;
            break;
        }
    }
 
    DATA_MEMBER_INT( m_neutronIndex, a_buffer, a_mode );
    DATA_MEMBER_CAST( m_isFission, a_buffer, a_mode, bool );
    DATA_MEMBER_CAST( m_hasFinalStatePhotons, a_buffer, a_mode, bool );
 
    m_Q = serializeFunction1d_d1( a_buffer, a_mode, m_Q );
    serializeProducts( a_buffer, a_mode, m_products );
    m_totalDelayedNeutronMultiplicity = serializeFunction1d( a_buffer, a_mode, m_totalDelayedNeutronMultiplicity );
    serializeDelayedNeutrons( a_buffer, a_mode, m_delayedNeutrons );
}

Referenced by MCGIDI::Reaction::serialize().

◆ setModelDBRC_data()

LUPI_HOST void MCGIDI::OutputChannel::setModelDBRC_data ( Sampling::Upscatter::ModelDBRC_data * a_modelDBRC_data )

This method calls the **setModelDBRC_data* method on the first product of this with a_modelDBRC_data.

Parameters

a_modelDBRC_data [in] The instance storing data needed to treat the DRRC upscatter mode.

Definition at line 256 of file MCGIDI_outputChannel.cc.

                                                                                                   {
 
    m_products[0]->setModelDBRC_data( a_modelDBRC_data );
}

Referenced by MCGIDI::Reaction::setModelDBRC_data().

◆ setUserParticleIndex()

LUPI_HOST void MCGIDI::OutputChannel::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 231 of file MCGIDI_outputChannel.cc.

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

Referenced by MCGIDI::Reaction::setUserParticleIndex().

◆ setUserParticleIndexViaIntid()

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

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

Parameters

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

Definition at line 244 of file MCGIDI_outputChannel.cc.

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

Referenced by MCGIDI::Reaction::setUserParticleIndexViaIntid().

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ OutputChannel() [1/2]

◆ OutputChannel() [2/2]

◆ ~OutputChannel()

Member Function Documentation

◆ angleBiasing()

◆ angleBiasingViaIntid()

◆ delayedNeutron()

◆ delayedNeutrons()

◆ finalQ()

◆ hasFission()

◆ isFission()

◆ isTwoBody()

◆ moveProductsEtAlToReaction()

◆ operator[]()

◆ productAverageMultiplicity()

◆ productAverageMultiplicityViaIntid()

◆ products()

◆ Q()

◆ sampleProducts()

◆ serialize()

◆ setModelDBRC_data()

◆ setUserParticleIndex()

◆ setUserParticleIndexViaIntid()