#include <GIDI.hpp>

Public Member Functions
	Particle (std::string const &a_pid, MultiGroup const &a_multiGroup, Functions::Function3dForm const &a_fluxes, Transporting::Mode a_mode=Transporting::Mode::multiGroup)
	Particle (std::string const &a_pid, Transporting::Mode a_mode=Transporting::Mode::multiGroup)
	Particle (std::string const &a_pid, MultiGroup const &a_multiGroup, Transporting::Mode a_mode=Transporting::Mode::multiGroup)
	Particle (Particle const &a_particle)
	~Particle ()
std::string const &	pid () const
Transporting::Mode	mode () const
Transporting::Conserve	conserve () const
int	multiGroupIndexFromEnergy (double a_e_in, bool a_encloseOutOfRange) const
std::size_t	numberOfGroups () const
MultiGroup	multiGroup () const
MultiGroup	fineMultiGroup () const
int	appendFlux (Flux const &a_flux)
ProcessedFlux const *	nearestProcessedFluxToTemperature (double a_temperature) const
std::vector< std::size_t > const &	collapseIndices () const
void	process (Transportable const &a_transportable, double a_epsilon=1e-6)
void	print (std::string const &a_indent) const

Detailed Description

Specifies particle information as mainly needed for multi-group transport. For example, the coarse and fine multi-group data.

Definition at line 3642 of file GIDI.hpp.

Constructor & Destructor Documentation

◆ Particle() [1/4]

GIDI::Transporting::Particle::Particle	(	std::string const &	a_pid,
		MultiGroup const &	a_multiGroup,
		Functions::Function3dForm const &	a_fluxes,
		Transporting::Mode	a_mode = Transporting::Mode::multiGroup )

Parameters

a_pid	[in] Particle id for the particle.
a_multiGroup	[in] The multi-group boundaries.
a_fluxes	[in] The fluxes as f(T,E,mu).
a_mode	[in] Should probably be deprecated.

Definition at line 174 of file GIDI_settings_particle.cc.

                                              :
        m_pid( a_pid ),
        m_mode( a_mode ),
        m_conserve( Transporting::Conserve::number ),
        m_multiGroup( a_multiGroup ) {
 
    std::vector<Transporting::Flux> fluxes = settingsFluxesFromFunction3d( a_fluxes );
 
    for( auto flux = fluxes.begin( ); flux != fluxes.end( ); ++flux ) appendFlux( *flux );
}

Referenced by Particle().

◆ Particle() [2/4]

GIDI::Transporting::Particle::Particle	(	std::string const &	a_pid,
		Transporting::Mode	a_mode = Transporting::Mode::multiGroup )

Parameters

a_pid	[in] Particle id for the particle.
a_mode	[in] Should probably be deprecated.

Definition at line 191 of file GIDI_settings_particle.cc.

                                                                    :
        m_pid( a_pid ),
        m_mode( a_mode ),
        m_conserve( Transporting::Conserve::number ) {
 
}

◆ Particle() [3/4]

GIDI::Transporting::Particle::Particle	(	std::string const &	a_pid,
		MultiGroup const &	a_group,
		Transporting::Mode	a_mode = Transporting::Mode::multiGroup )

Parameters

a_pid	[in] Particle id for the particle.
a_group	[in] The multi-group boundaries.
a_mode	[in] Should probably be deprecated.

Definition at line 204 of file GIDI_settings_particle.cc.

                                                                                               :
        m_pid( a_pid ),
        m_mode( a_mode ),
        m_conserve( Transporting::Conserve::number ),
        m_multiGroup( a_group ) {
 
}

◆ Particle() [4/4]

GIDI::Transporting::Particle::Particle ( Particle const & a_particle )

Parameters

a_particle [in] The Particle instance to copy.

Definition at line 216 of file GIDI_settings_particle.cc.

                                               :
        m_pid( a_particle.pid( ) ),
        m_mode( a_particle.mode( ) ),
        m_conserve( a_particle.conserve( ) ),
        m_multiGroup( a_particle.multiGroup( ) ),
        m_collapseIndices( a_particle.collapseIndices( ) ) {
 
    for( std::vector<Flux>::const_iterator iter = a_particle.m_fluxes.begin( ); iter != a_particle.m_fluxes.end( ); ++iter ) {
        m_fluxes.push_back( *iter );
    }
 
    for( std::vector<ProcessedFlux>::const_iterator iter = a_particle.m_processedFluxes.begin( ); iter != a_particle.m_processedFluxes.end( ); ++iter ) {
        m_processedFluxes.push_back( *iter );
    }
}

◆ ~Particle()

GIDI::Transporting::Particle::~Particle ( )

Definition at line 235 of file GIDI_settings_particle.cc.

                     {
 
}

Member Function Documentation

◆ appendFlux()

int GIDI::Transporting::Particle::appendFlux ( Flux const & a_flux )

