#include <GIDI.hpp>

Inheritance diagram for GIDI::FissionFragmentData:

Public Member Functions
	FissionFragmentData ()
	FissionFragmentData (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, Styles::Suite const *a_styles)
	~FissionFragmentData ()
Suite &	delayedNeutrons ()
Suite const &	delayedNeutrons () const
Component &	fissionEnergyReleases ()
Component const &	fissionEnergyReleases () const
bool	isDelayedFissionNeutronComplete () const
GUPI::Ancestry *	findInAncestry3 (std::string const &a_item)
GUPI::Ancestry const *	findInAncestry3 (std::string const &a_item) const
void	productIDs (std::set< std::string > &a_indices, Transporting::Particles const &a_particles, bool a_transportablesOnly) const
int	productMultiplicity (std::string const &a_productID) const
int	maximumLegendreOrder (LUPI::StatusMessageReporting &a_smr, Transporting::MG const &a_settings, Styles::TemperatureInfo const &a_temperatureInfo, std::string const &a_productID) const
Vector	multiGroupQ (LUPI::StatusMessageReporting &a_smr, Transporting::MG const &a_settings, Styles::TemperatureInfo const &a_temperatureInfo, bool a_final) const
Vector	multiGroupMultiplicity (LUPI::StatusMessageReporting &a_smr, Transporting::MG const &a_settings, Styles::TemperatureInfo const &a_temperatureInfo, std::string const &a_productID) const
Matrix	multiGroupProductMatrix (LUPI::StatusMessageReporting &a_smr, Transporting::MG const &a_settings, Styles::TemperatureInfo const &a_temperatureInfo, Transporting::Particles const &a_particles, std::string const &a_productID, std::size_t a_order) const
Vector	multiGroupAverageEnergy (LUPI::StatusMessageReporting &a_smr, Transporting::MG const &a_settings, Styles::TemperatureInfo const &a_temperatureInfo, std::string const &a_productID) const
Vector	multiGroupAverageMomentum (LUPI::StatusMessageReporting &a_smr, Transporting::MG const &a_settings, Styles::TemperatureInfo const &a_temperatureInfo, std::string const &a_productID) const
void	delayedNeutronProducts (DelayedNeutronProducts &a_delayedNeutronProducts) const
void	incompleteParticles (Transporting::Settings const &a_settings, std::set< std::string > &a_incompleteParticles) const
void	continuousEnergyProductData (Transporting::Settings const &a_settings, std::string const &a_particleID, double a_energy, double &a_productEnergy, double &a_productMomentum, double &a_productGain, bool a_ignoreIncompleteParticles) const
void	mapContinuousEnergyProductData (Transporting::Settings const &a_settings, std::string const &a_particleID, std::vector< double > const &a_energies, std::size_t a_offset, std::vector< double > &a_productEnergies, std::vector< double > &a_productMomenta, std::vector< double > &a_productGains, bool a_ignoreIncompleteParticles) const
void	calculateMultiGroupData (ProtareSingle const *a_protare, Styles::TemperatureInfo const &a_temperatureInfo, std::string const &a_heatedMultiGroupLabel, MultiGroupCalulationInformation const &a_multiGroupCalulationInformation, Functions::XYs1d const &a_crossSectionXYs1d)
void	toXMLList (GUPI::WriteInfo &a_writeInfo, std::string const &a_indent="") const
Public Member Functions inherited from GUPI::Ancestry
	Ancestry (std::string const &a_moniker, std::string const &a_attribute="")
virtual	~Ancestry ()
Ancestry &	operator= (Ancestry const &a_ancestry)
std::string const &	moniker () const
void	setMoniker (std::string const &a_moniker)
Ancestry *	ancestor ()
Ancestry const *	ancestor () const
void	setAncestor (Ancestry *a_ancestor)
std::string	attribute () const
Ancestry *	root ()
Ancestry const *	root () const
bool	isChild (Ancestry *a_instance)
bool	isParent (Ancestry *a_parent)
bool	isRoot () const
Ancestry *	findInAncestry (std::string const &a_href)
Ancestry const *	findInAncestry (std::string const &a_href) const
virtual LUPI_HOST void	serialize (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)
virtual std::string	xlinkItemKey () const
std::string	toXLink () const
void	printXML () const

