tstTransitionCoeff.cpp

./Core/dc/tests/tstTransitionCoeff.cpp

#include <cstdlib>
#include <iostream>

#include "Nemesis/gtest/nemesis_gtest.hh"
#include "Nemesis/harness/DBC.hh"
#include "Origen/Core/dc/FakeFactory.h"
#include "Origen/Core/dc/TransitionCoeff.h"
#include "Standard/Interface/SerialStream.h"

using namespace Origen;

void test_addEqOp( TransitionCoeff& tc1,
                   TransitionCoeff& tc2,
                   TransitionCoeff& tcTest );
void serialization_roundtrip( TransitionCoeff& d1 );

TEST( TransitionCoeff, Clone )
{
    TransitionCoeff tcOrig;
    LibraryHeader header = FakeFactory::createLibraryHeader_random1();
    FakeFactory::TransitionCoeff_random1( tcOrig, header );

    SP_TransitionCoeff tcClone = tcOrig.clone();
    ASSERT_TRUE( tcOrig == *tcClone );

    tcClone->scale( 1.5 );
    EXPECT_FALSE( tcOrig == *tcClone );
    EXPECT_FALSE( tcOrig.approx_eq( *tcClone ) );
}

TEST( TransitionCoeff, Scale )
{
    TransitionCoeff tc1;
    FakeFactory::TransitionCoeff_random2( tc1 );

    SP_TransitionCoeff tc2 = tc1.clone();
    tc2->scale( 1.05 );

    ASSERT_FLOAT_EQ( tc1.burnup() * 1.05, tc2->burnup() );

    // Check matrix
    ASSERT_EQ( tc1.matrix_size(), tc2->matrix_size() );
    for( size_t i = 0; i < tc1.matrix_size(); ++i )
    {
        ASSERT_FLOAT_EQ( tc1.matrix_array()[i] * 1.05, tc2->matrix_array()[i] );
    }

    // Check each value of fission cross-sections
    ASSERT_EQ( tc1.loss_xs_size(), tc2->loss_xs_size() );
    for( size_t i = 0; i < tc1.loss_xs_size(); ++i )
    {
        ASSERT_FLOAT_EQ( tc1.loss_xs_array()[i] * 1.05,
                         tc2->loss_xs_array()[i] );
    }

    // Check each value of fission cross-sections
    ASSERT_EQ( tc1.fission_xs_size(), tc2->fission_xs_size() );
    for( size_t i = 0; i < tc1.fission_xs_size(); ++i )
    {
        ASSERT_FLOAT_EQ( tc1.fission_xs_array()[i] * 1.05,
                         tc2->fission_xs_array()[i] );
    }

    // Check each value of neutron yields
    ASSERT_EQ( tc1.neutron_yields_size(), tc2->neutron_yields_size() );
    for( size_t i = 0; i < tc1.neutron_yields_size(); ++i )
    {
        ASSERT_FLOAT_EQ( tc1.neutron_yields_array()[i] * 1.05,
                         tc2->neutron_yields_array()[i] );
    }

    // Check each value of flux
    ASSERT_EQ( tc1.flux_size(), tc2->flux_size() );
    for( size_t i = 0; i < tc1.flux_size(); ++i )
    {
        ASSERT_FLOAT_EQ( tc1.flux_array()[i] * 1.05, tc2->flux_array()[i] );
    }

    // Check each value of kappa fission
    ASSERT_EQ( tc1.kappa_fission_size(), tc2->kappa_fission_size() );
    for( size_t i = 0; i < tc1.kappa_fission_size(); ++i )
    {
        ASSERT_FLOAT_EQ( tc1.kappa_fission_array()[i] * 1.05,
                         tc2->kappa_fission_array()[i] );
    }

    // Check each value of kappa capture
    ASSERT_EQ( tc1.kappa_capture_size(), tc2->kappa_capture_size() );
    for( size_t i = 0; i < tc1.kappa_capture_size(); ++i )
    {
        ASSERT_FLOAT_EQ( tc1.kappa_capture_array()[i] * 1.05,
                         tc2->kappa_capture_array()[i] );
    }
}