Adds a flux at a specified temperature to the list of fluxes. Currently, the temperature of the flux must be greater than temperatures for the currently listed fluxes.

Parameters

a_flux [in] The flux to add.

Returns: An error code. If not error, returns 0, otherwise returns non-0 value.

Definition at line 247 of file GIDI_settings_particle.cc.

                                             {
 
    double temperature = a_flux.temperature( );
    std::vector<Flux>::iterator iter;
 
    for( iter = m_fluxes.begin( ); iter != m_fluxes.end( ); ++iter ) {
        if( temperature <= iter->temperature( ) ) break;
    }
    if( iter != m_fluxes.end( ) ) return( 1 );
    m_fluxes.insert( iter, a_flux );
    return( 0 );
}

Referenced by Particle().

◆ collapseIndices()

std::vector< std::size_t > const & GIDI::Transporting::Particle::collapseIndices ( ) const

inline

Returns the value of the m_collapseIndices member.

Definition at line 3672 of file GIDI.hpp.

Referenced by GIDI::collapse(), GIDI::collapse(), and Particle().

◆ conserve()

Transporting::Conserve GIDI::Transporting::Particle::conserve ( ) const

inline

Returns the value of the m_conserve member.

Definition at line 3664 of file GIDI.hpp.

Referenced by Particle().

◆ fineMultiGroup()

MultiGroup GIDI::Transporting::Particle::fineMultiGroup ( ) const

inline

Returns the value of the m_fineMultiGroup member.

Definition at line 3669 of file GIDI.hpp.

Referenced by GIDI::Transporting::Settings::multiGroupZeroMatrix(), and GIDI::Transporting::Settings::multiGroupZeroVector().

◆ mode()

Transporting::Mode GIDI::Transporting::Particle::mode ( ) const

inline

Returns the value of the m_mode member.

Definition at line 3663 of file GIDI.hpp.

Referenced by Particle().

◆ multiGroup()

MultiGroup GIDI::Transporting::Particle::multiGroup ( ) const

inline

Returns the value of the m_multiGroup member.

Definition at line 3668 of file GIDI.hpp.

Referenced by MCGIDI::MultiGroupHash::MultiGroupHash(), and Particle().

◆ multiGroupIndexFromEnergy()

int GIDI::Transporting::Particle::multiGroupIndexFromEnergy	(	double	a_e_in,
		bool	a_encloseOutOfRange ) const

inline

Returns the coarse multi-group index corresponding to energy a_e_in. See MultiGroup::multiGroupIndexFromEnergy.

Definition at line 3665 of file GIDI.hpp.

◆ nearestProcessedFluxToTemperature()

ProcessedFlux const * GIDI::Transporting::Particle::nearestProcessedFluxToTemperature ( double a_temperature ) const

Returns the multi-group flux with its temperature closes to a_temperature.

Parameters

a_temperature [in] The temperature of the desired flux.

Definition at line 266 of file GIDI_settings_particle.cc.

                                                                                             {
 
    double priorTemperature, lastTemperature = 0;  // initialize to silence compiler warning
    std::vector<ProcessedFlux>::const_iterator iter;
 
    if( m_processedFluxes.size( ) == 0 ) return( nullptr );
 
    priorTemperature = m_processedFluxes[0].temperature( );
    for( iter = m_processedFluxes.begin( ); iter != m_processedFluxes.end( ); ++iter ) {
        lastTemperature = iter->temperature( );
        if( lastTemperature > a_temperature ) break;
    }
    if( iter == m_processedFluxes.end( ) ) {
        --iter; }
    else {
        if( fabs( lastTemperature - a_temperature ) < fabs( a_temperature - priorTemperature ) ) --iter;
    }
    return( &(*iter) );
}

Referenced by GIDI::collapse(), and GIDI::collapse().

◆ numberOfGroups()

std::size_t GIDI::Transporting::Particle::numberOfGroups ( ) const

inline

Returns the number of coarse multi-group groups.

Definition at line 3667 of file GIDI.hpp.

Referenced by GIDI::Transporting::Settings::multiGroupZeroMatrix(), and GIDI::Transporting::Settings::multiGroupZeroVector().

◆ pid()

std::string const & GIDI::Transporting::Particle::pid ( ) const

inline

Returns the value of the m_pid member.

Definition at line 3662 of file GIDI.hpp.

Referenced by GIDI::Transporting::Particles::add(), and Particle().

◆ print()

void GIDI::Transporting::Particle::print ( std::string const & a_indent ) const

Print Particle data to std::cout. Mainly for debugging.

Parameters

a_indent [in] The indent for each printed line.