Additional Inherited Members
Static Public Member Functions inherited from GUPI::Ancestry
static std::string	buildXLinkItemKey (std::string const &a_name, std::string const &a_key)

Detailed Description

This class represents a GNDS fissionFragmentData.

Definition at line 4038 of file GIDI.hpp.

Constructor & Destructor Documentation

◆ FissionFragmentData() [1/2]

GIDI::FissionFragmentData::FissionFragmentData ( )

Default constructor for FissionFragmentData.

Definition at line 22 of file GIDI_fissionFragmentData.cc.

                                          :
        GUPI::Ancestry( GIDI_fissionFragmentDataChars ),
        m_delayedNeutrons( GIDI_delayedNeutronsChars, GIDI_labelChars ),
        m_fissionEnergyReleases( GIDI_fissionEnergyReleasesChars, GIDI_labelChars ) {
 
}

◆ FissionFragmentData() [2/2]

GIDI::FissionFragmentData::FissionFragmentData	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		Styles::Suite const *	a_styles )

Constructed from data in a <outputChannel> node.

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The reaction HAPI::Node to be parsed and used to construct the reaction.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] The external PoPI::Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_styles	[in] The <styles> node under the <reactionSuite> node.

Definition at line 41 of file GIDI_fissionFragmentData.cc.

                                                                                                              :
        GUPI::Ancestry( a_node.name( ) ),
        m_delayedNeutrons( a_construction, GIDI_delayedNeutronsChars, GIDI_labelChars, a_node, a_setupInfo, a_pops, a_internalPoPs, 
                parseDelayedNeutronsSuite, a_styles ),
        m_fissionEnergyReleases( a_construction, GIDI_fissionEnergyReleasesChars, GIDI_labelChars, a_node, a_setupInfo, a_pops, a_internalPoPs, 
                parseFissionEnergyReleasesSuite, a_styles ) {
 
    m_delayedNeutrons.setAncestor( this );
    m_fissionEnergyReleases.setAncestor( this );
 
    for( std::size_t i1 = 0; i1 < m_delayedNeutrons.size( ); ++i1 ) {
        DelayedNeutron *delayedNeutron = m_delayedNeutrons.get<DelayedNeutron>( i1 );
 
        delayedNeutron->setDelayedNeutronIndex( static_cast<int>( i1 ) );
    }
}

◆ ~FissionFragmentData()

GIDI::FissionFragmentData::~FissionFragmentData ( )

Definition at line 62 of file GIDI_fissionFragmentData.cc.

                                           {
 
}

Member Function Documentation

◆ calculateMultiGroupData()

void GIDI::FissionFragmentData::calculateMultiGroupData	(	ProtareSingle const *	a_protare,
		Styles::TemperatureInfo const &	a_temperatureInfo,
		std::string const &	a_heatedMultiGroupLabel,
		MultiGroupCalulationInformation const &	a_multiGroupCalulationInformation,
		Functions::XYs1d const &	a_crossSectionXYs1d )

This methods calculates multi-group data for all needed components and adds each component's multi-group with label a_heatedMultiGroupLabel.

Parameters