TEST( TransitionCoeff, ApproxEq )
{
    TransitionCoeff tc1;
    FakeFactory::TransitionCoeff_random2( tc1 );

    TransitionCoeff tc2( tc1 );
    EXPECT_TRUE( tc1.approx_eq( tc2 ) );

    tc2.scale( 0.8 );
    tc2.scale( 1.25 );
    EXPECT_TRUE( tc1.approx_eq( tc2 ) );
}

TEST( TransitionCoeff, AddEqOpNoKappa )
{
    TransitionCoeff tc1, tc2;
    LibraryHeader header = FakeFactory::createLibraryHeader_random1();

    FakeFactory::TransitionCoeff_random1( tc1, header );
    FakeFactory::TransitionCoeff_random1( tc2, header );

    auto tcTest = tc1.clone();
    *tcTest += tc2;
    test_addEqOp( tc1, tc2, *tcTest );
}

TEST( TransitionCoeff, AddEqOpKappa )
{
    TransitionCoeff tc1, tc2;

    FakeFactory::TransitionCoeff_random2( tc1 );
    FakeFactory::TransitionCoeff_random2( tc2 );

    auto tcTest = tc1.clone();
    *tcTest += tc2;
    test_addEqOp( tc1, tc2, *tcTest );
}

TEST( TransitionCoeff, SerializeNoKappa )
{
    TransitionCoeff d1;
    LibraryHeader header = FakeFactory::createLibraryHeader_random1();
    FakeFactory::TransitionCoeff_random1( d1, header );
    serialization_roundtrip( d1 );
}

TEST( TransitionCoeff, SerializeWithKappa )
{
    TransitionCoeff d1;
    FakeFactory::TransitionCoeff_random2( d1 );
    serialization_roundtrip( d1 );
}

void test_addEqOp( TransitionCoeff& tc1,
                   TransitionCoeff& tc2,
                   TransitionCoeff& tcTest )
{
    EXPECT_FLOAT_EQ( tcTest.burnup(), ( tc1.burnup() + tc2.burnup() ) );
    for( size_t i = 0; i != tcTest.matrix_size(); ++i )
    {
        EXPECT_FLOAT_EQ( tcTest.matrix_array()[i],
                         ( tc1.matrix_array()[i] + tc2.matrix_array()[i] ) );
    }
    for( size_t i = 0; i != tcTest.loss_xs_size(); ++i )
    {
        EXPECT_FLOAT_EQ( tcTest.loss_xs_array()[i],
                         ( tc1.loss_xs_array()[i] + tc2.loss_xs_array()[i] ) );
    }
    for( size_t i = 0; i != tcTest.fission_xs_size(); ++i )
    {
        EXPECT_FLOAT_EQ(
            tcTest.fission_xs_array()[i],
            ( tc1.fission_xs_array()[i] + tc2.fission_xs_array()[i] ) );
    }
    for( size_t i = 0; i != tcTest.neutron_yields_size(); ++i )
    {
        EXPECT_FLOAT_EQ(
            tcTest.neutron_yields_array()[i],
            ( tc1.neutron_yields_array()[i] + tc1.neutron_yields_array()[i] ) );
    }
    for( size_t i = 0; i != tcTest.flux_size(); ++i )
    {
        EXPECT_FLOAT_EQ( tcTest.flux_array()[i],
                         ( tc1.flux_array()[i] + tc2.flux_array()[i] ) );
    }

    for( size_t i = 0; i != tcTest.kappa_capture_size(); ++i )
    {
        EXPECT_FLOAT_EQ(
            tcTest.kappa_capture_array()[i],
            ( tc1.kappa_capture_array()[i] + tc2.kappa_capture_array()[i] ) );
    }
    for( size_t i = 0; i != tcTest.kappa_fission_size(); ++i )
    {
        EXPECT_FLOAT_EQ(
            tcTest.kappa_fission_array()[i],
            ( tc1.kappa_fission_array()[i] + tc2.kappa_fission_array()[i] ) );
    }
}

void serialization_roundtrip( TransitionCoeff& d1 )
{
    //
    // Serialize
    //
    SerialStream ss;
    int return_code = d1.serialize( &ss );
    ASSERT_EQ( return_code, 0 );

    //
    // Deserialize
    //
    TransitionCoeff d2;
    return_code = d2.deserialize( &ss );
    EXPECT_EQ( return_code, 0 );
    jDebugLine( d1.toString() );
    EXPECT_TRUE( d1 == d2 );
}