Definition at line 364 of file GIDI_settings_particle.cc.

                                                      {
 
    std::string indent2( "  " );
    indent2 += a_indent;
 
    std::cout << a_indent << "particle: id = " << m_pid << std::endl;
    m_multiGroup.print( indent2 );
 
    std::cout << indent2;
    for( auto iter = m_collapseIndices.begin( ); iter != m_collapseIndices.end( ); ++iter ) std::cout << " " << *iter;
    std::cout << std::endl;
 
}

◆ process()

void GIDI::Transporting::Particle::process	(	Transportable const &	a_transportable,
		double	a_epsilon = 1e-6 )

For internal use only: should only be called from Particles::process. Determines the mapping of fine multi-group boundaries to coarse multi-group boundaries, and calculated multi-group fluxes from m_fluxes.

Parameters

a_transportable	[in] The Transportable instance that specified the coarse multi-group information for collapsing.
a_epsilon	[in] Specifies how close a coarse multi-group boundary must be to a fine multi-group boundary to be considered the same boundary.

Definition at line 294 of file GIDI_settings_particle.cc.

                                                                               {
 
    std::vector<double> groupBoundaries = a_transportable.groupBoundaries( );
    std::string errInfo( "cannot collapse particle '" + m_pid 
            + "' from multi-group '" + a_transportable.group( ).label( ) + "' of size " + std::to_string( groupBoundaries.size( ) ) 
            + " to multi-group '" + m_multiGroup.label( ) + "' of size " + std::to_string( m_multiGroup.boundaries( ).size( ) ) );
 
    if( m_mode != Transporting::Mode::MonteCarloContinuousEnergy ) {
        if( m_multiGroup.size( ) == 0 ) {
            m_multiGroup = MultiGroup( a_transportable.group( ).label( ), groupBoundaries );
        }
        if( m_fineMultiGroup.size( ) > 0 ) {
            if( m_fineMultiGroup.size( ) != groupBoundaries.size( ) )
                throw Exception( "For particle '" + m_pid + "', redefining particle's fine multi-group of different size not allowed." );
            for( std::size_t i1 = 0; i1 < m_fineMultiGroup.size( ); ++i1 ) {
                if( fabs( m_fineMultiGroup[i1] - groupBoundaries[i1] ) > a_epsilon * m_fineMultiGroup[i1] )
                    throw Exception( "For particle '" + m_pid + "', redefining particle's fine multi-group not allowed." );
            }
            return;                                 // Processing already done.
        }
 
        std::size_t i1 = 0, n1 = groupBoundaries.size( );
 
        while( i1 < n1 ) {
            if( fabs( m_multiGroup[0] - groupBoundaries[i1] ) <= a_epsilon * groupBoundaries[i1] ) break;
            ++i1;
        }
        if( i1 == n1 ) throw Exception( "Groups not compatible: " + errInfo + "." );
        m_collapseIndices.push_back( i1 );
     
        for( std::size_t i2 = 1; i2 < m_multiGroup.size( ); ++i2 ) {
            while( i1 < n1 ) {
                if( fabs( m_multiGroup[i2] - groupBoundaries[i1] ) <= a_epsilon * groupBoundaries[i1] ) break;
                ++i1;
            }
            if( i1 == n1 ) throw Exception( "Group boundaries not compatible: " + errInfo + "." );
            m_collapseIndices.push_back( i1 );
        }
 
        if( m_fluxes.size( ) == 0 ) {
            std::vector<double> fluxes;
            for( std::size_t index = 0; index < groupBoundaries.size( ) - 1; ++index ) {
                fluxes.push_back( groupBoundaries[index+1] - groupBoundaries[index] );
            }
            m_processedFluxes.push_back( ProcessedFlux( 0.0, fluxes ) ); }
        else {
            for( std::size_t i2 = 0; i2 < m_fluxes.size( ); ++i2 ) {
                ProcessedFlux __processedFlux( m_fluxes[i2].process( groupBoundaries ) );
                m_processedFluxes.push_back( __processedFlux );
            }
        }
 
        m_fineMultiGroup = a_transportable.group( );
    }
 
    if( a_transportable.conserve() == GIDI_conserveNumberChars ) {
        m_conserve = Transporting::Conserve::number;
    } else if( a_transportable.conserve() == GIDI_conserveEnergyOutChars ) {
        m_conserve = Transporting::Conserve::energyOut;
    } else {
        throw Exception( "Unrecognized particle conserve flag '" + a_transportable.conserve() + "'" );
    }
}

Referenced by process().

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Particle() [1/4]

◆ Particle() [2/4]

◆ Particle() [3/4]

◆ Particle() [4/4]

◆ ~Particle()

Member Function Documentation

◆ appendFlux()

◆ collapseIndices()

◆ conserve()

◆ fineMultiGroup()

◆ mode()

◆ multiGroup()

◆ multiGroupIndexFromEnergy()

◆ nearestProcessedFluxToTemperature()

◆ numberOfGroups()

◆ pid()

◆ print()

◆ process()