a_temperatureInfo	[in] Specifies the temperature and labels use to lookup the requested data.
a_heatedMultiGroupLabel	[in] The label of the style for the multi-group data being added.
a_multiGroupCalulationInformation	[in] Store multi-group boundary and flux data used for multi-grouping.
a_crossSectionXYs1d	[in[ The cross section weight.

Definition at line 421 of file GIDI_fissionFragmentData.cc.

                                                            {
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        delayedNeutrons1.calculateMultiGroupData( a_protare, a_temperatureInfo, a_heatedMultiGroupLabel, a_multiGroupCalulationInformation, a_crossSectionXYs1d );
    }
 
    if( ( m_fissionEnergyReleases.size( ) > 0 ) && ( m_fissionEnergyReleases.find( a_heatedMultiGroupLabel ) !=  m_fissionEnergyReleases.end( ) ) ) {
        Functions::FissionEnergyRelease const *fissionEnergyRelease = m_fissionEnergyReleases.get<Functions::FissionEnergyRelease>( 0 );
        Functions::FissionEnergyRelease *multiGroupFissionEnergyRelease = m_fissionEnergyReleases.get<Functions::FissionEnergyRelease>( a_heatedMultiGroupLabel );
 
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->promptProductKE( ), multiGroupFissionEnergyRelease->promptProductKE( ) );
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->promptNeutronKE( ), multiGroupFissionEnergyRelease->promptNeutronKE( ) );
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->delayedNeutronKE( ), multiGroupFissionEnergyRelease->delayedNeutronKE( ) );
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->promptGammaEnergy( ), multiGroupFissionEnergyRelease->promptGammaEnergy( ) );
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->delayedGammaEnergy( ), multiGroupFissionEnergyRelease->delayedGammaEnergy( ) );
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->delayedBetaEnergy( ), multiGroupFissionEnergyRelease->delayedBetaEnergy( ) );
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->neutrinoEnergy( ), multiGroupFissionEnergyRelease->neutrinoEnergy( ) );
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->nonNeutrinoEnergy( ), multiGroupFissionEnergyRelease->nonNeutrinoEnergy( ) );
        calculate1dMultiGroupFissionEnergyRelease( a_multiGroupCalulationInformation, a_crossSectionXYs1d, 
                fissionEnergyRelease->totalEnergy( ), multiGroupFissionEnergyRelease->totalEnergy( ) );
    }
}

◆ continuousEnergyProductData()

void GIDI::FissionFragmentData::continuousEnergyProductData	(	Transporting::Settings const &	a_settings,
		std::string const &	a_particleID,
		double	a_energy,
		double &	a_productEnergy,
		double &	a_productMomentum,
		double &	a_productGain,
		bool	a_ignoreIncompleteParticles ) const

Returns, via arguments, the average energy and momentum, and gain for product with particle id a_particleID.

Parameters

a_settings	[in] Specifies the requested label.
a_particleID	[in] The particle id of the product.
a_energy	[in] The energy of the projectile.
a_productEnergy	[in] The average energy of the product.
a_productMomentum	[in] The average momentum of the product.
a_productGain	[in] The gain of the product.
a_ignoreIncompleteParticles	[in] If true, incomplete particles are ignore, otherwise a throw is executed.

Definition at line 372 of file GIDI_fissionFragmentData.cc.

                                                                                                                                    {
 
    if( a_settings.delayedNeutrons( ) != Transporting::DelayedNeutrons::on ) return;
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        delayedNeutrons1.continuousEnergyProductData( a_settings, a_particleID, a_energy, a_productEnergy, a_productMomentum, a_productGain, 
                a_ignoreIncompleteParticles );
    }
}

◆ delayedNeutronProducts()

void GIDI::FissionFragmentData::delayedNeutronProducts ( DelayedNeutronProducts & a_delayedNeutronProducts ) const

Appends a DelayedNeutronProduct instance for each delayed neutron in m_delayedNeutrons.

Parameters

a_delayedNeutronProducts [in] The list to append the delayed neutrons to.

Definition at line 332 of file GIDI_fissionFragmentData.cc.

                                                                                                         {
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutron = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        PhysicalQuantity rate = *delayedNeutron.rate( ).get<PhysicalQuantity>( 0 );
        a_delayedNeutronProducts.push_back( DelayedNeutronProduct( delayedNeutron.delayedNeutronIndex( ), rate, &delayedNeutron.product( ) ) );
    }
}

◆ delayedNeutrons() [1/2]

Suite & GIDI::FissionFragmentData::delayedNeutrons ( )

inline

Definition at line 4049 of file GIDI.hpp.

4049{ return( m_delayedNeutrons ); }

◆ delayedNeutrons() [2/2]

Suite const & GIDI::FissionFragmentData::delayedNeutrons ( ) const

inline

Definition at line 4050 of file GIDI.hpp.

4050{ return( m_delayedNeutrons ); }

◆ findInAncestry3() [1/2]

GUPI::Ancestry * GIDI::FissionFragmentData::findInAncestry3 ( std::string const & a_item )

virtual

Used by GUPI::Ancestry to tranverse GNDS nodes. This method returns a pointer to a derived class' a_item member or nullptr if none exists.

Parameters

a_item [in] The name of the class member whose pointer is to be return.

Returns: The pointer to the class member or nullptr if class does not have a member named a_item.

Implements GUPI::Ancestry.

Definition at line 91 of file GIDI_fissionFragmentData.cc.

                                                                            {
 
    if( a_item == GIDI_delayedNeutronsChars ) return( &m_delayedNeutrons );
    if( a_item == GIDI_fissionEnergyReleasesChars ) return( &m_fissionEnergyReleases );
 
    return( nullptr );
}

◆ findInAncestry3() [2/2]

GUPI::Ancestry const * GIDI::FissionFragmentData::findInAncestry3 ( std::string const & a_item ) const

virtual

Used by GUPI::Ancestry to tranverse GNDS nodes. This method returns a pointer to a derived class' a_item member or nullptr if none exists.

Parameters

a_item [in] The name of the class member whose pointer is to be return.

Returns: The pointer to the class member or nullptr if class does not have a member named a_item.

Implements GUPI::Ancestry.

Definition at line 106 of file GIDI_fissionFragmentData.cc.

                                                                                        {
 
    if( a_item == GIDI_delayedNeutronsChars ) return( &m_delayedNeutrons );
    if( a_item == GIDI_fissionEnergyReleasesChars ) return( &m_fissionEnergyReleases );
 
    return( nullptr );
}

◆ fissionEnergyReleases() [1/2]

Component & GIDI::FissionFragmentData::fissionEnergyReleases ( )

inline

Definition at line 4051 of file GIDI.hpp.

4051{ return( m_fissionEnergyReleases ); }

◆ fissionEnergyReleases() [2/2]

Component const & GIDI::FissionFragmentData::fissionEnergyReleases ( ) const

inline

Definition at line 4052 of file GIDI.hpp.

4052{ return( m_fissionEnergyReleases ); }

◆ incompleteParticles()

void GIDI::FissionFragmentData::incompleteParticles	(	Transporting::Settings const &	a_settings,
		std::set< std::string > &	a_incompleteParticles ) const

Loops over the instances in ** m_delayedNeutrons** calling their incompleteParticles method.

Parameters

a_settings	[in] Specifies the requested label.
a_incompleteParticles	[out] The list of particles whose completeParticle method returns false.

Definition at line 349 of file GIDI_fissionFragmentData.cc.

                                                                                                                                      {
 
    if( a_settings.delayedNeutrons( ) == Transporting::DelayedNeutrons::on ) {
        for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
            DelayedNeutron const &delayedNeutron = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
            delayedNeutron.incompleteParticles( a_settings, a_incompleteParticles );
        }
    }
}

◆ isDelayedFissionNeutronComplete()

bool GIDI::FissionFragmentData::isDelayedFissionNeutronComplete ( ) const

Returns false* if this has delayed fission neutrons and they are not complete; otherwise, returns **true.

Returns: bool

Definition at line 72 of file GIDI_fissionFragmentData.cc.

                                                                 {
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        Product const &product = delayedNeutrons1.product( );
        if( !product.isDelayedFissionNeutronComplete( true ) ) return( false );
    }
 
    return( true );
}

◆ mapContinuousEnergyProductData()

void GIDI::FissionFragmentData::mapContinuousEnergyProductData	(	Transporting::Settings const &	a_settings,
		std::string const &	a_particleID,
		std::vector< double > const &	a_energies,
		std::size_t	a_offset,
		std::vector< double > &	a_productEnergies,
		std::vector< double > &	a_productMomenta,
		std::vector< double > &	a_productGains,
		bool	a_ignoreIncompleteParticles ) const

Modifies the average product energies, momenta and gains for product with particle id a_particleID.

Parameters

a_settings	[in] Specifies user options.
a_particleID	[in] The particle id of the product.
a_energies	[in] The vector of energies to map the data to.
a_offset	[in] The index of the first energy whose data are to be added to the vectors.
a_productEnergies	[out] The vector of average energies of the product.
a_productMomenta	[out] The vector of average momenta of the product.
a_productGains	[out] The vector of gain of the product.
a_ignoreIncompleteParticles	[in] If true, incomplete particles are ignore, otherwise a throw is executed.

Definition at line 398 of file GIDI_fissionFragmentData.cc.

                                                                                            {
 
    if( a_settings.delayedNeutrons( ) != Transporting::DelayedNeutrons::on ) return;
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        delayedNeutrons1.mapContinuousEnergyProductData( a_settings, a_particleID, a_energies, a_offset, a_productEnergies, a_productMomenta,
                a_productGains, a_ignoreIncompleteParticles );
    }
}

◆ maximumLegendreOrder()

int GIDI::FissionFragmentData::maximumLegendreOrder	(	LUPI::StatusMessageReporting &	a_smr,
		Transporting::MG const &	a_settings,
		Styles::TemperatureInfo const &	a_temperatureInfo,
		std::string const &	a_productID ) const

Determines the maximum Legredre order present in the multi-group transfer matrix for the specified products of this output channel.

Parameters

a_smr	[Out] If errors are not to be thrown, then the error is reported via this instance.
a_settings	[in] Specifies the requested label.
a_temperatureInfo	[in] Specifies the temperature and labels use to lookup the requested data.
a_productID	[in] Particle id of the requested product.

Returns: The maximum Legredre order. If no transfer matrix data are present for the requested product, -1 is returned.

Definition at line 166 of file GIDI_fissionFragmentData.cc.

                                                                                                     {
 
    int _maximumLegendreOrder = -1;
 
    if( a_settings.delayedNeutrons( ) == Transporting::DelayedNeutrons::on ) {
        for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
            DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
            int r_maximumLegendreOrder = delayedNeutrons1.maximumLegendreOrder( a_smr, a_settings, a_temperatureInfo, a_productID );
 
            if( r_maximumLegendreOrder > _maximumLegendreOrder ) _maximumLegendreOrder = r_maximumLegendreOrder;
        }
    }
 
    return( _maximumLegendreOrder );
}

◆ multiGroupAverageEnergy()

Vector GIDI::FissionFragmentData::multiGroupAverageEnergy	(	LUPI::StatusMessageReporting &	a_smr,
		Transporting::MG const &	a_settings,
		Styles::TemperatureInfo const &	a_temperatureInfo,
		std::string const &	a_productID ) const

Returns the sum of the multi-group, average energy for the requested label for the requested product. This is a cross section weighted average energy.

Parameters

a_smr	[Out] If errors are not to be thrown, then the error is reported via this instance.
a_settings	[in] Specifies the requested label.
a_temperatureInfo	[in] Specifies the temperature and labels use to lookup the requested data.
a_productID	[in] Particle id for the requested product.

Returns: The requested multi-group average energy as a GIDI::Vector.

Definition at line 283 of file GIDI_fissionFragmentData.cc.

                                                                                                     {
 
    Vector vector( 0 );
 
    if( a_settings.delayedNeutrons( ) != Transporting::DelayedNeutrons::on ) return( vector );
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        vector += delayedNeutrons1.multiGroupAverageEnergy( a_smr, a_settings, a_temperatureInfo, a_productID );
    }
 
    return( vector );
}

◆ multiGroupAverageMomentum()

Vector GIDI::FissionFragmentData::multiGroupAverageMomentum	(	LUPI::StatusMessageReporting &	a_smr,
		Transporting::MG const &	a_settings,
		Styles::TemperatureInfo const &	a_temperatureInfo,
		std::string const &	a_productID ) const

Returns the sum of the multi-group, average momentum for the requested label for the requested product. This is a cross section weighted average momentum.

Parameters

a_smr	[Out] If errors are not to be thrown, then the error is reported via this instance.
a_settings	[in] Specifies the requested label.
a_temperatureInfo	[in] Specifies the temperature and labels use to lookup the requested data.
a_productID	[in] Particle id for the requested product.

Returns: The requested multi-group average momentum as a GIDI::Vector.

Definition at line 310 of file GIDI_fissionFragmentData.cc.

                                                                                                     {
 
    Vector vector( 0 );
 
    if( a_settings.delayedNeutrons( ) != Transporting::DelayedNeutrons::on ) return( vector );
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        vector += delayedNeutrons1.multiGroupAverageMomentum( a_smr, a_settings, a_temperatureInfo, a_productID );
    }
 
    return( vector );
}

◆ multiGroupMultiplicity()

Vector GIDI::FissionFragmentData::multiGroupMultiplicity	(	LUPI::StatusMessageReporting &	a_smr,
		Transporting::MG const &	a_settings,
		Styles::TemperatureInfo const &	a_temperatureInfo,
		std::string const &	a_productID ) const

Returns the sum of the multi-group multiplicity for the requested label for the request product of this output channel. This is a cross section weighted multiplicity.

Parameters

a_smr	[Out] If errors are not to be thrown, then the error is reported via this instance.
a_settings	[in] Specifies the requested label.
a_temperatureInfo	[in] Specifies the temperature and labels use to lookup the requested data.
a_productID	[in] Particle id for the requested product.

Returns: The requested multi-group multiplicity as a GIDI::Vector.

Definition at line 195 of file GIDI_fissionFragmentData.cc.

                                                                                                     {
 
    Vector vector( 0 );
 
    if( a_settings.delayedNeutrons( ) != Transporting::DelayedNeutrons::on ) return( vector );
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        vector += delayedNeutrons1.multiGroupMultiplicity( a_smr, a_settings, a_temperatureInfo, a_productID );
    }
 
    return( vector );
}

◆ multiGroupProductMatrix()

Matrix GIDI::FissionFragmentData::multiGroupProductMatrix	(	LUPI::StatusMessageReporting &	a_smr,
		Transporting::MG const &	a_settings,
		Styles::TemperatureInfo const &	a_temperatureInfo,
		Transporting::Particles const &	a_particles,
		std::string const &	a_productID,
		std::size_t	a_order ) const

Returns the multi-group, product matrix for the requested label for the requested product index for the requested Legendre order. If no data are found, an empty GIDI::Matrix is returned.

Parameters

a_smr	[Out] If errors are not to be thrown, then the error is reported via this instance.
a_settings	[in] Specifies the requested label and if delayed neutrons should be included.
a_temperatureInfo	[in] Specifies the temperature and labels use to lookup the requested data.
a_particles	[in] The list of particles to be transported.
a_productID	[in] Particle id for the requested product.
a_order	[in] Requested product matrix, Legendre order.

Returns: The requested multi-group product matrix as a GIDI::Matrix.

Definition at line 255 of file GIDI_fissionFragmentData.cc.

                                          {
 
    Matrix matrix( 0, 0 );
 
    if( a_settings.delayedNeutrons( ) != Transporting::DelayedNeutrons::on ) return( matrix );
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        matrix += delayedNeutrons1.multiGroupProductMatrix( a_smr, a_settings, a_temperatureInfo, a_particles, a_productID, a_order );
    }
 
    return( matrix );
}

◆ multiGroupQ()

Vector GIDI::FissionFragmentData::multiGroupQ	(	LUPI::StatusMessageReporting &	a_smr,
		Transporting::MG const &	a_settings,
		Styles::TemperatureInfo const &	a_temperatureInfo,
		bool	a_final ) const

Returns the sum of the multi-group, Q for the requested label for the this output channel. This is a cross section weighted Q. If a_final is false, only the Q for the output channels directly under each reaction is summed. Otherwise, the Q for all output channels summed, including output channels for each products.

Parameters

a_smr	[Out] If errors are not to be thrown, then the error is reported via this instance.
a_settings	[in] Specifies the requested label.
a_temperatureInfo	[in] Specifies the temperature and labels use to lookup the requested data.
a_final	[in] If true, the Q is calculated for all output channels, including those for products.

Returns: The requested multi-group Q as a GIDI::Vector.

Definition at line 224 of file GIDI_fissionFragmentData.cc.

                                                                                                      {
 
    Vector vector( 0 );
 
    if( a_settings.delayedNeutrons( ) != Transporting::DelayedNeutrons::on ) return( vector );
 
    if( m_fissionEnergyReleases.size( ) == 0 ) return( vector );
 
    Functions::FissionEnergyRelease const *form = dynamic_cast<Functions::FissionEnergyRelease const *>( a_settings.form( 
            a_smr, m_fissionEnergyReleases, a_temperatureInfo, "Q-value" ) );
 
    if( form != nullptr ) vector += form->multiGroupQ( a_smr, a_settings, a_temperatureInfo );
 
    return( vector );
}

◆ productIDs()

void GIDI::FissionFragmentData::productIDs	(	std::set< std::string > &	a_indices,
		Transporting::Particles const &	a_particles,
		bool	a_transportablesOnly ) const

Insert a std::set with the products id and any product in in its output channel. If a_transportablesOnly is true, only transportable product indices are return.

Parameters

a_indices	[out] The unique list of product indices.
a_particles	[in] The list of particles to be transported.
a_transportablesOnly	[in] If true, only transportable product indices are added in the list.

Definition at line 123 of file GIDI_fissionFragmentData.cc.

                                                                                                                                              {
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        delayedNeutrons1.productIDs( a_indices, a_particles, a_transportablesOnly );
    }
}

◆ productMultiplicity()

int GIDI::FissionFragmentData::productMultiplicity ( std::string const & a_productID ) const

Returns the product multiplicity (e.g., 0, 1, 2, ...) or -1 if energy dependent or not an integer for particle with id a_productID.

Parameters

a_productID; [in] The id of the requested particle.

Returns: The multiplicity for the requested particle.

Definition at line 140 of file GIDI_fissionFragmentData.cc.

                                                                                 {
 
    int total_multiplicity = 0;
 
    for( std::size_t index = 0; index < m_delayedNeutrons.size( ); ++index ) {
        DelayedNeutron const &delayedNeutrons1 = *m_delayedNeutrons.get<DelayedNeutron>( index );
 
        int multiplicity = delayedNeutrons1.productMultiplicity( a_productID );
        if( multiplicity < 0 ) return( -1 );
        total_multiplicity += multiplicity;
    }
 
    return( total_multiplicity );
}

◆ toXMLList()

void GIDI::FissionFragmentData::toXMLList	(	GUPI::WriteInfo &	a_writeInfo,
		std::string const &	a_indent = "" ) const

virtual

Fills the argument a_writeInfo with the XML lines that represent this. Recursively enters each sub-node.

Parameters

a_writeInfo	[in/out] Instance containing incremental indentation and other information and stores the appended lines.
a_indent	[in] The amount to indent this node.

Reimplemented from GUPI::Ancestry.

Definition at line 463 of file GIDI_fissionFragmentData.cc.

                                                                                                 {
 
    std::string indent2 = a_writeInfo.incrementalIndent( a_indent );
 
    if( moniker( ) == "" ) return;
    if( ( m_delayedNeutrons.size( ) == 0 ) && ( m_fissionEnergyReleases.size( ) == 0 ) ) return;
    a_writeInfo.addNodeStarter( a_indent, moniker( ), "" );
    m_delayedNeutrons.toXMLList( a_writeInfo, indent2 );
    m_fissionEnergyReleases.toXMLList( a_writeInfo, indent2 );
    a_writeInfo.addNodeEnder( moniker( ) );
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FissionFragmentData() [1/2]

◆ FissionFragmentData() [2/2]

◆ ~FissionFragmentData()

Member Function Documentation

◆ calculateMultiGroupData()

◆ continuousEnergyProductData()

◆ delayedNeutronProducts()

◆ delayedNeutrons() [1/2]

◆ delayedNeutrons() [2/2]

◆ findInAncestry3() [1/2]

◆ findInAncestry3() [2/2]

◆ fissionEnergyReleases() [1/2]

◆ fissionEnergyReleases() [2/2]

◆ incompleteParticles()

◆ isDelayedFissionNeutronComplete()

◆ mapContinuousEnergyProductData()

◆ maximumLegendreOrder()

◆ multiGroupAverageEnergy()

◆ multiGroupAverageMomentum()

◆ multiGroupMultiplicity()

◆ multiGroupProductMatrix()

◆ multiGroupQ()

◆ productIDs()

◆ productMultiplicity()

◆ toXMLList()